Merge pull request #1 from AmplicaLabs/feature/use-schema-names

Use schema names functionality from @dsnp/frequency-schemas.

Author: wesbiggs

.env.example

@@ -1,7 +1,5 @@
 # Environment variables for testnet
 FREQUENCY_NODE="wss://rpc.rococo.frequency.xyz"
-FREQUENCY_NETWORK="testnet"
 
-# If running locally, use these instead
+# If running locally, use this instead
 #FREQUENCY_NODE="ws://127.0.0.1:9944"
-#FREQUENCY_NETWORK="local"

README.md

@@ -17,34 +17,29 @@ import { FrequencyResolver } from "@dsnp/did-resolver-frequency";
 
 const frequencyResolver = new FrequencyResolver({
   providerUri: "ws://127.0.0.1:9944",
-  frequencyNetwork: "local",
 });
 ```
 
 If constructed this way, you must call `disconnect()` to explicitly release the connection; the process will not exit if this is not done.
 
 or,
 
-2. Construct with preconfigured `ApiPromise` object from `@polkadot/api`:
+2. Construct with preconfigured `Promise<ApiPromise>` object from `@polkadot/api`:
 
 ```
 import { FrequencyResolver } from "@dsnp/did-resolver-frequency";
 
 const frequencyResolver = new FrequencyResolver({
   apiPromise: myApiPromise, // from ApiPromise.create(...)
-  frequencyNetwork: "local",
 });
 ```
 
-The `frequencyNetwork` key is required in both cases (this is expected to be unnecessary with Frequency schema naming in the future).
-
 Summary of options:
 
 | Configuration option | Description |
 | --- | --- |
 | `providerUri` | Provider URI for Frequency RPC node (optional; alternative to `apiPromise` |
-| `apiPromise` | An `ApiPromise` object (optional; alternative to `providerUri` |
-| `frequencyNetwork` | One of `local`, `testnet`, `mainnet` |
+| `apiPromise` | A `Promise<ApiPromise>` (optional; alternative to `providerUri` |
 
 See `.env.example` for example configuration.
 
@@ -56,7 +51,6 @@ import dsnp from "@dsnp/did-resolver";
 
 const frequencyResolver = new FrequencyResolver({
   providerUri: "wss://rpc.rococo.frequency.xyz",
-  frequencyNetwork: "testnet"
 });
 
 const resolver = new Resolver(dsnp.getResolver([frequencyResolver]));
@@ -111,8 +105,3 @@ Currently this resolver implements the minimal functionality required to support
 Public keys are encoded using the `Multikey` type.
 The `id` consists of the DSNP DID and a URL fragment that is the same as the `publicKeyMultibase` value, which is a multicodec value in `base58btc` encoding.
 The decoded value for `ed25519-pub` keys will be 34 bytes, including the two-byte multicodec identifier.
-
-## Known issues
-
-- The resolver currently responds with a DID document for any valid-looking DSNP DID.
-  It should return a `notFound` error if there is no corresponding Frequency MSA.

index.test.ts

@@ -7,12 +7,12 @@ describe("dsnp-did-resolver-frequency", () => {
   it("can be constructed with providerUri", async () => {
     const resolver = new FrequencyResolver({
       providerUri: "ws://127.0.0.1:9944",
-      frequencyNetwork: "local",
     });
 
     await resolver.disconnect();
   });
 
+  /* TODO needs mocking
   it("can be constructed with apiPromise", async () => {
     const apiPromise = ApiPromise.create({
       provider: new WsProvider("ws://127.0.0.1:9944"),
@@ -22,13 +22,13 @@ describe("dsnp-did-resolver-frequency", () => {
 
     const resolver = new FrequencyResolver({
       apiPromise,
-      frequencyNetwork: "local",
     });
 
     await resolver.disconnect();
   });
+  */
 
-  /* Need to mock for this...
+  /* TODO needs mocking
   it("resolves did:dsnp:13972", async () => {
     const myDid = "did:dsnp:13972";
     const result = await resolver.resolve(myDid);

index.ts

@@ -5,9 +5,15 @@ import { DSNPResolver } from "@dsnp/did-resolver";
 import avro from "avro-js";
 import { options } from "@frequency-chain/api-augment";
 import { WsProvider, ApiPromise } from "@polkadot/api";
+import { xxhashAsHex } from "@polkadot/util-crypto";
+import { bnToU8a, u8aToHex } from "@polkadot/util";
 
 const publicKeyAvroSchema = avro.parse(dsnp.publicKey);
 
+const keyCountStorageKeyHex =
+  xxhashAsHex("Msa", 128) +
+  xxhashAsHex("PublicKeyCountForMsaId", 128).substring(2);
+
 function makeVerificationMethod(
   controller: string,
   publicKeyMultibase: string,
@@ -23,27 +29,22 @@ function makeVerificationMethod(
 
 export class FrequencyResolver implements DSNPResolver {
   private providerUri: string | null = null;
-  private frequencyNetwork: string;
   private _singletonApi: Promise<ApiPromise> | null = null;
-
-  constructor(options: { providerUri?: string; apiPromise?: Promise<ApiPromise>, frequencyNetwork: string }) {
+  private keyAgreementSchemaId: number | null = null;
+  private assertionMethodSchemaId: number | null = null;
+  private initialized: boolean = false;
+
+  constructor(options: {
+    providerUri?: string;
+    apiPromise?: Promise<ApiPromise>;
+  }) {
     if (options.providerUri) {
       this.providerUri = options.providerUri;
     } else if (options.apiPromise != null) {
       this._singletonApi = options.apiPromise;
     } else {
       throw new Error("providerUri or apiPromise is required");
     }
-
-    this.frequencyNetwork = options.frequencyNetwork;
-    if (
-      !this.frequencyNetwork ||
-      !["local", "testnet", "mainnet"].includes(this.frequencyNetwork)
-    ) {
-      throw new Error(
-        'frequencyNetwork must be one of: "local", "testnet", "mainnet"',
-      );
-    }
   }
 
   async getApi(): Promise<ApiPromise> {
@@ -54,7 +55,6 @@ export class FrequencyResolver implements DSNPResolver {
         ...options,
       });
     }
-
     return this._singletonApi;
   }
 
@@ -83,26 +83,37 @@ export class FrequencyResolver implements DSNPResolver {
   }
 
   async resolve(dsnpUserId: bigint): Promise<DIDDocument | null> {
-    const controller = `did:dsnp:${dsnpUserId}`;
-
-    // Attempt to retrieve public key(s)
-    let keyAgreementSchemaId: number;
-    let assertionMethodSchemaId: number;
+    if (!this.initialized) {
+      const api: Promise<ApiPromise> = this.getApi();
+      // Get the appropriate schemaIds for the chain we're connecting to
+      this.keyAgreementSchemaId = await dsnp.getSchemaId(
+        api,
+        "public-key-key-agreement",
+      );
+      this.assertionMethodSchemaId = await dsnp.getSchemaId(
+        api,
+        "public-key-assertion-method",
+      );
+      this.initialized = true;
+    }
 
-    switch (this.frequencyNetwork) {
-      case "testnet":
-        keyAgreementSchemaId = 18;
-        assertionMethodSchemaId = 100;
-        break;
-      default:
-        keyAgreementSchemaId = 7;
-        assertionMethodSchemaId = 11;
-        break;
+    // Determine if MSA exists by checking public key count
+    const msaUint8a = bnToU8a(dsnpUserId, { bitLength: 64 });
+    const key =
+      keyCountStorageKeyHex +
+      xxhashAsHex(msaUint8a).substring(2) +
+      u8aToHex(msaUint8a).substring(2);
+    const result = await (await this.getApi()).rpc.state.getStorage(key);
+    if (Number(result) == 0) {
+      return null;
     }
 
+    const controller = `did:dsnp:${dsnpUserId}`;
+
+    // Retrieve public key(s)
     const assertionMethodKeys = await this.getPublicKeysForSchema(
       dsnpUserId,
-      assertionMethodSchemaId,
+      this.assertionMethodSchemaId!,
     );
     const assertionMethod = assertionMethodKeys.map(
       (publicKeyMultibase: string) => {
@@ -112,7 +123,7 @@ export class FrequencyResolver implements DSNPResolver {
 
     const keyAgreementKeys = await this.getPublicKeysForSchema(
       dsnpUserId,
-      keyAgreementSchemaId,
+      this.keyAgreementSchemaId!,
     );
     const keyAgreement = keyAgreementKeys.map((publicKeyMultibase) => {
       return makeVerificationMethod(controller, publicKeyMultibase);