did resolver

TypeScript hizo resolución

Esta biblioteca se pretende como una interfaz común simple para que las aplicaciones de JavaScript resuelvan documentos de identificadores descentralizados (DIDS).

Esto está destinado a respaldar las especificaciones de identificadores descentralizados propuestos del Grupo Comunitario de Credenciales W3C.

La biblioteca no implementa ningún método DID específico, pero permite que los implementadores de métodos DID publiquen paquetes NPM que las aplicaciones pueden agregar.

Configurar el objeto Resolver

Ahora debe preconfigurar un resolución durante la instancia. El constructor Resolver espera un registro de métodos asignados a una función de resolución. Por ejemplo:

 {
  ethr : resolve ,
  web : resolve
}

Cada resolución de métodos debe exponer una función llamada getResolver que devolverá un objeto que contenga uno de estos pares de clave/valor. Luego puede aplanarlos en un objeto para pasar al constructor 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 resolutores de métodos de Legacy DIS

Los resueltos de métodos creados antes de la versión 3.0.0 de esta biblioteca se pueden usar como resolución heredado.

 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 ) 

Resolviendo un documento DIS

El resolución presenta una función resolve() que devuelve una promesa de ES6 que devuelve el 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' ) 

Almacenamiento en caché

Resolver documentos DID puede ser costoso. En la mayoría de los casos, es mejor hacer caché documentos. El almacenamiento en caché debe estar habilitado específicamente utilizando el parámetro cache

El caché incorporado usa un mapa, pero no tiene un TTL automático, por lo que las entradas no caducan. Esto está bien en la mayoría de los contextos web, móvil y sin servidor. Si ejecuta un proceso de larga duración, es posible que desee utilizar un sistema de almacenamiento de almacenamiento configurable existente.

El caché incorporado se puede habilitar pasando en un valor true al constructor:

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

Aquí hay un ejemplo que usa js-cache que no se ha probado.

 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
} ) 

Implementación de un método DID

Cada método DID tendrá sus propios métodos para buscar un identificador en su respectiva blockchain u otro mecanismo de almacenamiento descentralizado.

Para evitar la configuración errónea, los implementadores del método deben exportar una función getResolver() que devuelve un objeto que mapee el nombre del método a una resolve(did: string, parsed: ParsedDID, didResolver: DIDResolver, options: DIDResolutionOptions) funcionan. Eg { ethr: resolve } .

La función de resolución debe aceptar una cadena DID y un objeto de 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 }
}

El resultado mymethod getResolver() podría pasar al constructor didresolver. Tenga en cuenta que debe aplanarse si también se usa con otros métodos.

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

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