@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/services/substrate/service.js

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assert = require('assert');
+var BigNumber = require('bignumber.js');
+var BN = require('bn.js');
+var core_formatUtils = require('../../core/format-utils.js');
+var services_dock_service = require('../dock/service.js');
+var services_substrate_apiUtils = require('./api-utils.js');
+var services_substrate_configs = require('./configs.js');
+var services_keyring_service = require('../keyring/service.js');
+require('../../core/validation.js');
+require('../../types.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');
+require('@polkadot/keyring');
+require('@polkadot/util-crypto');
+require('../keyring/configs.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
+var BN__default = /*#__PURE__*/_interopDefaultLegacy(BN);
+
+// @ts-nocheck
+const FEE_ESTIMATION_BUFFER = 1.1;
+function getFeeWithBuffer(paymentFee) {
+    assert__default["default"](!!paymentFee, 'paymentFee is required');
+    return new BigNumber__default["default"](paymentFee).multipliedBy(FEE_ESTIMATION_BUFFER);
+}
+class SubstrateService {
+    rpcMethods = [
+        SubstrateService.prototype.getAccountBalance,
+        SubstrateService.prototype.getFeeAmount,
+        SubstrateService.prototype.sendTokens,
+    ];
+    constructor() {
+        this.name = services_substrate_configs.serviceName;
+    }
+    async getAccountBalance(params) {
+        services_substrate_configs.validation.getAccountBalance(params);
+        console.log('ensure dock ready');
+        await services_dock_service.dockService.ensureDockReady();
+        console.log('ensure dock ready done');
+        const { data: { free }, } = await services_dock_service.dockService.dock.api.query.system.account(params.address);
+        return free.toNumber() / core_formatUtils.DOCK_TOKEN_UNIT;
+    }
+    async getFeeAmount(params) {
+        services_substrate_configs.validation.getFeeAmount(params);
+        const { toAddress, keyPair } = params;
+        const amount = core_formatUtils.getPlainDockAmount(params.amount).toNumber();
+        const account = services_keyring_service.keyringService.decryptKeyPair({
+            jsonData: keyPair,
+            password: '',
+        });
+        services_dock_service.dockService.dock.setAccount(account);
+        const extrinsic = services_dock_service.dockService.dock.api.tx.balances.transfer(toAddress, amount);
+        const paymentInfo = await extrinsic.paymentInfo(account);
+        const fee = getFeeWithBuffer(paymentInfo.partialFee)
+            .dividedBy(core_formatUtils.DOCK_TOKEN_UNIT)
+            .toNumber();
+        return fee;
+    }
+    async sendTokens(params) {
+        services_substrate_configs.validation.sendTokens(params);
+        let { toAddress, fromAddress, keyPair } = params;
+        let amount = core_formatUtils.getPlainDockAmount(params.amount).toNumber();
+        const account = services_keyring_service.keyringService.decryptKeyPair({
+            jsonData: keyPair,
+            password: '',
+        });
+        const { dock } = services_dock_service.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 }) => {
+                const adjFee = getFeeWithBuffer(partialFee);
+                let maxTransfer = balances.availableBalance.sub(new BN__default["default"](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);
+            services_substrate_apiUtils.signAndSend(account, extrinsic).on('done', resolve).on('error', reject);
+        });
+    }
+}
+const substrateService = new SubstrateService();
+
+exports.FEE_ESTIMATION_BUFFER = FEE_ESTIMATION_BUFFER;
+exports.SubstrateService = SubstrateService;
+exports.getFeeWithBuffer = getFeeWithBuffer;
+exports.substrateService = substrateService;

package/lib/services/substrate/service.mjs

@@ -0,0 +1,94 @@
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import BN from 'bn.js';
+import { DOCK_TOKEN_UNIT, getPlainDockAmount } from '../../core/format-utils.mjs';
+import { dockService } from '../dock/service.mjs';
+import { signAndSend } from './api-utils.mjs';
+import { serviceName, validation } from './configs.mjs';
+import { keyringService } from '../keyring/service.mjs';
+import '../../core/validation.mjs';
+import '../../types.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';
+import '@polkadot/keyring';
+import '@polkadot/util-crypto';
+import '../keyring/configs.mjs';
+
+// @ts-nocheck
+const FEE_ESTIMATION_BUFFER = 1.1;
+function getFeeWithBuffer(paymentFee) {
+    assert(!!paymentFee, 'paymentFee is required');
+    return new BigNumber(paymentFee).multipliedBy(FEE_ESTIMATION_BUFFER);
+}
+class SubstrateService {
+    rpcMethods = [
+        SubstrateService.prototype.getAccountBalance,
+        SubstrateService.prototype.getFeeAmount,
+        SubstrateService.prototype.sendTokens,
+    ];
+    constructor() {
+        this.name = serviceName;
+    }
+    async getAccountBalance(params) {
+        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) {
+        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) {
+        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 }) => {
+                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);
+        });
+    }
+}
+const substrateService = new SubstrateService();
+
+export { FEE_ESTIMATION_BUFFER, SubstrateService, getFeeWithBuffer, substrateService };

package/lib/services/test-utils.js

@@ -0,0 +1,327 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utilCrypto = require('@polkadot/util-crypto');
+var assert = require('assert');
+var BigNumber = require('bignumber.js');
+var core_formatUtils = require('../core/format-utils.js');
+var fixtures = require('../fixtures.js');
+var modules_networkManager = require('../modules/network-manager.js');
+var services_dock_service = require('./dock/service.js');
+var services_keyring_service = require('./keyring/service.js');
+require('json-rpc-2.0');
+require('../core/crypto.js');
+require('../core/logger.js');
+var services_wallet_service = require('./wallet/service.js');
+var Keyring = require('@polkadot/keyring');
+require('../core/validation.js');
+require('../types.js');
+require('./keyring/configs.js');
+require('@docknetwork/sdk');
+require('@docknetwork/sdk/resolver');
+require('@docknetwork/crypto-wasm-ts/lib/index');
+require('events');
+require('../modules/event-manager.js');
+require('./dock/configs.js');
+require('crypto');
+require('uuid');
+require('../wallet/memory-storage-wallet.js');
+require('@docknetwork/universal-wallet/storage-wallet');
+require('../wallet/memory-storage-interface.js');
+require('@docknetwork/universal-wallet/storage/storage-interface');
+require('../wallet/rpc-storage-wallet.js');
+require('../wallet/rpc-storage-interface.js');
+require('./storage/service.js');
+require('./wallet/configs.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
+var Keyring__default = /*#__PURE__*/_interopDefaultLegacy(Keyring);
+
+async function initializeWalletService() {
+  await utilCrypto.cryptoWaitReady();
+  await services_keyring_service.keyringService.initialize({
+    ss58Format: 21,
+  });
+  await services_wallet_service.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 utilCrypto.cryptoWaitReady();
+
+  await services_keyring_service.keyringService.initialize({
+    ss58Format: modules_networkManager.NetworkManager.getInstance().getNetworkInfo().addressPrefix,
+  });
+
+  let sdkMock;
+
+  if (API_MOCK_DISABLED) {
+    return services_dock_service.dockService.init({
+      address: modules_networkManager.NetworkManager.getInstance().getNetworkInfo().substrateUrl,
+    });
+  } else {
+    sdkMock = mockDockSdkConnection();
+    await services_dock_service.dockService.init({
+      address: modules_networkManager.NetworkManager.getInstance().getNetworkInfo().substrateUrl,
+    });
+  }
+
+  const _dockSdk = services_dock_service.dockService.dock;
+
+  services_dock_service.dockService.isDockReady = true;
+
+  services_dock_service.dockService.dock = {
+    api: {
+      events: {
+        system: {
+          ExtrinsicFailed: {
+            is: event => !!mockTransactionError,
+          },
+        },
+      },
+      query: {
+        system: {
+          account: jest.fn().mockImplementation(() => ({
+            data: {
+              free: BigNumber__default["default"](fixtures.TestFixtures.account1.balance * core_formatUtils.DOCK_TOKEN_UNIT),
+            },
+          })),
+        },
+      },
+      revocation: {
+        getIsRevoked: jest.fn().mockImplementation(() => false),
+      },
+      tx: {
+        balances: {
+          transfer: jest.fn().mockImplementation(() => ({
+            paymentInfo: () => ({
+              partialFee: BigNumber__default["default"](TEST_FEE_AMOUNT * core_formatUtils.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 () => {
+    services_dock_service.dockService.dock = _dockSdk;
+    if (sdkMock) {
+      sdkMock.clear();
+    }
+    services_dock_service.dockService.disconnect();
+  };
+}
+
+let walletCreated;
+
+async function setupTestWallet() {
+  if (walletCreated) {
+    return;
+  }
+
+  modules_networkManager.NetworkManager.getInstance().setNetworkId('testnet');
+
+  await utilCrypto.cryptoWaitReady();
+  await services_keyring_service.keyringService.initialize({
+    ss58Format: modules_networkManager.NetworkManager.getInstance().getNetworkInfo().addressPrefix,
+  });
+  await services_wallet_service.walletService.create({
+    walletId: 'test-wallet',
+    type: 'memory',
+  });
+  await services_wallet_service.walletService.createAccountDocuments({
+    mnemonic: fixtures.TestFixtures.account1.mnemonic,
+    name: fixtures.TestFixtures.account1.name,
+  });
+  await services_wallet_service.walletService.createAccountDocuments({
+    mnemonic: fixtures.TestFixtures.account2.mnemonic,
+    name: fixtures.TestFixtures.account2.name,
+  });
+
+  walletCreated = true;
+}
+
+function mockDockSdkConnection(connectionError) {
+  const result = 'result';
+  const dock = services_dock_service.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;
+
+  services_dock_service.setDock({
+    ...dock,
+    setAccount(account) {
+      currentAccount = account;
+    },
+    did: {
+      new: () => {
+        if (
+          currentAccount &&
+          currentAccount.address === fixtures.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__default["default"]();
+        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__default["default"](!!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__default["default"](
+      !!rpcService[methodName],
+      `[${methodName}]: not found in the rpc client`,
+    );
+
+    rpcService.call = jest.fn();
+    rpcService[methodName]();
+
+    const methodArg = rpcService.call.mock.calls[0][0];
+
+    assert__default["default"](
+      methodArg === methodName,
+      `[${methodName}]: rpc call method with wrong value "${methodArg}"`,
+    );
+  });
+
+  Object.keys(validation).forEach(key => {
+    validation[key] = validationTmp[key];
+  });
+}
+
+exports.API_MOCK_DISABLED = API_MOCK_DISABLED;
+exports.TEST_FEE_AMOUNT = TEST_FEE_AMOUNT;
+exports.TEST_SCHEMA_METADATA = TEST_SCHEMA_METADATA;
+exports.TEST_TRUST_REGISTRIES = TEST_TRUST_REGISTRIES;
+exports.assertRpcService = assertRpcService;
+exports.getPromiseError = getPromiseError;
+exports.initializeWalletService = initializeWalletService;
+exports.mockDockSdkConnection = mockDockSdkConnection;
+exports.mockDockService = mockDockService;
+exports.setMockTransactionError = setMockTransactionError;
+exports.setupTestWallet = setupTestWallet;