@docknetwork/wallet-sdk-relay-service 0.4.22 → 1.4.0

package/lib/payloads.mjs

@@ -0,0 +1,132 @@
+import { _ as _asyncToGenerator, a as _regeneratorRuntime, d as _createForOfIteratorHelper } from './_rollupPluginBabelHelpers-78739aa5.js';
+import VerifiableCredential from '@docknetwork/sdk/verifiable-credential';
+import { cryptoWaitReady } from '@polkadot/util-crypto';
+import { getSuiteFromKeyDoc } from '@docknetwork/sdk/utils/vc/helpers';
+import { getKeypairFromDoc } from '@docknetwork/universal-wallet/methods/keypairs';
+import assert from 'assert';
+import base64url from 'base64url';
+
+// 1 year
+var DEFAULT_EXPIRATION = 86400 * 1000 * 365;
+var isDIDDockRegex = /did:dock/gi;
+function ensureDIDDockFragment(keyDoc) {
+  if (!isDIDDockRegex.test(keyDoc.id)) {
+    return keyDoc;
+  }
+  keyDoc.id = keyDoc.id.replace(/#.+/, '');
+  keyDoc.id = "".concat(keyDoc.id, "#keys-1");
+  return keyDoc;
+}
+function generateSignedPayload(_x, _x2) {
+  return _generateSignedPayload.apply(this, arguments);
+}
+function _generateSignedPayload() {
+  _generateSignedPayload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(keyPairDoc, subject) {
+    var cred, keyPair, suite;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          assert(!!keyPairDoc, 'keyPairDoc is required');
+          assert(!!subject, 'subject is required');
+          _context.next = 4;
+          return cryptoWaitReady();
+        case 4:
+          keyPairDoc = ensureDIDDockFragment(keyPairDoc);
+          cred = new VerifiableCredential('dock:relay');
+          cred.setContext(['https://www.w3.org/2018/credentials/v1', {
+            dk: 'https://ld.dock.io/credentials#',
+            RelayAuthCredential: 'dk:RelayAuthCredential',
+            token: 'dk:token',
+            limit: 'dk:limit',
+            to: 'dk:to',
+            msg: 'dk:msg'
+          }]);
+          cred.setIssuanceDate(new Date().toISOString());
+          cred.setExpirationDate(new Date(Date.now() + DEFAULT_EXPIRATION).toISOString());
+          cred.setSubject(subject);
+          cred.setIssuer(keyPairDoc.controller);
+          cred.addType('RelayAuthCredential');
+          keyPair = getKeypairFromDoc(keyPairDoc);
+          keyPair.signer = keyPair.signer();
+          _context.next = 16;
+          return getSuiteFromKeyDoc(keyPair);
+        case 16:
+          suite = _context.sent;
+          _context.next = 19;
+          return cred.sign(suite);
+        case 19:
+          return _context.abrupt("return", {
+            payload: [subject, cred.issuanceDate, cred.expirationDate, cred.toJSON().proof],
+            did: keyPairDoc.controller
+          });
+        case 20:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _generateSignedPayload.apply(this, arguments);
+}
+function generateSignedPayloadFromList(_x3, _x4) {
+  return _generateSignedPayloadFromList.apply(this, arguments);
+}
+function _generateSignedPayloadFromList() {
+  _generateSignedPayloadFromList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(keyPairDocs, subject) {
+    var payload, dids, _iterator, _step, keyPairDoc, _yield$generateSigned, signedPayload, did;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          payload = [];
+          dids = [];
+          _iterator = _createForOfIteratorHelper(keyPairDocs);
+          _context2.prev = 3;
+          _iterator.s();
+        case 5:
+          if ((_step = _iterator.n()).done) {
+            _context2.next = 16;
+            break;
+          }
+          keyPairDoc = _step.value;
+          _context2.next = 9;
+          return generateSignedPayload(keyPairDoc, subject);
+        case 9:
+          _yield$generateSigned = _context2.sent;
+          signedPayload = _yield$generateSigned.payload;
+          did = _yield$generateSigned.did;
+          payload.push(signedPayload);
+          dids.push(did);
+        case 14:
+          _context2.next = 5;
+          break;
+        case 16:
+          _context2.next = 21;
+          break;
+        case 18:
+          _context2.prev = 18;
+          _context2.t0 = _context2["catch"](3);
+          _iterator.e(_context2.t0);
+        case 21:
+          _context2.prev = 21;
+          _iterator.f();
+          return _context2.finish(21);
+        case 24:
+          return _context2.abrupt("return", {
+            payload: payload,
+            dids: dids
+          });
+        case 25:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[3, 18, 21, 24]]);
+  }));
+  return _generateSignedPayloadFromList.apply(this, arguments);
+}
+function toBase64(payload) {
+  return base64url.encode(JSON.stringify(payload));
+}
+function fromBase64(payload) {
+  return JSON.parse(base64url.decode(payload));
+}
+
+export { ensureDIDDockFragment, fromBase64, generateSignedPayload, generateSignedPayloadFromList, toBase64 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@docknetwork/wallet-sdk-relay-service",
-    "version": "0.4.22",
+    "version": "1.4.0",
     "license": "https://github.com/docknetwork/react-native-sdk/LICENSE",
     "repository": {
         "type": "git",
@@ -14,7 +14,7 @@
         "uuid": "^9.0.0",
         "@docknetwork/minimal-cipher": "^5.2.1",
         "@docknetwork/sdk": "8.6.0",
-        "@docknetwork/wallet-sdk-wasm": "0.4.19"
+        "@docknetwork/wallet-sdk-wasm": "1.4.0"
     },
     "devDependencies": {
         "jest": "29.1.0",

package/src/didcomm.js

@@ -4,6 +4,7 @@ import {Ed25519VerificationKey2020} from '@digitalbazaar/ed25519-verification-ke
 import {Cipher} from '@docknetwork/minimal-cipher';
 import {v1 as uuidv1} from 'uuid';
 import base64url from 'base64url';
+import * as bs58 from 'base58-universal';
 
 import {resolveDID} from './did/dids';
 
@@ -180,15 +181,27 @@ export function isDerivableKey(keyDoc) {
   );
 }
 
+function getDIDKeydocsFromDIDDocument(didDocument) {
+  return [
+    ...potentialToArray(didDocument.verificationMethod),
+    ...potentialToArray(didDocument.keyAgreement),
+    ...potentialToArray(didDocument.publicKey),
+  ];
+}
+
 export async function getAgreementKeydocFromDID(did) {
   if (!did) {
     return undefined;
   }
 
+  // Early out for polygon DIDs as they dont support this
+  if (did.startsWith('did:polygon')) {
+    throw new Error('PolygonID DIDs cannot be used for DIDComm purposes');
+  }
+
   // Resolve actual DID document and get key agreement keys
   const isDIDUrl = did.indexOf('#') !== -1;
   const didDocument = await resolveDID(did);
-
   const keyAgreements = didDocument.keyAgreement
     ? Array.isArray(didDocument.keyAgreement)
       ? didDocument.keyAgreement
@@ -214,11 +227,7 @@ export async function getAgreementKeydocFromDID(did) {
   }
 
   // No valid key agreement found on resolution, lets derive one from a ED25519 key if we can
-  const publicKeys = didDocument.publicKey
-    ? Array.isArray(didDocument.publicKey)
-      ? didDocument.publicKey
-      : [didDocument.publicKey]
-    : [];
+  const publicKeys = getDIDKeydocsFromDIDDocument(didDocument);
 
   // See if DID document has any derivable keys
   const derivableKey = publicKeys.filter(isDerivableKey)[0];
@@ -231,26 +240,43 @@ export async function getAgreementKeydocFromDID(did) {
   );
 }
 
+export const MULTIBASE_BASE58BTC_HEADER = 'z';
+export const MULTICODEC_ED25519_PRIV_HEADER = new Uint8Array([0x80, 0x26]);
+export const MULTICODEC_ED25519_PUB_HEADER = new Uint8Array([0xed, 0x01]);
+export function encodeMbKey(header, key) {
+  const mbKey = new Uint8Array(header.length + key.length);
+  mbKey.set(header);
+  mbKey.set(key, header.length);
+  return MULTIBASE_BASE58BTC_HEADER + bs58.encode(mbKey);
+}
+
 export async function getDerivedAgreementKey(derivableKey) {
   if (!isDerivableKey(derivableKey)) {
     throw new Error(`Cannot derive X25519 KAK from type: ${derivableKey.type}`);
   }
 
-  if (!derivableKey.publicKeyMultibase) {
-    derivableKey.publicKeyMultibase = derivableKey.publicKeyBase58;
-  }
-
-  // Convert derivable key into latest 2020 format
-  const ed2020VerificationKey = await Ed25519VerificationKey2020.from({
-    keyPair: derivableKey,
-    ...derivableKey,
-  });
+  const publicKeyMultibase = derivableKey.publicKeyBase58
+    ? encodeMbKey(
+        MULTICODEC_ED25519_PUB_HEADER,
+        bs58.decode(derivableKey.publicKeyBase58),
+      )
+    : derivableKey.publicKeyMultibase;
+  const privateKeyMultibase =
+    (derivableKey.privateKeyBase58
+      ? encodeMbKey(
+          MULTICODEC_ED25519_PRIV_HEADER,
+          bs58.decode(derivableKey.privateKeyBase58),
+        )
+      : undefined) || derivableKey.privateKeyMultibase;
 
   // Convert ed25519 2020 verification key into a key agreement key
   const derivedKeyAgreement =
     X25519KeyAgreementKey2020.fromEd25519VerificationKey2020({
-      keyPair: ed2020VerificationKey,
-      ...ed2020VerificationKey,
+      keyPair: {
+        publicKeyMultibase,
+        privateKeyMultibase,
+        controller: derivableKey.controller,
+      },
     });
   return derivedKeyAgreement;
 }

package/tests/relay-service.e2e.test.js

@@ -1,12 +1,12 @@
+import {dockService} from '@docknetwork/wallet-sdk-wasm/src/services/dock';
 import {RelayService} from '../lib';
-import {dock} from '../lib/did/did-resolver';
 import {ALICE_KEY_PAIR_DOC, BOB_KEY_PAIR_DOC} from './mock-data';
 
 describe('Relay service', () => {
   const messageContent = `Test message ${Date.now()}`;
 
   beforeAll(async () => {
-    await dock.init({
+    await dockService.init({
       address: 'wss://knox-1.dock.io',
     });
   });

package/src/did/did-resolver.js

@@ -1,35 +0,0 @@
-import {
-  DockResolver,
-  DIDKeyResolver,
-  WildcardMultiResolver,
-  UniversalResolver,
-} from '@docknetwork/sdk/resolver';
-import dock from '@docknetwork/sdk';
-
-// Create a resolver in order to lookup DIDs for verifying
-export const universalResolverUrl = 'https://uniresolver.io';
-
-// class WalletSDKResolver extends WildcardMultiResolver {
-//   static PREFIX = WILDCARD;
-//   static METHOD = WILDCARD;
-
-//   async resolve(did) {
-//     const trimmedDID = did.split('#')[0];
-//     const document = await super.resolve(trimmedDID);
-//     return document;
-//   }
-// }
-
-export const resolver = new WildcardMultiResolver(
-  // {
-  //   dock: new DockResolver(dock), // Prebuilt resolver
-  //   key: new DIDKeyResolver(), // did:key resolution
-  // },
-  [
-    new DockResolver(dock),
-    new DIDKeyResolver(),
-    new UniversalResolver(universalResolverUrl),
-  ],
-);
-
-export {dock};