@spacesops/wdk-react-native-provider 1.0.0-beta.3

package/src/services/wdk-service/types.ts

@@ -0,0 +1,137 @@
+export enum AssetTicker {
+  BTC = 'btc',
+  USDT = 'usdt',
+  XAUT = 'xaut',
+}
+
+export enum NetworkType {
+  SEGWIT = 'bitcoin',
+  LIGHTNING = 'lightning',
+  ETHEREUM = 'ethereum',
+  SOLANA = 'solana',
+  TRON = 'tron',
+  TON = 'ton',
+  POLYGON = 'polygon',
+  ARBITRUM = 'arbitrum',
+}
+
+export const AssetAddressMap = {
+  [AssetTicker.BTC]: {
+    [NetworkType.SEGWIT]: 'bitcoin',
+  },
+  [AssetTicker.USDT]: {
+    [NetworkType.ETHEREUM]: 'ethereum',
+    [NetworkType.POLYGON]: 'polygon',
+    [NetworkType.ARBITRUM]: 'arbitrum',
+    [NetworkType.TON]: 'ton',
+  },
+  [AssetTicker.XAUT]: {
+    [NetworkType.ETHEREUM]: 'ethereum',
+  },
+};
+
+export const AssetBalanceMap = {
+  [AssetTicker.BTC]: {
+    [NetworkType.SEGWIT]: 'bitcoin',
+  },
+  [AssetTicker.USDT]: {
+    [NetworkType.ETHEREUM]: 'ethereum',
+    [NetworkType.POLYGON]: 'polygon',
+    [NetworkType.ARBITRUM]: 'arbitrum',
+    [NetworkType.TON]: 'ton',
+  },
+  [AssetTicker.XAUT]: {
+    [NetworkType.ETHEREUM]: 'ethereum',
+  },
+};
+
+export interface Amount {
+  denomination: AssetTicker;
+  value: string;
+  networkType: NetworkType;
+}
+
+export interface Wallet {
+  id: string;
+  name: string;
+  enabledAssets: AssetTicker[];
+}
+
+export type AddressMap = Partial<Record<NetworkType, string>>;
+export type BalanceMap = Record<
+  string,
+  { balance: number; asset: AssetTicker }
+>;
+export type TransactionMap = Partial<Record<NetworkType, Transaction[]>>;
+
+export interface Transaction {
+  blockchain: string;
+  blockNumber: number;
+  transactionHash: string;
+  transferIndex: number;
+  token: string;
+  amount: string;
+  timestamp: number;
+  transactionIndex: number;
+  logIndex: number;
+  from: string;
+  to: string;
+}
+
+export interface PaymasterToken {
+  address: string;
+}
+
+export interface EVMChainConfig {
+  chainId: number;
+  blockchain: string;
+  provider: string;
+  bundlerUrl: string;
+  paymasterUrl: string;
+  paymasterAddress: string;
+  entrypointAddress: string;
+  transferMaxFee: number;
+  swapMaxFee: number;
+  bridgeMaxFee: number;
+  paymasterToken: PaymasterToken;
+  safeModulesVersion?: string;
+}
+
+export interface TONChainConfig {
+  tonApiClient: {
+    url: string;
+  };
+  tonClient: {
+    url: string;
+  };
+  paymasterToken: PaymasterToken;
+  transferMaxFee: number;
+}
+
+export interface BitcoinChainConfig {
+  host: string;
+  port: number;
+}
+
+export interface TronChainConfig {
+  chainId: number;
+  provider: string;
+  gasFreeProvider: string;
+  apiKey: string;
+  apiSecret: string;
+  serviceProvider: string;
+  verifyingContract: string;
+  transferMaxFee: number;
+  swapMaxFee: number;
+  bridgeMaxFee: number;
+  paymasterToken: PaymasterToken;
+}
+
+export interface ChainsConfig {
+  ethereum?: EVMChainConfig;
+  arbitrum?: EVMChainConfig;
+  polygon?: EVMChainConfig;
+  ton?: TONChainConfig;
+  bitcoin?: BitcoinChainConfig;
+  tron?: TronChainConfig;
+}

package/src/services/wdk-service/wdk-encryption-salt.ts

@@ -0,0 +1,30 @@
+const MAX_BYTES = 16;
+
+function generateWdkSalt(email: any): Buffer {
+  const localPart = email.split('@')[0];
+
+  // Encode the local part using TextEncoder
+  const encoder = new TextEncoder();
+  const encoded = encoder.encode(localPart);
+
+  // Prepare a MAX_BYTES-byte buffer
+  const bf = new Uint8Array(MAX_BYTES);
+
+  if (encoded.length > MAX_BYTES) {
+    // If more than MAX_BYTES bytes, take the last MAX_BYTES bytes
+    const sliced = encoded.slice(0, MAX_BYTES);
+    bf.set(sliced);
+  } else {
+    // Copy encoded bytes to beginning
+    bf.set(encoded, 0);
+
+    // Fill the remaining bytes with 7
+    bf.fill(7, encoded.length);
+  }
+
+  return bf as Buffer;
+}
+
+export const wdkEncryptionSalt = {
+  generateWdkSalt,
+};

package/src/services/wdk-service/wdk-secret-manager-storage.ts

@@ -0,0 +1,102 @@
+import b4a from 'b4a';
+import * as Keychain from 'react-native-keychain';
+
+export const WDK_STORAGE_SEED = 'seed' as const;
+export const WDK_STORAGE_ENTROPY = 'entropy' as const;
+export const WDK_STORAGE_SALT = 'salt' as const;
+
+export class WdkSecretManagerStorage {
+  static BASE_SERVICE_NAME = 'wdk.secretManager';
+
+  static async saveData(
+    key:
+      | typeof WDK_STORAGE_SEED
+      | typeof WDK_STORAGE_ENTROPY
+      | typeof WDK_STORAGE_SALT,
+    value: Buffer | string
+  ) {
+    const itemService = WdkSecretManagerStorage.getServiceForItem(key);
+    await Keychain.setGenericPassword(
+      key,
+      b4a.isBuffer(value) ? b4a.toString(value, 'hex') : value,
+      {
+        service: itemService,
+        accessControl:
+          key === 'seed' ? Keychain.ACCESS_CONTROL.BIOMETRY_ANY : undefined,
+      }
+    );
+  }
+
+  static async retrieveData(
+    key:
+      | typeof WDK_STORAGE_SEED
+      | typeof WDK_STORAGE_ENTROPY
+      | typeof WDK_STORAGE_SALT
+  ) {
+    const itemService = WdkSecretManagerStorage.getServiceForItem(key);
+
+    try {
+      const credentials = await Keychain.getGenericPassword({
+        service: itemService,
+        accessControl:
+          key === 'seed' ? Keychain.ACCESS_CONTROL.BIOMETRY_ANY : undefined,
+      });
+      if (credentials) {
+        return b4a.from(credentials.password, 'hex');
+      }
+      console.info(
+        `For key ${itemService} in secure storage data do not exist.`
+      );
+      return false;
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+  }
+
+  static async hasKey(
+    key:
+      | typeof WDK_STORAGE_SEED
+      | typeof WDK_STORAGE_ENTROPY
+      | typeof WDK_STORAGE_SALT
+  ) {
+    const itemService = WdkSecretManagerStorage.getServiceForItem(key);
+    return await Keychain.hasGenericPassword({ service: itemService });
+  }
+
+  static async resetData(
+    key:
+      | typeof WDK_STORAGE_SEED
+      | typeof WDK_STORAGE_ENTROPY
+      | typeof WDK_STORAGE_SALT
+  ) {
+    const itemService = WdkSecretManagerStorage.getServiceForItem(key);
+    try {
+      const success = await Keychain.resetGenericPassword({
+        service: itemService,
+      });
+      if (success) {
+        console.info(`Item for key '${key}' was reset successfully.`);
+      }
+      return true;
+    } catch (error) {
+      console.error(`Failed to reset item for key '${key}':`, error);
+      return false;
+    }
+  }
+
+  static async resetAllData() {
+    await WdkSecretManagerStorage.resetData(WDK_STORAGE_ENTROPY);
+    await WdkSecretManagerStorage.resetData(WDK_STORAGE_SEED);
+    await WdkSecretManagerStorage.resetData(WDK_STORAGE_SALT);
+  }
+
+  static getServiceForItem(
+    key:
+      | typeof WDK_STORAGE_SEED
+      | typeof WDK_STORAGE_ENTROPY
+      | typeof WDK_STORAGE_SALT
+  ) {
+    return `${WdkSecretManagerStorage.BASE_SERVICE_NAME}.${key}`;
+  }
+}

package/src/spec/hrpc/hrpc.json

@@ -0,0 +1,66 @@
+{
+  "version": 1,
+  "schema": [
+    {
+      "id": 0,
+      "name": "@tetherto/wdk-secret-manager/command-workletStart",
+      "request": {
+        "name": "@tetherto/wdk-secret-manager/command-workletStart-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@tetherto/wdk-secret-manager/command-workletStart-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 1,
+      "name": "@tetherto/wdk-secret-manager/command-workletStop",
+      "request": {
+        "name": "@tetherto/wdk-secret-manager/command-workletStop-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@tetherto/wdk-secret-manager/command-workletStop-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 2,
+      "name": "@tetherto/wdk-secret-manager/command-generateAndEncrypt",
+      "request": {
+        "name": "@tetherto/wdk-secret-manager/command-generateAndEncrypt-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@tetherto/wdk-secret-manager/command-generateAndEncrypt-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 3,
+      "name": "@tetherto/wdk-secret-manager/command-decrypt",
+      "request": {
+        "name": "@tetherto/wdk-secret-manager/command-decrypt-request",
+        "stream": false
+      },
+      "response": {
+        "name": "@tetherto/wdk-secret-manager/command-decrypt-response",
+        "stream": false
+      },
+      "version": 1
+    },
+    {
+      "id": 4,
+      "name": "@tetherto/wdk-secret-manager/command-log",
+      "request": {
+        "name": "@tetherto/wdk-secret-manager/command-log-request",
+        "send": true
+      },
+      "version": 1
+    }
+  ]
+}

package/src/spec/hrpc/index.js

@@ -0,0 +1,228 @@
+// This file is autogenerated by the hrpc compiler
+
+const { c, RPC, RPCStream, RPCRequestStream } = require('hrpc/runtime');
+const { getEncoding } = require('./messages.js');
+
+const methods = new Map([
+  ['@tetherto/wdk-secret-manager/command-workletStart', 0],
+  [0, '@tetherto/wdk-secret-manager/command-workletStart'],
+  ['@tetherto/wdk-secret-manager/command-workletStop', 1],
+  [1, '@tetherto/wdk-secret-manager/command-workletStop'],
+  ['@tetherto/wdk-secret-manager/command-generateAndEncrypt', 2],
+  [2, '@tetherto/wdk-secret-manager/command-generateAndEncrypt'],
+  ['@tetherto/wdk-secret-manager/command-decrypt', 3],
+  [3, '@tetherto/wdk-secret-manager/command-decrypt'],
+  ['@tetherto/wdk-secret-manager/command-log', 4],
+  [4, '@tetherto/wdk-secret-manager/command-log'],
+]);
+
+class HRPC {
+  constructor(stream) {
+    this._stream = stream;
+    this._handlers = [];
+    this._requestEncodings = new Map([
+      [
+        '@tetherto/wdk-secret-manager/command-workletStart',
+        getEncoding(
+          '@tetherto/wdk-secret-manager/command-workletStart-request'
+        ),
+      ],
+      [
+        '@tetherto/wdk-secret-manager/command-workletStop',
+        getEncoding('@tetherto/wdk-secret-manager/command-workletStop-request'),
+      ],
+      [
+        '@tetherto/wdk-secret-manager/command-generateAndEncrypt',
+        getEncoding(
+          '@tetherto/wdk-secret-manager/command-generateAndEncrypt-request'
+        ),
+      ],
+      [
+        '@tetherto/wdk-secret-manager/command-decrypt',
+        getEncoding('@tetherto/wdk-secret-manager/command-decrypt-request'),
+      ],
+      [
+        '@tetherto/wdk-secret-manager/command-log',
+        getEncoding('@tetherto/wdk-secret-manager/command-log-request'),
+      ],
+    ]);
+    this._responseEncodings = new Map([
+      [
+        '@tetherto/wdk-secret-manager/command-workletStart',
+        getEncoding(
+          '@tetherto/wdk-secret-manager/command-workletStart-response'
+        ),
+      ],
+      [
+        '@tetherto/wdk-secret-manager/command-workletStop',
+        getEncoding(
+          '@tetherto/wdk-secret-manager/command-workletStop-response'
+        ),
+      ],
+      [
+        '@tetherto/wdk-secret-manager/command-generateAndEncrypt',
+        getEncoding(
+          '@tetherto/wdk-secret-manager/command-generateAndEncrypt-response'
+        ),
+      ],
+      [
+        '@tetherto/wdk-secret-manager/command-decrypt',
+        getEncoding('@tetherto/wdk-secret-manager/command-decrypt-response'),
+      ],
+    ]);
+    this._rpc = new RPC(stream, async (req) => {
+      const command = methods.get(req.command);
+      const responseEncoding = this._responseEncodings.get(command);
+      const requestEncoding = this._requestEncodings.get(command);
+      if (this._requestIsSend(command)) {
+        const request = req.data ? c.decode(requestEncoding, req.data) : null;
+        await this._handlers[command](request);
+        return;
+      }
+      if (!this._requestIsStream(command) && !this._responseIsStream(command)) {
+        const request = req.data ? c.decode(requestEncoding, req.data) : null;
+        const response = await this._handlers[command](request);
+        req.reply(c.encode(responseEncoding, response));
+      }
+      if (!this._requestIsStream(command) && this._responseIsStream(command)) {
+        const request = req.data ? c.decode(requestEncoding, req.data) : null;
+        const responseStream = new RPCStream(
+          null,
+          null,
+          req.createResponseStream(),
+          responseEncoding
+        );
+        responseStream.data = request;
+        await this._handlers[command](responseStream);
+      }
+      if (this._requestIsStream(command) && !this._responseIsStream(command)) {
+        const requestStream = new RPCRequestStream(
+          req,
+          responseEncoding,
+          req.createRequestStream(),
+          requestEncoding
+        );
+        const response = await this._handlers[command](requestStream);
+        req.reply(c.encode(responseEncoding, response));
+      }
+      if (this._requestIsStream(command) && this._responseIsStream(command)) {
+        const requestStream = new RPCRequestStream(
+          req,
+          responseEncoding,
+          req.createRequestStream(),
+          requestEncoding,
+          req.createResponseStream(),
+          responseEncoding
+        );
+        await this._handlers[command](requestStream);
+      }
+    });
+  }
+
+  async _call(name, args) {
+    const requestEncoding = this._requestEncodings.get(name);
+    const responseEncoding = this._responseEncodings.get(name);
+    const request = this._rpc.request(methods.get(name));
+    const encoded = c.encode(requestEncoding, args);
+    request.send(encoded);
+    return c.decode(responseEncoding, await request.reply());
+  }
+
+  _callSync(name, args) {
+    const requestEncoding = this._requestEncodings.get(name);
+    const responseEncoding = this._responseEncodings.get(name);
+    const request = this._rpc.request(methods.get(name));
+    if (this._requestIsSend(name)) {
+      const encoded = c.encode(requestEncoding, args);
+      request.send(encoded);
+    }
+    if (!this._requestIsStream(name) && this._responseIsStream(name)) {
+      const encoded = c.encode(requestEncoding, args);
+      request.send(encoded);
+      return new RPCStream(request.createResponseStream(), responseEncoding);
+    }
+    if (this._requestIsStream(name) && !this._responseIsStream(name)) {
+      return new RPCRequestStream(
+        request,
+        responseEncoding,
+        null,
+        null,
+        request.createRequestStream(),
+        requestEncoding
+      );
+    }
+    if (this._requestIsStream(name) && this._responseIsStream(name)) {
+      return new RPCRequestStream(
+        request,
+        responseEncoding,
+        request.createResponseStream(),
+        responseEncoding,
+        request.createRequestStream(),
+        requestEncoding
+      );
+    }
+  }
+
+  async commandWorkletStart(args) {
+    return this._call(
+      '@tetherto/wdk-secret-manager/command-workletStart',
+      args
+    );
+  }
+
+  async commandWorkletStop(args) {
+    return this._call('@tetherto/wdk-secret-manager/command-workletStop', args);
+  }
+
+  async commandGenerateAndEncrypt(args) {
+    return this._call(
+      '@tetherto/wdk-secret-manager/command-generateAndEncrypt',
+      args
+    );
+  }
+
+  async commandDecrypt(args) {
+    return this._call('@tetherto/wdk-secret-manager/command-decrypt', args);
+  }
+
+  commandLog(args) {
+    return this._callSync('@tetherto/wdk-secret-manager/command-log', args);
+  }
+
+  onCommandWorkletStart(responseFn) {
+    this._handlers['@tetherto/wdk-secret-manager/command-workletStart'] =
+      responseFn;
+  }
+
+  onCommandWorkletStop(responseFn) {
+    this._handlers['@tetherto/wdk-secret-manager/command-workletStop'] =
+      responseFn;
+  }
+
+  onCommandGenerateAndEncrypt(responseFn) {
+    this._handlers['@tetherto/wdk-secret-manager/command-generateAndEncrypt'] =
+      responseFn;
+  }
+
+  onCommandDecrypt(responseFn) {
+    this._handlers['@tetherto/wdk-secret-manager/command-decrypt'] = responseFn;
+  }
+
+  onCommandLog(responseFn) {
+    this._handlers['@tetherto/wdk-secret-manager/command-log'] = responseFn;
+  }
+
+  _requestIsStream(command) {
+    return [].includes(command);
+  }
+
+  _responseIsStream(command) {
+    return [].includes(command);
+  }
+
+  _requestIsSend(command) {
+    return ['@tetherto/wdk-secret-manager/command-log'].includes(command);
+  }
+}
+
+module.exports = HRPC;