@docknetwork/wallet-sdk-wasm 0.4.19

package/src/services/relay-service/index.test.js

@@ -0,0 +1,67 @@
+import {assertRpcService} from '../test-utils';
+import {validation, SendMessageParams, GetMessagesParams} from './configs';
+import {relayService as service, relayServiceClient} from './service';
+import {RelayServiceRpc} from './service-rpc';
+
+describe('RelayService', () => {
+  it('ServiceRpc', () => {
+    assertRpcService(RelayServiceRpc, service, validation);
+  });
+
+  describe('service', () => {
+    it('expect to getMessages using relayServiceClient', async () => {
+      const mockResult = {
+        success: true,
+      };
+      const getMessageMock = jest
+        .spyOn(relayServiceClient, 'getMessages')
+        .mockImplementation(() => mockResult);
+      const params: GetMessagesParams = {keyPairDocs: [{}], limit: 10};
+      const result = await service.getMessages(params);
+
+      expect(result).toBe(mockResult);
+      expect(relayServiceClient.getMessages).toBeCalledWith(params);
+      getMessageMock.mockClear();
+    });
+
+    it('expect to sendMessages using relayServiceClient', async () => {
+      const mockResult = [
+        {
+          _id: '638a567a0562ef5792844699',
+          to: 'did:key:z6MkhN7PBjWgSMQ24Bebdpvvw8fVRv7m6MHDqiwTKozzBgrJ',
+          from: 'did:dock:5FoRVGjv9wJzH2X7sCewzvShAQh2LUUW73GU7Toe8DAswnVp',
+          msg: 'Test message 1670010489278',
+        },
+      ];
+      const sendMessageMock = jest
+        .spyOn(relayServiceClient, 'sendMessage')
+        .mockImplementation(() => mockResult);
+      const params: SendMessageParams = {
+        keyPairDoc: {},
+        recipientDid: 'some-did',
+        message: 'some-message',
+      };
+      const result = await service.sendMessage(params);
+
+      expect(result).toBe(mockResult);
+      expect(relayServiceClient.sendMessage).toBeCalledWith(params);
+
+      sendMessageMock.mockClear();
+    });
+  });
+
+  it('expect to resolve did comm messages', async () => {
+    const message = 'didcomm:some-base-64';
+    const mockResult = 'some-result';
+    const resolveMessageMock = jest
+      .spyOn(relayServiceClient, 'resolveDidcommMessage')
+      .mockImplementation(() => mockResult);
+
+    const keyPairDocs = ['keyPairDoc'];
+    const result = await service.resolveDidcommMessage({message, keyPairDocs});
+
+    expect(result).toBe(mockResult);
+
+    resolveMessageMock.mockClear();
+  });
+});

package/src/services/relay-service/service-rpc.ts

@@ -0,0 +1,40 @@
+import {RpcService} from '../rpc-service-client';
+import {
+  GetMessagesParams,
+  SendMessageParams,
+  ResolveDidcommMessageParams,
+  RegisterDIDPushNotificationParams,
+  serviceName,
+  validation,
+} from './configs';
+
+export class RelayServiceRpc extends RpcService {
+  constructor() {
+    super(serviceName);
+  }
+
+  sendMessage(params: SendMessageParams) {
+    validation.sendMessage(params);
+    return this.call('sendMessage', params);
+  }
+
+  getMessages(params: GetMessagesParams) {
+    validation.getMessages(params);
+    return this.call('getMessages', params);
+  }
+
+  registerDIDPushNotification(params: RegisterDIDPushNotificationParams) {
+    validation.registerDIDPushNotification(params);
+    return this.call('registerDIDPushNotification', params);
+  }
+
+  resolveDidcommMessage(params: ResolveDidcommMessageParams) {
+    validation.resolveDidcommMessage(params);
+    return this.call('resolveDidcommMessage', params);
+  }
+
+  signJwt(params: ResolveDidcommMessageParams) {
+    validation.signJwt(params);
+    return this.call('signJwt', params);
+  }
+}

package/src/services/relay-service/service.ts

@@ -0,0 +1,58 @@
+import {
+  SendMessageParams,
+  GetMessagesParams,
+  ResolveDidcommMessageParams,
+  RegisterDIDPushNotificationParams,
+  serviceName,
+  validation,
+} from './configs';
+
+import {RelayService as relayServiceClient} from '@docknetwork/wallet-sdk-relay-service/src';
+
+/**
+ * RelayService
+ */
+export class RelayService {
+  name: string;
+
+  rpcMethods = [
+    RelayService.prototype.getMessages,
+    RelayService.prototype.sendMessage,
+    RelayService.prototype.registerDIDPushNotification,
+    RelayService.prototype.resolveDidcommMessage,
+    RelayService.prototype.signJwt,
+  ];
+
+  constructor() {
+    this.name = serviceName;
+  }
+
+  sendMessage(params: SendMessageParams) {
+    validation.sendMessage(params);
+    return relayServiceClient.sendMessage(params as any);
+  }
+
+  resolveDidcommMessage(params: ResolveDidcommMessageParams) {
+    validation.resolveDidcommMessage(params);
+    return relayServiceClient.resolveDidcommMessage(params);
+  }
+
+  signJwt(params: ResolveDidcommMessageParams) {
+    validation.signJwt(params);
+    return relayServiceClient.signJwt(params);
+  }
+
+  getMessages(params: GetMessagesParams) {
+    validation.getMessages(params);
+    return relayServiceClient.getMessages(params);
+  }
+
+  registerDIDPushNotification(params: RegisterDIDPushNotificationParams) {
+    validation.registerDIDPushNotification(params);
+    return relayServiceClient.registerDIDPushNotification(params);
+  }
+}
+
+export {relayServiceClient};
+
+export const relayService: RelayService = new RelayService();

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

@@ -0,0 +1,23 @@
+import assert from 'assert';
+import {rpcRequest} from '../rpc-client';
+
+export class RpcService {
+  serviceName: string;
+  sandbox: Boolean;
+
+  constructor(serviceName) {
+    assert(!!serviceName, 'serviceName is required');
+
+    this.serviceName = serviceName;
+    this.sandbox = false;
+  }
+
+  call(method, ...params) {
+    assert(typeof method === 'string', 'method is required');
+
+    return rpcRequest(
+      `${this.sandbox ? 'sandbox-' : ''}${this.serviceName}.${method}`,
+      ...params,
+    );
+  }
+}

package/src/services/sandbox.js

@@ -0,0 +1,3 @@
+import {pexService} from './pex/service';
+
+export default [pexService];

package/src/services/storage/configs.ts

@@ -0,0 +1 @@
+export const validation = {};

package/src/services/storage/index.android.js

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

package/src/services/storage/index.ios.js

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

package/src/services/storage/index.js

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

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

@@ -0,0 +1,26 @@
+import {assertRpcService} from '../test-utils';
+import {validation} from './configs';
+import {storageService as service} from './service';
+import {StorageServiceRpc} from './service-rpc';
+
+global.localStorage = {
+  setItem: jest.fn(),
+};
+
+describe('StorageService', () => {
+  it('ServiceRpc', () => {
+    assertRpcService(StorageServiceRpc, service, validation);
+  });
+
+  describe('service', () => {
+    beforeAll(async () => {});
+
+    describe('setItem', () => {
+      it('expect to setItem', async () => {
+        const data = 2;
+        await service.setItem(data);
+        expect(global.localStorage.setItem).toBeCalledWith(data);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,19 @@
+import {RpcService} from '../rpc-service-client';
+
+export class StorageServiceRpc extends RpcService {
+  constructor() {
+    super('storage');
+  }
+
+  setItem(...args): Promise<any> {
+    return this.call('setItem', ...args);
+  }
+
+  removeItem(...args): Promise<any> {
+    return this.call('removeItem', ...args);
+  }
+
+  getItem(...args): Promise<any> {
+    return this.call('getItem', ...args);
+  }
+}

package/src/services/storage/service.ts

@@ -0,0 +1,26 @@
+// @ts-nocheck
+export class StorageService {
+  rpcMethods = [
+    StorageService.prototype.setItem,
+    StorageService.prototype.getItem,
+    StorageService.prototype.removeItem,
+  ];
+
+  constructor() {
+    this.name = 'storage';
+  }
+
+  setItem(...args): Promise<any> {
+    return global.localStorage.setItem(...args);
+  }
+
+  removeItem(...args): Promise<any> {
+    return global.localStorage.removeItem(...args);
+  }
+
+  getItem(...args): Promise<any> {
+    return global.localStorage.getItem(...args);
+  }
+}
+
+export const storageService: StorageService = new StorageService();

package/src/services/substrate/api-utils.test.js

@@ -0,0 +1,73 @@
+import {DOCK_TOKEN_UNIT} from '../../core/format-utils';
+import {TestFixtures} from '../../fixtures';
+import {once} from '../../modules/event-manager';
+import {dockService} from '../dock/service';
+import {mockDockService, setMockTransactionError} from '../test-utils';
+import {signAndSend} from './api-utils';
+import {substrateService} from './service';
+
+describe('ApiUtils', () => {
+  let unmockDockService;
+
+  beforeAll(async () => {
+    unmockDockService = await mockDockService();
+  });
+
+  describe('signAndSend', () => {
+    it('expect to send tokens', async () => {
+      const account = TestFixtures.account1.getKeyring();
+      dockService.dock.setAccount(account);
+      const extrinsic = dockService.dock.api.tx.balances.transfer(
+        TestFixtures.account2.address,
+        1,
+      );
+      setMockTransactionError(null);
+      const emitter = signAndSend(account, extrinsic);
+      const [result] = await once(emitter, 'done');
+
+      console.log('tx hash', result);
+
+      expect(typeof result).toBe('string');
+    });
+
+    it('expect to get error: Inability to pay fees', async () => {
+      const account = TestFixtures.noBalanceAccount.getKeyring();
+      dockService.dock.setAccount(account);
+      const extrinsic = dockService.dock.api.tx.balances.transfer(
+        TestFixtures.account2.address,
+        1,
+      );
+      const errorMessage =
+        '1010: Invalid Transaction: Inability to pay some fees , e.g. account balance too low';
+
+      setMockTransactionError(errorMessage);
+      const emitter = signAndSend(account, extrinsic);
+      const error = await once(emitter, 'error');
+
+      expect(error.message).toBe(errorMessage);
+    });
+
+    it('expect to get error: Not enough balance', async () => {
+      const account = TestFixtures.account1.getKeyring();
+      dockService.dock.setAccount(account);
+      const balance = await substrateService.getAccountBalance({
+        address: TestFixtures.account1.address,
+      });
+      const extrinsic = dockService.dock.api.tx.balances.transfer(
+        TestFixtures.account2.address,
+        balance * 2 * DOCK_TOKEN_UNIT,
+      );
+
+      const errorMessage =
+        'balances.InsufficientBalance:  Balance too low to send value';
+
+      setMockTransactionError(errorMessage);
+      const emitter = signAndSend(account, extrinsic);
+      const error = await once(emitter, 'error');
+
+      expect(error.message).toBe(errorMessage);
+    });
+  });
+
+  afterAll(() => unmockDockService);
+});

package/src/services/substrate/api-utils.ts

@@ -0,0 +1,66 @@
+// @ts-nocheck
+import assert from 'assert';
+import {EventEmitter} from 'events';
+import {Logger} from '../../core/logger';
+import {dockService} from '../dock/service';
+
+export const extrisicErrorsFilter = ({event}) => {
+  return dockService.dock.api.events.system.ExtrinsicFailed.is(event);
+};
+
+export const mapEventToErrorMessage = ({event}) => {
+  assert(!!event, 'event is required');
+
+  const [error] = event.data;
+  assert(!!error, 'error is required');
+
+  if (error.isModule) {
+    // for module errors, we have the section indexed, lookup
+    const decoded = dockService.dock.api.registry.findMetaError(error.asModule);
+    const {docs, method, section} = decoded;
+
+    return `${section}.${method}: ${docs.join(' ')}`;
+  }
+
+  return error.toString();
+};
+
+export const getExtrinsicErrors = ({status, events}) =>
+  events.filter(extrisicErrorsFilter).map(mapEventToErrorMessage);
+
+export function signAndSend(account, extrinsic: any): EventEmitter {
+  const emitter = new EventEmitter();
+
+  function execute() {
+    extrinsic
+      .signAndSend(account, result => {
+        const {status} = result;
+
+        Logger.debug(`extrinsic update ${JSON.stringify(result)}`);
+
+        if (status.isInBlock || status.isFinalized) {
+          const errors = getExtrinsicErrors(result);
+
+          if (!errors.length) {
+            return emitter.emit('done', status.toHex());
+          }
+
+          emitter.emit('error', new Error(errors[0]));
+          emitter.emit('errors', errors);
+        } else if (status.isInvalid) {
+          emitter.emit('error', new Error('Transaction status is invalid'));
+        } else if (status.isDropped) {
+          emitter.emit('error', new Error('Transaction status dropped'));
+        } else if (status.isRetracted) {
+          emitter.emit('error', new Error('Transaction status is retracted'));
+        }
+      })
+      .catch(err => {
+        emitter.emit('error', err);
+      });
+  }
+
+  setTimeout(execute, 1);
+
+  return emitter;
+}

package/src/services/substrate/configs.ts

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import assert from 'assert';
+import {isAddressValid, isNumberValid} from '../../core/validation';
+
+const assertTransaction = ({
+  toAddress,
+  fromAddress,
+  amount,
+}: TransactionParams) => {
+  assert(isAddressValid(toAddress), 'invalid toAddress');
+  assert(isAddressValid(fromAddress), 'invalid fromAddress');
+  assert(isNumberValid(amount), 'invalid amount');
+};
+
+export const validation = {
+  getAccountBalance({address}: GetAccountBalanceParams) {
+    assert(isAddressValid(address), `invalid address ${address}`);
+  },
+  getFeeAmount: assertTransaction,
+  sendTokens: assertTransaction,
+};
+
+export const serviceName = 'substrate';
+
+export type GetAccountBalanceParams = {
+  address: string,
+};
+
+export type TransactionParams = {
+  toAddress: string,
+  fromAddress: string,
+  amount: number | string,
+  transferAll?: boolean,
+};

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

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

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

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

package/src/services/substrate/index.js

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

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

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

@@ -0,0 +1,24 @@
+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);
+  }
+}