did resolver

TypeScript hat es gelöst

Diese Bibliothek ist als einfache gemeinsame Schnittstelle für JavaScript -Anwendungen gedacht, um Dokumente aus dezentralen Kennungen (DIDS) zu lösen.

Dies soll die vorgeschlagene dezentrale Identifikatoren der W3C -Anmeldeinformationen Community Group unterstützen.

Die Bibliothek implementiert keine spezifische DID -Methode, ermöglicht es DID -Methodenimplementierern jedoch, NPM -Pakete zu veröffentlichen, die Anwendungen hinzufügen können.

Konfigurieren Resolver -Objekt

Sie müssen jetzt einen Resolver während der Instanziierung vorkonfigurieren. Der Resolver -Konstruktor erwartet eine Registrierung von Methoden, die einer Resolver -Funktion zugeordnet sind. Zum Beispiel:

 {
  ethr : resolve ,
  web : resolve
}

Jeder Methode -Resolver sollte eine Funktion namens getResolver freilegen, die ein Objekt zurückgibt, das eines dieser Schlüssel-/Wertpaare enthält. Dann können Sie sie in ein Objekt überflachen, um in den Resolver -Konstruktor zu gelangen.

 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 )

Verwenden von Legacy -Methoden -Resolvers

Haben Methodenreserve, die vor Version 3.0.0 dieser Bibliothek erstellt wurden, als ältere Resolver verwendet werden.

 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 ) 

Auflösung eines Dokuments

Der Resolver präsentiert eine einfache resolve() -Funktion, die ein ES6 -Versprechen zurückgibt, das das DID -Dokument zurückgibt.

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

Ausschnitt

Auflösungsdokumente können teuer sein. In den meisten Fällen ist es am besten, Dokumente durch Cache zu machen. Das Caching muss speziell mit dem cache -Parameter aktiviert werden

Der integrierte Cache verwendet eine Karte, hat jedoch keine automatische TTL, sodass Einträge nicht verfallen. Dies ist in den meisten Web-, Mobil- und serverlosen Kontexten in Ordnung. Wenn Sie einen langjährigen Prozess ausführen, möchten Sie möglicherweise ein vorhandenes konfigurierbares Caching-System verwenden.

Der eingebaute Cache kann aktiviert werden, indem ein true Wert an den Konstruktor weitergegeben wird:

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

Hier ist ein Beispiel mit js-cache , das nicht getestet wurde.

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

Implementierung einer DID -Methode

Jede Methode verfügt über eigene Methoden, um eine Kennung für seine jeweilige Blockchain oder einen anderen dezentralen Speichermechanismus zu suchen.

Um eine Missverständnis zu vermeiden, sollten Methodenimplementierer eine getResolver() -Funktion exportieren, die einen Objekt -Zuordnen des Methodennamens in eine resolve(did: string, parsed: ParsedDID, didResolver: DIDResolver, options: DIDResolutionOptions) . zB { ethr: resolve } .

Die Auflösungsfunktion sollte eine DID -String und ein Objekt vom Typ ParsedDid akzeptieren

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

Das Ergebnis von MyMethod getResolver() könnte dann in den Didresolver -Konstruktor übergeben werden. Beachten Sie, dass es abgeflacht werden sollte, wenn es auch mit anderen Methoden verwendet wird.

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

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