did resolver

TypeScript fez resolvedor

Esta biblioteca se destina a uma interface comum simples para aplicativos JavaScript para resolver documentos DID de identificadores descentralizados (DIDs).

Isso se destina a apoiar as especificações de identificadores descentralizados propostos do Grupo Comunitário de Credenciais do W3C.

A biblioteca não implementa nenhum método específico de DID, mas permite que os implementadores de métodos liberem pacotes NPM que os aplicativos podem adicionar.

Configure o objeto Resolver

Agora você deve pré -configurar um resolvedor durante a instanciação. O Construtor Resolver espera um registro de métodos mapeado para uma função de resolvedor. Por exemplo:

 {
  ethr : resolve ,
  web : resolve
}

Cada resolvedor de método deve expor uma função chamada getResolver , que retornará um objeto que contém um desses pares de chave/valor. Em seguida, você pode achatá -los em um objeto para passar para o construtor Resolver .

 import { Resolver } from 'did-resolver'
import ethr from 'ethr-did-resolver'
import web from 'web-did-resolver'
import sov from 'sov-did-resolver'

//returns an object of { methodName: resolveFunction}
ethrResolver = ethr . getResolver ( )
webResolver = web . getResolver ( )

//If you are using multiple methods you need to flatten them into one object
const resolver = new Resolver ( {
  ... ethrResolver ,
  ... webResolver ,
} )

//If you are using one method you can simply pass the result of getResolver( into the constructor
const resolver = new Resolver ( ethrResolver )

Usando os resolvedores de método do Legacy fez

Os resolvedores de método criados antes da versão 3.0.0 desta biblioteca podem ser usados ​​como resolvedores legados.

 import { Resolver } from 'did-resolver'
import web from 'web-did-resolver'
import sov from 'sov-did-resolver'

//returns an object of { methodName: resolveFunction}
webResolver = web . getResolver ( )
sovResolver = sov . getResolver ( )

//If you are using multiple methods you need to flatten them into one object
const resolver = new Resolver ( { } , {
  legacyResolvers : {
    ... webResolver ,
    ... sovResolver ,
  }
} )

//If you are using one method you can simply pass the result of getResolver( into the constructor
const resolver = new Resolver ( ethrResolver ) 

Resolvendo um documento DID

O resolvedor apresenta uma função de resolve() que retorna uma promessa ES6 que retorna o documento DID.

 resolver . resolve ( 'did:ethr:0xF3beAC30C498D9E26865F34fCAa57dBB935b0D74/some/path#fragment=123' ) . then ( doc => console . log )

// You can also use ES7 async/await syntax
const doc = await resolver . resolve ( 'did:ethr:0xF3beAC30C498D9E26865F34fCAa57dBB935b0D74/some/path#fragment=123' ) 

Cache

Resolver documentos DId pode ser caro. Na maioria dos casos, é melhor o cache fazer documentos. O cache deve ser ativado especificamente usando o parâmetro cache

O cache embutido usa um mapa, mas não possui um TTL automático, para que as entradas não expirem. Isso é bom nos contextos da maioria da web, móveis e sem servidor. Se você executar um processo de longa duração, poderá usar um sistema de cache configurável existente.

O cache interno pode ser ativado passando um valor true para o construtor:

 const resolver = new DIDResolver ( {
  ethr ,
  web
} , {
  cache : true
} )

Aqui está um exemplo usando js-cache que não foi testado.

 var cache = require ( 'js-cache' )
const customCache : DIDCache = ( parsed , resolve ) => {
  // DID spec requires to not cache if no-cache param is set
  if ( parsed . params && parsed . params [ 'no-cache' ] === 'true' ) return await resolve ( )
  const cached = cache . get ( parsed . didUrl )
  if ( cached !== undefined ) return cached
  const doc = await resolve ( )
  cache . set ( parsed , doc , 60000 )
  return doc
}

const resolver = new DIDResolver ( {
  ethr ,
  web
} , {
  cache : customCache
} ) 

Implementando um método DID

Cada método do DID terá seus próprios métodos para procurar um identificador em sua respectiva blockchain ou outro mecanismo de armazenamento descentralizado.

Para evitar a configuração incorreta, os implementadores do método devem exportar uma função getResolver() que retorne um objeto que mapeando o nome do método para uma resolve(did: string, parsed: ParsedDID, didResolver: DIDResolver, options: DIDResolutionOptions) Função. por exemplo, { ethr: resolve } .

A função de resolução deve aceitar uma string de DID e um objeto do tipo Parseddid

 export function getResolver ( ) {
  async function resolve (
    did : string ,
    parsed : ParsedDID ,
    didResolver : Resolver ,
    options : DIDResolutionOptions
  ) : Promise < DIDDocument > {
    console . log ( parsed )
    // {method: 'mymethod', id: 'abcdefg', did: 'did:mymethod:abcdefg/some/path#fragment=123', path: '/some/path', fragment: 'fragment=123'}
    const didDoc = ... // lookup doc
    // If you need to lookup another did as part of resolving this did document, the primary DIDResolver object is passed in as well
    const parentDID = await didResolver . resolve ( ... )
    // Return the DIDResolutionResult object
    return {
      didResolutionMetadata : { contentType : 'application/did+ld+json' } ,
      didDocument : didDoc
      didDocumentMetadata : { ... }
    }
  }

  return { myMethod : resolve }
}

O resultado MyMethod getResolver() pode ser passado para o construtor DidResolver. Observe que ele deve ser achatado se usado com outros métodos também.

 import { DIDResolver } from 'did-resolver'
import MyMethod from 'mymethod-did-resolver'

const myResolver = MyMethod . getResolver ( )
const resolver = new DIDResolver ( myResolver )