@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/services/test-utils.mjs

@@ -0,0 +1,307 @@
+import { cryptoWaitReady } from '@polkadot/util-crypto';
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import { DOCK_TOKEN_UNIT } from '../core/format-utils.mjs';
+import { TestFixtures } from '../fixtures.mjs';
+import { NetworkManager } from '../modules/network-manager.mjs';
+import { dockService, setDock, getDock } from './dock/service.mjs';
+import { keyringService } from './keyring/service.mjs';
+import 'json-rpc-2.0';
+import '../core/crypto.mjs';
+import '../core/logger.mjs';
+import { walletService } from './wallet/service.mjs';
+import Keyring from '@polkadot/keyring';
+import '../core/validation.mjs';
+import '../types.mjs';
+import './keyring/configs.mjs';
+import '@docknetwork/sdk';
+import '@docknetwork/sdk/resolver';
+import '@docknetwork/crypto-wasm-ts/lib/index';
+import 'events';
+import '../modules/event-manager.mjs';
+import './dock/configs.mjs';
+import 'crypto';
+import 'uuid';
+import '../wallet/memory-storage-wallet.mjs';
+import '@docknetwork/universal-wallet/storage-wallet';
+import '../wallet/memory-storage-interface.mjs';
+import '@docknetwork/universal-wallet/storage/storage-interface';
+import '../wallet/rpc-storage-wallet.mjs';
+import '../wallet/rpc-storage-interface.mjs';
+import './storage/service.mjs';
+import './wallet/configs.mjs';
+
+async function initializeWalletService() {
+  await cryptoWaitReady();
+  await keyringService.initialize({
+    ss58Format: 21,
+  });
+  await walletService.create('test-wallet', 'memory');
+}
+
+const TEST_FEE_AMOUNT = 2.48;
+const API_MOCK_DISABLED = process.env.API_MOCK_DISABLED === 'true';
+const TEST_TRUST_REGISTRIES = {
+  '0xc255301bad77eab2a86760a80dfac734d85f1378b95671b169e3a519aa7eadd2': {
+    name: 'Github',
+    convener: 'did:dock:5HcwutWUAwVmHamXUa4QVpqHtDtJZwktXitETNKVMq6TZSPk',
+    govFramework:
+      '0x68747470733a2f2f6170692d73746167696e672e646f636b2e696f2f74727573742d726567697374726965732f3078633235353330316261643737656162326138363736306138306466616337333464383566313337386239353637316231363965336135313961613765616464322f7075626c6963',
+  },
+};
+const TEST_SCHEMA_METADATA = {
+  '0x719455878946440f05937aba69d20a84ef32a2e254a03be324d72bf81d37d19b': {
+    verifiers: [],
+  },
+};
+
+let mockTransactionError;
+
+const setMockTransactionError = error => {
+  mockTransactionError = error;
+};
+
+async function mockDockService() {
+  await cryptoWaitReady();
+
+  await keyringService.initialize({
+    ss58Format: NetworkManager.getInstance().getNetworkInfo().addressPrefix,
+  });
+
+  let sdkMock;
+
+  if (API_MOCK_DISABLED) {
+    return dockService.init({
+      address: NetworkManager.getInstance().getNetworkInfo().substrateUrl,
+    });
+  } else {
+    sdkMock = mockDockSdkConnection();
+    await dockService.init({
+      address: NetworkManager.getInstance().getNetworkInfo().substrateUrl,
+    });
+  }
+
+  const _dockSdk = dockService.dock;
+
+  dockService.isDockReady = true;
+
+  dockService.dock = {
+    api: {
+      events: {
+        system: {
+          ExtrinsicFailed: {
+            is: event => !!mockTransactionError,
+          },
+        },
+      },
+      query: {
+        system: {
+          account: jest.fn().mockImplementation(() => ({
+            data: {
+              free: BigNumber(TestFixtures.account1.balance * DOCK_TOKEN_UNIT),
+            },
+          })),
+        },
+      },
+      revocation: {
+        getIsRevoked: jest.fn().mockImplementation(() => false),
+      },
+      tx: {
+        balances: {
+          transfer: jest.fn().mockImplementation(() => ({
+            paymentInfo: () => ({
+              partialFee: BigNumber(TEST_FEE_AMOUNT * DOCK_TOKEN_UNIT),
+            }),
+            signAndSend: (account, callback) => {
+              callback({
+                status: {
+                  isInBlock: true,
+                  isFinalized: true,
+                  toHex: () => 'hash',
+                },
+                events: [
+                  {
+                    event: {
+                      data: [mockTransactionError],
+                    },
+                  },
+                ],
+              });
+
+              return Promise.resolve({});
+            },
+          })),
+        },
+      },
+    },
+    trustRegistry: {
+      registriesInfo: jest.fn().mockImplementation(() => TEST_TRUST_REGISTRIES),
+      registrySchemasMetadata: jest
+        .fn()
+        .mockImplementation(() => TEST_SCHEMA_METADATA),
+    },
+    init: jest.fn().mockImplementation(() => Promise.resolve({})),
+    disconnect: jest.fn(),
+    setAccount: jest.fn(),
+  };
+
+  return () => {
+    dockService.dock = _dockSdk;
+    if (sdkMock) {
+      sdkMock.clear();
+    }
+    dockService.disconnect();
+  };
+}
+
+let walletCreated;
+
+async function setupTestWallet() {
+  if (walletCreated) {
+    return;
+  }
+
+  NetworkManager.getInstance().setNetworkId('testnet');
+
+  await cryptoWaitReady();
+  await keyringService.initialize({
+    ss58Format: NetworkManager.getInstance().getNetworkInfo().addressPrefix,
+  });
+  await walletService.create({
+    walletId: 'test-wallet',
+    type: 'memory',
+  });
+  await walletService.createAccountDocuments({
+    mnemonic: TestFixtures.account1.mnemonic,
+    name: TestFixtures.account1.name,
+  });
+  await walletService.createAccountDocuments({
+    mnemonic: TestFixtures.account2.mnemonic,
+    name: TestFixtures.account2.name,
+  });
+
+  walletCreated = true;
+}
+
+function mockDockSdkConnection(connectionError) {
+  const result = 'result';
+  const dock = getDock();
+  const mocks = [
+    jest.spyOn(dock, 'init').mockImplementation(() => {
+      if (connectionError) {
+        return Promise.reject(connectionError);
+      }
+
+      return Promise.resolve(result);
+    }),
+    jest.spyOn(dock, 'disconnect').mockReturnValue(Promise.resolve(true)),
+  ];
+
+  let currentAccount;
+
+  setDock({
+    ...dock,
+    setAccount(account) {
+      currentAccount = account;
+    },
+    did: {
+      new: () => {
+        if (
+          currentAccount &&
+          currentAccount.address === TestFixtures.noBalanceAccount.address
+        ) {
+          throw new Error(
+            '1010: Invalid Transaction: Inability to pay some fees , e.g. account balance too low',
+          );
+        }
+        return {
+          txHash: 'hash',
+        };
+      },
+      getDocument: () => ({
+        '@context': ['https://www.w3.org/ns/did/v1'],
+        assertionMethod: [
+          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
+        ],
+        authentication: [
+          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
+        ],
+        capabilityInvocation: [
+          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
+        ],
+        controller: [
+          'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
+        ],
+        id: 'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
+        publicKey: [
+          {
+            controller:
+              'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
+            id: 'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi#keys-1',
+            publicKeyBase58: '8UDojkFBh5RopLKZredz8uVZV5U579voUwQFyYDmgBM3',
+            type: 'Sr25519VerificationKey2020',
+          },
+        ],
+      }),
+    },
+    keyring: {
+      createFromPair: jest.fn(() => {
+        const kr = new Keyring();
+        return kr.createFromUri('//Alice');
+      }),
+    },
+  });
+
+  return {
+    result,
+    clear: () => mocks.forEach(mock => mock.mockClear()),
+  };
+}
+
+async function getPromiseError(func) {
+  try {
+    return await func();
+  } catch (err) {
+    return err;
+  }
+}
+
+function assertRpcService(
+  ServiceClass            ,
+  service     ,
+  validation     ,
+) {
+  assert(!!ServiceClass.prototype.call, 'must extend RpcServie class');
+
+  const rpcService = new ServiceClass();
+  const validationTmp = {};
+
+  Object.keys(validation).forEach(key => {
+    validationTmp[key] = validation[key];
+    validation[key] = () => true;
+  });
+
+  service.rpcMethods.forEach(method => {
+    const methodName = method.name;
+    assert(
+      !!rpcService[methodName],
+      `[${methodName}]: not found in the rpc client`,
+    );
+
+    rpcService.call = jest.fn();
+    rpcService[methodName]();
+
+    const methodArg = rpcService.call.mock.calls[0][0];
+
+    assert(
+      methodArg === methodName,
+      `[${methodName}]: rpc call method with wrong value "${methodArg}"`,
+    );
+  });
+
+  Object.keys(validation).forEach(key => {
+    validation[key] = validationTmp[key];
+  });
+}
+
+export { API_MOCK_DISABLED, TEST_FEE_AMOUNT, TEST_SCHEMA_METADATA, TEST_TRUST_REGISTRIES, assertRpcService, getPromiseError, initializeWalletService, mockDockSdkConnection, mockDockService, setMockTransactionError, setupTestWallet };

package/lib/services/trust-registry/configs.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assert = require('assert');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+
+// @ts-nocheck
+const serviceName = 'trust-registry';
+const validation = {
+    getTrustRegistries: params => {
+        const { schemaId, issuerDID, verifierDID } = params;
+        assert__default["default"](!!schemaId || !!issuerDID || !!verifierDID, 'no query option provider');
+    },
+    getTrustRegistryVerifiers: params => {
+        const { trustRegistryId } = params;
+        assert__default["default"](!!trustRegistryId, 'trustRegistryId is required');
+    },
+};
+
+exports.serviceName = serviceName;
+exports.validation = validation;

package/lib/services/trust-registry/configs.mjs

@@ -0,0 +1,16 @@
+import assert from 'assert';
+
+// @ts-nocheck
+const serviceName = 'trust-registry';
+const validation = {
+    getTrustRegistries: params => {
+        const { schemaId, issuerDID, verifierDID } = params;
+        assert(!!schemaId || !!issuerDID || !!verifierDID, 'no query option provider');
+    },
+    getTrustRegistryVerifiers: params => {
+        const { trustRegistryId } = params;
+        assert(!!trustRegistryId, 'trustRegistryId is required');
+    },
+};
+
+export { serviceName, validation };

package/lib/services/trust-registry/index.android.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_trustRegistry_serviceRpc = require('./service-rpc.js');
+require('../rpc-service-client.js');
+require('assert');
+require('../../rpc-client.js');
+require('json-rpc-2.0');
+require('../../core/crypto.js');
+require('crypto');
+require('../../core/logger.js');
+require('../../logger.js');
+require('../../rpc-util.js');
+require('./configs.js');
+
+const trustRegistryService = new services_trustRegistry_serviceRpc.TrustRegistryServiceRpc();
+
+exports.trustRegistryService = trustRegistryService;

package/lib/services/trust-registry/index.android.mjs

@@ -0,0 +1,15 @@
+import { TrustRegistryServiceRpc } from './service-rpc.mjs';
+import '../rpc-service-client.mjs';
+import 'assert';
+import '../../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../../core/crypto.mjs';
+import 'crypto';
+import '../../core/logger.mjs';
+import '../../logger.mjs';
+import '../../rpc-util.mjs';
+import './configs.mjs';
+
+const trustRegistryService = new TrustRegistryServiceRpc();
+
+export { trustRegistryService };

package/lib/services/trust-registry/index.ios.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_trustRegistry_serviceRpc = require('./service-rpc.js');
+require('../rpc-service-client.js');
+require('assert');
+require('../../rpc-client.js');
+require('json-rpc-2.0');
+require('../../core/crypto.js');
+require('crypto');
+require('../../core/logger.js');
+require('../../logger.js');
+require('../../rpc-util.js');
+require('./configs.js');
+
+const trustRegistryService = new services_trustRegistry_serviceRpc.TrustRegistryServiceRpc();
+
+exports.trustRegistryService = trustRegistryService;

package/lib/services/trust-registry/index.ios.mjs

@@ -0,0 +1,15 @@
+import { TrustRegistryServiceRpc } from './service-rpc.mjs';
+import '../rpc-service-client.mjs';
+import 'assert';
+import '../../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../../core/crypto.mjs';
+import 'crypto';
+import '../../core/logger.mjs';
+import '../../logger.mjs';
+import '../../rpc-util.mjs';
+import './configs.mjs';
+
+const trustRegistryService = new TrustRegistryServiceRpc();
+
+export { trustRegistryService };

package/lib/services/trust-registry/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_trustRegistry_service = require('./service.js');
+require('./configs.js');
+require('assert');
+require('@docknetwork/sdk/utils/did/typed-did/helpers');
+require('crypto');
+require('../dock/service.js');
+require('@docknetwork/sdk');
+require('@docknetwork/sdk/resolver');
+require('@docknetwork/crypto-wasm-ts/lib/index');
+require('events');
+require('../../core/logger.js');
+require('../../modules/event-manager.js');
+require('../dock/configs.js');
+
+
+
+exports.trustRegistryService = services_trustRegistry_service.trustRegistryService;

package/lib/services/trust-registry/index.mjs

@@ -0,0 +1,13 @@
+export { trustRegistryService } from './service.mjs';
+import './configs.mjs';
+import 'assert';
+import '@docknetwork/sdk/utils/did/typed-did/helpers';
+import 'crypto';
+import '../dock/service.mjs';
+import '@docknetwork/sdk';
+import '@docknetwork/sdk/resolver';
+import '@docknetwork/crypto-wasm-ts/lib/index';
+import 'events';
+import '../../core/logger.mjs';
+import '../../modules/event-manager.mjs';
+import '../dock/configs.mjs';

package/lib/services/trust-registry/service-rpc.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_rpcServiceClient = require('../rpc-service-client.js');
+var services_trustRegistry_configs = require('./configs.js');
+require('assert');
+require('../../rpc-client.js');
+require('json-rpc-2.0');
+require('../../core/crypto.js');
+require('crypto');
+require('../../core/logger.js');
+require('../../logger.js');
+require('../../rpc-util.js');
+
+class TrustRegistryServiceRpc extends services_rpcServiceClient.RpcService {
+  constructor() {
+    super(services_trustRegistry_configs.serviceName);
+  }
+
+  async getTrustRegistries(params) {
+    return this.call('getTrustRegistries', params);
+  }
+  async getTrustRegistryVerifiers(params) {
+    return this.call('getTrustRegistryVerifiers', params);
+  }
+}
+
+exports.TrustRegistryServiceRpc = TrustRegistryServiceRpc;

package/lib/services/trust-registry/service-rpc.mjs

@@ -0,0 +1,25 @@
+import { RpcService } from '../rpc-service-client.mjs';
+import { serviceName } from './configs.mjs';
+import 'assert';
+import '../../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../../core/crypto.mjs';
+import 'crypto';
+import '../../core/logger.mjs';
+import '../../logger.mjs';
+import '../../rpc-util.mjs';
+
+class TrustRegistryServiceRpc extends RpcService {
+  constructor() {
+    super(serviceName);
+  }
+
+  async getTrustRegistries(params) {
+    return this.call('getTrustRegistries', params);
+  }
+  async getTrustRegistryVerifiers(params) {
+    return this.call('getTrustRegistryVerifiers', params);
+  }
+}
+
+export { TrustRegistryServiceRpc };

package/lib/services/trust-registry/service.js

@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var services_trustRegistry_configs = require('./configs.js');
+var helpers = require('@docknetwork/sdk/utils/did/typed-did/helpers');
+var crypto = require('crypto');
+var services_dock_service = require('../dock/service.js');
+require('assert');
+require('@docknetwork/sdk');
+require('@docknetwork/sdk/resolver');
+require('@docknetwork/crypto-wasm-ts/lib/index');
+require('events');
+require('../../core/logger.js');
+require('../../modules/event-manager.js');
+require('../dock/configs.js');
+
+// @ts-nocheck
+class TrustRegistryService {
+    constructor() {
+        this.name = services_trustRegistry_configs.serviceName;
+    }
+    rpcMethods = [
+        TrustRegistryService.prototype.getTrustRegistries,
+        TrustRegistryService.prototype.getTrustRegistryVerifiers,
+    ];
+    async getTrustRegistries({ schemaId, issuerDID, verifierDID, }) {
+        services_trustRegistry_configs.validation.getTrustRegistries({ schemaId, issuerDID, verifierDID });
+        const queryOptions = {};
+        if (schemaId) {
+            const hashedId = crypto.createHash('sha256').update(schemaId).digest('hex');
+            const schemaIdHex = '0x' + hashedId;
+            queryOptions.schemaIds = {
+                AnyOf: [schemaIdHex],
+            };
+        }
+        if (issuerDID) {
+            const issuerDIDMethodKey = helpers.typedHexDID(services_dock_service.dockService.dock.api, issuerDID);
+            queryOptions.issuers = {
+                AnyOf: [issuerDIDMethodKey],
+            };
+        }
+        if (verifierDID) {
+            const verifierDIDMethodKey = helpers.typedHexDID(services_dock_service.dockService.dock.api, verifierDID);
+            queryOptions.verifiers = {
+                AnyOf: [verifierDIDMethodKey],
+            };
+        }
+        const registryInfo = await services_dock_service.dockService.dock.trustRegistry?.registriesInfo(queryOptions);
+        return registryInfo;
+    }
+    async getTrustRegistryVerifiers({ schemaId, trustRegistryId, issuerDID }) {
+        services_trustRegistry_configs.validation.getTrustRegistryVerifiers({ schemaId, trustRegistryId });
+        const hashedId = crypto.createHash('sha256').update(schemaId).digest('hex');
+        const schemaIdHex = '0x' + hashedId;
+        const issuerDIDMethodKey = issuerDID
+            ? helpers.typedHexDID(services_dock_service.dockService.dock.api, issuerDID)
+            : null;
+        const metadata = await services_dock_service.dockService.dock.trustRegistry.registrySchemasMetadata({
+            schemaIds: [schemaIdHex],
+            ...(issuerDIDMethodKey && {
+                issuers: {
+                    AnyOf: [issuerDIDMethodKey],
+                },
+            }),
+        }, trustRegistryId);
+        return metadata[schemaIdHex]?.verifiers;
+    }
+}
+const trustRegistryService = new TrustRegistryService();
+
+exports.trustRegistryService = trustRegistryService;

package/lib/services/trust-registry/service.mjs

@@ -0,0 +1,68 @@
+import { serviceName, validation } from './configs.mjs';
+import { typedHexDID } from '@docknetwork/sdk/utils/did/typed-did/helpers';
+import { createHash } from 'crypto';
+import { dockService } from '../dock/service.mjs';
+import 'assert';
+import '@docknetwork/sdk';
+import '@docknetwork/sdk/resolver';
+import '@docknetwork/crypto-wasm-ts/lib/index';
+import 'events';
+import '../../core/logger.mjs';
+import '../../modules/event-manager.mjs';
+import '../dock/configs.mjs';
+
+// @ts-nocheck
+class TrustRegistryService {
+    constructor() {
+        this.name = serviceName;
+    }
+    rpcMethods = [
+        TrustRegistryService.prototype.getTrustRegistries,
+        TrustRegistryService.prototype.getTrustRegistryVerifiers,
+    ];
+    async getTrustRegistries({ schemaId, issuerDID, verifierDID, }) {
+        validation.getTrustRegistries({ schemaId, issuerDID, verifierDID });
+        const queryOptions = {};
+        if (schemaId) {
+            const hashedId = createHash('sha256').update(schemaId).digest('hex');
+            const schemaIdHex = '0x' + hashedId;
+            queryOptions.schemaIds = {
+                AnyOf: [schemaIdHex],
+            };
+        }
+        if (issuerDID) {
+            const issuerDIDMethodKey = typedHexDID(dockService.dock.api, issuerDID);
+            queryOptions.issuers = {
+                AnyOf: [issuerDIDMethodKey],
+            };
+        }
+        if (verifierDID) {
+            const verifierDIDMethodKey = typedHexDID(dockService.dock.api, verifierDID);
+            queryOptions.verifiers = {
+                AnyOf: [verifierDIDMethodKey],
+            };
+        }
+        const registryInfo = await dockService.dock.trustRegistry?.registriesInfo(queryOptions);
+        return registryInfo;
+    }
+    async getTrustRegistryVerifiers({ schemaId, trustRegistryId, issuerDID }) {
+        validation.getTrustRegistryVerifiers({ schemaId, trustRegistryId });
+        const hashedId = createHash('sha256').update(schemaId).digest('hex');
+        const schemaIdHex = '0x' + hashedId;
+        const issuerDIDMethodKey = issuerDID
+            ? typedHexDID(dockService.dock.api, issuerDID)
+            : null;
+        const metadata = await dockService.dock.trustRegistry.registrySchemasMetadata({
+            schemaIds: [schemaIdHex],
+            ...(issuerDIDMethodKey && {
+                issuers: {
+                    AnyOf: [issuerDIDMethodKey],
+                },
+            }),
+        }, trustRegistryId);
+        return metadata[schemaIdHex]?.verifiers;
+    }
+}
+const trustRegistryService = new TrustRegistryService();
+
+export { trustRegistryService };

package/lib/services/util-crypto/configs.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assert = require('assert');
+var core_validation = require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+
+// @ts-nocheck
+const validation = {
+    deriveValidate(uri) {
+        assert__default["default"](!!uri, 'uri is required');
+    },
+    isAddressValid(address) {
+        core_validation.assertAddress(address);
+    },
+    mnemonicGenerate(numWords) {
+        if (numWords) {
+            assert__default["default"](typeof numWords === 'number', 'invalid number of words');
+        }
+    },
+    mnemonicValidate(phrase) {
+        assert__default["default"](typeof phrase === 'string', 'invalid mnemonic phrase');
+    },
+};
+
+exports.validation = validation;