did resolver

TypeScript a résolté

Cette bibliothèque est destinée à une simple interface commune pour les applications JavaScript pour résoudre les documents DID des identifiants décentralisés (DIDS).

Ceci est destiné à soutenir les spécificateurs décentralisés proposés du groupe communautaire des informations d'identification W3C.

La bibliothèque n'implémente aucune méthode DID spécifique, mais permet aux implémentateurs de méthode DID de publier des packages NPM que les applications peuvent ajouter.

Configurer l'objet Resolver

Vous devez maintenant préconermer un résolveur pendant l'instanciation. Le constructeur Resolver s'attend à un registre des méthodes mappés à une fonction de résolveur. Par exemple:

 {
  ethr : resolve ,
  web : resolve
}

Chaque résolver de méthode doit exposer une fonction appelée getResolver qui renverra un objet contenant l'une de ces paires de clés / valeur. Ensuite, vous pouvez les aplatir dans un seul objet pour passer dans le constructeur 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 )

Utilisation de Resolvers de méthode de l'héritage

DID Method Resolvers créé avant la version 3.0.0 de cette bibliothèque peut être utilisée comme résolveurs hérités.

 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 ) 

Résoudre un document DI

Le résolveur présente une fonction simple resolve() qui renvoie une promesse ES6 renvoyant le document 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' ) 

Mise en cache

La résolution des documents DID peut être coûteuse. Il est dans la plupart des cas mieux de mettre en cache des documents. La mise en cache doit être spécifiquement activée à l'aide du paramètre cache

Le cache intégré utilise une carte, mais n'a pas de TTL automatique, donc les entrées n'expirent pas. C'est bien dans la plupart des contextes Web, mobiles et sans serveur. Si vous exécutez un processus de longue date, vous souhaiterez peut-être utiliser un système de mise en cache configurable existant.

Le cache intégré peut être activé en transmettant une true valeur au constructeur:

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

Voici un exemple utilisant js-cache qui n'a pas été testé.

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

Implémentation d'une méthode DID

Chaque méthode DID aura ses propres méthodes pour rechercher un identifiant sur sa blockchain respective ou un autre mécanisme de stockage décentralisé.

Pour éviter une mauvaise configuration, les implémentateurs de méthode doivent exporter une fonction getResolver() qui renvoie un objet mappant le nom de la méthode dans une resolve(did: string, parsed: ParsedDID, didResolver: DIDResolver, options: DIDResolutionOptions) . par exemple { ethr: resolve } .

La fonction de résolution doit accepter une chaîne DID et un objet de type 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 }
}

Le résultat MyMethod getResolver() pourrait ensuite être transmis dans le constructeur DitreSolver. Notez qu'il doit être aplati s'il est également utilisé avec d'autres méthodes.

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

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