@docknetwork/wallet-sdk-wasm 0.4.19

package/src/services/substrate/service.ts

@@ -0,0 +1,117 @@
+// @ts-nocheck
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import BN from 'bn.js';
+import {DOCK_TOKEN_UNIT, getPlainDockAmount} from '../../core/format-utils';
+import {dockService} from '../dock/service';
+import {signAndSend} from './api-utils';
+import {
+  GetAccountBalanceParams,
+  serviceName,
+  TransactionParams,
+  validation,
+} from './configs';
+import {keyringService} from '../keyring/service';
+
+export const FEE_ESTIMATION_BUFFER = 1.1;
+
+export function getFeeWithBuffer(paymentFee: BigNumber) {
+  assert(!!paymentFee, 'paymentFee is required');
+
+  return new BigNumber(paymentFee).multipliedBy(FEE_ESTIMATION_BUFFER);
+}
+
+export class SubstrateService {
+  rpcMethods = [
+    SubstrateService.prototype.getAccountBalance,
+    SubstrateService.prototype.getFeeAmount,
+    SubstrateService.prototype.sendTokens,
+  ];
+
+  constructor() {
+    this.name = serviceName;
+  }
+
+  async getAccountBalance(params: GetAccountBalanceParams) {
+    validation.getAccountBalance(params);
+
+    console.log('ensure dock ready');
+    await dockService.ensureDockReady();
+
+    console.log('ensure dock ready done');
+
+    const {
+      data: {free},
+    } = await dockService.dock.api.query.system.account(params.address);
+
+    return free.toNumber() / DOCK_TOKEN_UNIT;
+  }
+
+  async getFeeAmount(params: TransactionParams) {
+    validation.getFeeAmount(params);
+
+    const {toAddress, keyPair} = params;
+    const amount = getPlainDockAmount(params.amount).toNumber();
+
+    const account = keyringService.decryptKeyPair({
+      jsonData: keyPair,
+      password: '',
+    });
+
+    dockService.dock.setAccount(account);
+
+    const extrinsic = dockService.dock.api.tx.balances.transfer(
+      toAddress,
+      amount,
+    );
+    const paymentInfo = await extrinsic.paymentInfo(account);
+    const fee = getFeeWithBuffer(paymentInfo.partialFee)
+      .dividedBy(DOCK_TOKEN_UNIT)
+      .toNumber();
+
+    return fee;
+  }
+
+  async sendTokens(params: TransactionParams) {
+    validation.sendTokens(params);
+
+    let {toAddress, fromAddress, keyPair} = params;
+    let amount = getPlainDockAmount(params.amount).toNumber();
+    const account = keyringService.decryptKeyPair({
+      jsonData: keyPair,
+      password: '',
+    });
+    const {dock} = dockService;
+
+    dock.setAccount(account);
+
+    if (params.transferAll) {
+      const api = dock.api;
+      const balances = await api.derive.balances.all(account.address);
+
+      await api.tx.balances
+        .transfer(fromAddress, balances.availableBalance)
+        .paymentInfo(account)
+        .then(async ({partialFee}): void => {
+          const adjFee = getFeeWithBuffer(partialFee);
+          let maxTransfer = balances.availableBalance.sub(
+            new BN(adjFee.toNumber()),
+          );
+
+          if (!maxTransfer.gt(api.consts.balances.existentialDeposit)) {
+            throw new Error('balance too low');
+          }
+
+          amount = maxTransfer;
+        });
+    }
+
+    return new Promise((resolve, reject) => {
+      const extrinsic = dock.api.tx.balances.transfer(toAddress, amount);
+
+      signAndSend(account, extrinsic).on('done', resolve).on('error', reject);
+    });
+  }
+}
+
+export const substrateService: SubstrateService = new SubstrateService();

package/src/services/test-utils.js

@@ -0,0 +1,284 @@
+import {cryptoWaitReady} from '@polkadot/util-crypto';
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import {DOCK_TOKEN_UNIT} from '../core/format-utils';
+import {TestFixtures} from '../fixtures';
+import {NetworkManager} from '../modules/network-manager';
+import {dockService, getDock, setDock} from './dock/service';
+import {keyringService} from './keyring';
+import {RpcService} from './rpc-service-client';
+import {walletService} from './wallet';
+import Keyring from '@polkadot/keyring';
+
+export async function initializeWalletService() {
+  await cryptoWaitReady();
+  await keyringService.initialize({
+    ss58Format: 21,
+  });
+  await walletService.create('test-wallet', 'memory');
+}
+
+export const TEST_FEE_AMOUNT = 2.48;
+export const API_MOCK_DISABLED = process.env.API_MOCK_DISABLED === 'true';
+export const TEST_TRUST_REGISTRIES = {
+  '0xc255301bad77eab2a86760a80dfac734d85f1378b95671b169e3a519aa7eadd2': {
+    name: 'Github',
+    convener: 'did:dock:5HcwutWUAwVmHamXUa4QVpqHtDtJZwktXitETNKVMq6TZSPk',
+    govFramework:
+      '0x68747470733a2f2f6170692d73746167696e672e646f636b2e696f2f74727573742d726567697374726965732f3078633235353330316261643737656162326138363736306138306466616337333464383566313337386239353637316231363965336135313961613765616464322f7075626c6963',
+  },
+};
+export const TEST_SCHEMA_METADATA = {
+  '0x719455878946440f05937aba69d20a84ef32a2e254a03be324d72bf81d37d19b': {
+    verifiers: [],
+  },
+};
+
+let mockTransactionError;
+
+export const setMockTransactionError = error => {
+  mockTransactionError = error;
+};
+
+export 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;
+
+export 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;
+}
+
+export 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()),
+  };
+}
+
+export async function getPromiseError(func) {
+  try {
+    return await func();
+  } catch (err) {
+    return err;
+  }
+}
+
+export function assertRpcService(
+  ServiceClass: RpcService,
+  service: any,
+  validation: any,
+) {
+  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];
+  });
+}

package/src/services/trust-registry/configs.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import assert from 'assert';
+
+export const serviceName = 'trust-registry';
+export 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');
+  },
+};

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

@@ -0,0 +1,3 @@
+import {TrustRegistryServiceRpc} from './service-rpc';
+
+export const trustRegistryService = new TrustRegistryServiceRpc();

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

@@ -0,0 +1,3 @@
+import {TrustRegistryServiceRpc} from './service-rpc';
+
+export const trustRegistryService = new TrustRegistryServiceRpc();

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

@@ -0,0 +1 @@
+export {trustRegistryService} from './service';

package/src/services/trust-registry/index.test.js

@@ -0,0 +1,65 @@
+import {dockService} from '../dock/service';
+
+import {trustRegistryService as service} from './service';
+import {
+  TEST_SCHEMA_METADATA,
+  TEST_TRUST_REGISTRIES,
+  mockDockService,
+} from '../test-utils';
+
+describe('TrustRegistryService', () => {
+  let unmockDockService;
+
+  beforeAll(async () => {
+    unmockDockService = await mockDockService();
+  });
+
+  it('should successfully fetch trust registries', async () => {
+    const params = {
+      schemaId: 'some-schema-id',
+      issuerDID: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+      verifierDID: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+    };
+    const result = await service.getTrustRegistries(params);
+
+    const queryObject =
+      dockService.dock.trustRegistry.registriesInfo.mock.calls[0][0];
+    expect(queryObject.issuers.AnyOf).toHaveLength(1);
+    expect(queryObject.verifiers.AnyOf).toHaveLength(1);
+    expect(queryObject.schemaIds.AnyOf[0]).toEqual(
+      '0x719455878946440f05937aba69d20a84ef32a2e254a03be324d72bf81d37d19b',
+    );
+    expect(result).toEqual(TEST_TRUST_REGISTRIES);
+  });
+
+  it('should successfully fetch trust registry verifiers', async () => {
+    const trustRegistryId =
+      '0xc255301bad77eab2a86760a80dfac734d85f1378b95671b169e3a519aa7eadd2';
+    const params = {
+      schemaId: 'some-schema-id',
+      issuerDID: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+      trustRegistryId,
+    };
+    const result = await service.getTrustRegistryVerifiers(params);
+    const queryObject =
+      dockService.dock.trustRegistry.registrySchemasMetadata.mock.calls[0][0];
+
+    expect(
+      dockService.dock.trustRegistry.registrySchemasMetadata.mock.calls[0][1],
+    ).toEqual(trustRegistryId);
+    expect(queryObject.issuers.AnyOf).toHaveLength(1);
+    expect(queryObject.schemaIds[0]).toEqual(
+      '0x719455878946440f05937aba69d20a84ef32a2e254a03be324d72bf81d37d19b',
+    );
+
+    expect(result).toEqual(
+      TEST_SCHEMA_METADATA[
+        '0x719455878946440f05937aba69d20a84ef32a2e254a03be324d72bf81d37d19b'
+      ].verifiers,
+    );
+  });
+
+  afterAll(async () => {
+    await unmockDockService();
+  });
+});

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

@@ -0,0 +1,15 @@
+import {RpcService} from '../rpc-service-client';
+import {serviceName} from './configs';
+
+export class TrustRegistryServiceRpc extends RpcService {
+  constructor() {
+    super(serviceName);
+  }
+
+  async getTrustRegistries(params) {
+    return this.call('getTrustRegistries', params);
+  }
+  async getTrustRegistryVerifiers(params) {
+    return this.call('getTrustRegistryVerifiers', params);
+  }
+}

package/src/services/trust-registry/service.ts

@@ -0,0 +1,88 @@
+// @ts-nocheck
+import {serviceName} from './configs';
+import {typedHexDID} from '@docknetwork/sdk/utils/did/typed-did/helpers';
+import {createHash} from 'crypto';
+import {dockService} from '../dock/service';
+import {validation} from './configs';
+
+class TrustRegistryService {
+  constructor() {
+    this.name = serviceName;
+  }
+  rpcMethods = [
+    TrustRegistryService.prototype.getTrustRegistries,
+    TrustRegistryService.prototype.getTrustRegistryVerifiers,
+  ];
+  
+  async getTrustRegistries({
+    schemaId,
+    issuerDID,
+    verifierDID,
+  }: {
+    schemaId?: string;
+    issuerDID?: string;
+    verifierDID?: string;
+  }) {
+    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;
+  }
+}
+
+export const trustRegistryService = new TrustRegistryService();

package/src/services/util-crypto/configs.ts

@@ -0,0 +1,23 @@
+// @ts-nocheck
+import assert from 'assert';
+import {assertAddress} from '../../core/validation';
+
+export const validation = {
+  deriveValidate(uri: string) {
+    assert(!!uri, 'uri is required');
+  },
+
+  isAddressValid(address: string) {
+    assertAddress(address);
+  },
+
+  mnemonicGenerate(numWords: number) {
+    if (numWords) {
+      assert(typeof numWords === 'number', 'invalid number of words');
+    }
+  },
+
+  mnemonicValidate(phrase: string) {
+    assert(typeof phrase === 'string', 'invalid mnemonic phrase');
+  },
+};

package/src/services/util-crypto/index.android.js

@@ -0,0 +1,3 @@
+import {UtilCryptoServiceRpc} from './service-rpc';
+
+export const utilCryptoService = new UtilCryptoServiceRpc();

package/src/services/util-crypto/index.ios.js

@@ -0,0 +1,3 @@
+import {UtilCryptoServiceRpc} from './service-rpc';
+
+export const utilCryptoService = new UtilCryptoServiceRpc();

package/src/services/util-crypto/index.js

@@ -0,0 +1 @@
+export {utilCryptoService} from './service';