@docknetwork/wallet-sdk-wasm 1.5.8 → 1.5.10

package/src/services/substrate/index.test.js

@@ -1,116 +0,0 @@
-import BigNumber from 'bignumber.js';
-import {TestFixtures} from '../../fixtures';
-import {
-  assertRpcService,
-  getPromiseError,
-  mockDockService,
-  setMockTransactionError,
-  setupTestWallet,
-  TEST_FEE_AMOUNT,
-} from '../test-utils';
-import {validation} from './configs';
-import {
-  substrateService as service,
-  getFeeWithBuffer,
-  FEE_ESTIMATION_BUFFER,
-} from './service';
-import {SubstrateServiceRpc} from './service-rpc';
-
-describe('ExampleService', () => {
-  it('ServiceRpc', () => {
-    assertRpcService(SubstrateServiceRpc, service, validation);
-  });
-
-  describe('service', () => {
-    let unmockDockService;
-    let testKeypairJSON;
-
-    beforeAll(async () => {
-      unmockDockService = await mockDockService();
-      testKeypairJSON = TestFixtures.account1.getKeyring().toJson('');
-      await setupTestWallet();
-    });
-
-    describe('getAccountBalance', () => {
-      it('expect to get account balance', async () => {
-        const balance = await service.getAccountBalance({
-          address: TestFixtures.account1.address,
-        });
-        expect(typeof balance).toBe('number');
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.getAccountBalance({address: null}),
-        );
-        expect(error.message).toBe('invalid address null');
-      });
-    });
-
-    describe('getFeeAmount', () => {
-      it('expect to add buffer to the fee', () => {
-        expect(getFeeWithBuffer(new BigNumber(1)).toNumber()).toBe(
-          1 * FEE_ESTIMATION_BUFFER,
-        );
-        expect(() => getFeeWithBuffer(null)).toThrowError();
-      });
-
-      it('expect to get fee amount', async () => {
-        const fee = await service.getFeeAmount({
-          toAddress: TestFixtures.account2.address,
-          fromAddress: TestFixtures.account1.address,
-          amount: 1,
-          keyPair: testKeypairJSON,
-        });
-        expect(fee).toBe(TEST_FEE_AMOUNT * 1.1);
-      });
-
-      it('expect to validate params', async () => {
-        const error = await getPromiseError(() =>
-          service.getFeeAmount({
-            amount: null,
-            fromAddress: 'address',
-            toAddress: 'adress',
-          }),
-        );
-        expect(error.message).toBe('invalid amount');
-      });
-    });
-
-    describe('sendTokens', () => {
-      it('expect to send tokens', async () => {
-        setMockTransactionError(null);
-        const hash = await service.sendTokens({
-          amount: 1,
-          fromAddress: TestFixtures.account1.address,
-          toAddress: TestFixtures.account2.address,
-          keyPair: testKeypairJSON,
-        });
-
-        console.log('tx hash', hash);
-
-        expect(typeof hash).toBe('string');
-      });
-
-      it('expect to handle transaction error', async () => {
-        const errorMessage = 'some error from substrate';
-
-        setMockTransactionError(errorMessage);
-
-        const error = await getPromiseError(() =>
-          service.sendTokens({
-            amount: 1,
-            fromAddress: TestFixtures.account1.address,
-            toAddress: TestFixtures.account2.address,
-          }),
-        );
-
-        expect(error.message).toBeDefined();
-      });
-    });
-
-    afterAll(async () => {
-      await unmockDockService();
-    });
-  });
-});

package/src/services/substrate/service-rpc.js

@@ -1,24 +0,0 @@
-import {RpcService} from '../rpc-service-client';
-import {
-  GetAccountBalanceParams,
-  serviceName,
-  TransactionParams,
-} from './configs';
-
-export class SubstrateServiceRpc extends RpcService {
-  constructor() {
-    super(serviceName);
-  }
-
-  getAccountBalance(params: GetAccountBalanceParams): Promise<any> {
-    return this.call('getAccountBalance', params);
-  }
-
-  getFeeAmount(params: TransactionParams): Promise<any> {
-    return this.call('getFeeAmount', params);
-  }
-
-  sendTokens(params: TransactionParams): Promise<any> {
-    return this.call('sendTokens', params);
-  }
-}

package/src/services/substrate/service.ts

@@ -1,117 +0,0 @@
-// @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 {blockchainService} from '../blockchain/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 blockchainService.ensureBlockchainReady();
-
-    console.log('ensure dock ready done');
-
-    const {
-      data: {free},
-    } = await blockchainService.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: '',
-    });
-
-    blockchainService.dock.setAccount(account);
-
-    const extrinsic = blockchainService.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} = blockchainService;
-
-    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/trust-registry/configs.ts

@@ -1,14 +0,0 @@
-// @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

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

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

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

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

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

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

@@ -1,67 +0,0 @@
-import {blockchainService} from '../blockchain/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 =
-      blockchainService.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 =
-      blockchainService.dock.trustRegistry.registrySchemasMetadata.mock
-        .calls[0][0];
-
-    expect(
-      blockchainService.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

@@ -1,15 +0,0 @@
-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

@@ -1,94 +0,0 @@
-// @ts-nocheck
-import {serviceName} from './configs';
-import {createHash} from 'crypto';
-import {blockchainService} from '../blockchain/service';
-import {validation} from './configs';
-
-
-// TODO: Implement this function when the Trust Registry support is added to the SDK
-function typedHexDID(resolver, issuerDID) {
-  return issuerDID;
-}
-
-// Trust Registry Service is not supported in the current version of the SDK
-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(blockchainService.dock.api, issuerDID);
-      queryOptions.issuers = {
-        AnyOf: [issuerDIDMethodKey],
-      };
-    }
-
-    if (verifierDID) {
-      const verifierDIDMethodKey = typedHexDID(
-        blockchainService.dock.api,
-        verifierDID,
-      );
-      queryOptions.verifiers = {
-        AnyOf: [verifierDIDMethodKey],
-      };
-    }
-
-    const registryInfo = await blockchainService.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(blockchainService.dock.api, issuerDID)
-      : null;
-
-    const metadata =
-      await blockchainService.dock.trustRegistry.registrySchemasMetadata(
-        {
-          schemaIds: [schemaIdHex],
-          ...(issuerDIDMethodKey && {
-            issuers: {
-              AnyOf: [issuerDIDMethodKey],
-            },
-          }),
-        },
-        trustRegistryId,
-      );
-
-    return metadata[schemaIdHex]?.verifiers;
-  }
-}
-
-export const trustRegistryService = new TrustRegistryService();

package/src/test/axiosMocks.js

@@ -1,20 +0,0 @@
-import axios from 'axios';
-import MockAdapter from 'axios-mock-adapter';
-import successData from './fixtures/subscan-success.json';
-import paramsFailure from './fixtures/subscan-failure.json';
-import requestFailure from './fixtures/subscan-too-many-requests.json';
-import {SUBSCAN_TRANSFER_URL} from '../core/subscan';
-
-const mockAdapter = new MockAdapter(axios);
-
-export function mockSubscanSuccess() {
-  mockAdapter.onPost(SUBSCAN_TRANSFER_URL).replyOnce(200, successData);
-}
-
-export function mockSubscanParamsFailure() {
-  mockAdapter.onPost(SUBSCAN_TRANSFER_URL).replyOnce(200, paramsFailure);
-}
-
-export function mockSubscanRequestFailure() {
-  mockAdapter.onPost(SUBSCAN_TRANSFER_URL).replyOnce(429, requestFailure);
-}

package/src/test/fixtures/subscan-failure.json

@@ -1,5 +0,0 @@
-{
-  "code": 10001,
-  "message": "Params Error",
-  "generated_at": 1643066008
-}