@subwallet/extension-base 0.8.3-2 → 1.0.1

package/utils/eth/parseTransaction/base.js

@@ -0,0 +1,273 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { Buffer } from 'buffer';
+import { ethers } from 'ethers';
+import isBuffer from 'is-buffer';
+// @ts-ignore
+import { _jsonInterfaceMethodToString, keccak256 } from 'web3-utils';
+const ABI_TYPES = ['function', 'constructor', 'event', 'fallback'];
+const instanceOfAbiItem = object => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+  return 'type' in object && ABI_TYPES.includes(object.type);
+};
+const checkArrayAbiItems = data => {
+  if (Array.isArray(data)) {
+    return data.length > 0 && data.every(value => instanceOfAbiItem(value));
+  } else {
+    return false;
+  }
+};
+const genType = type => {
+  if (typeof type === 'string') {
+    return type;
+  } else {
+    if (type.components) {
+      var _type$components;
+      const arr = (_type$components = type.components) === null || _type$components === void 0 ? void 0 : _type$components.map(genType);
+      const tupleStr = `(${arr.join(',')})`;
+      if (type.type === 'tuple[]') {
+        return tupleStr + '[]';
+      } else {
+        return tupleStr;
+      }
+    } else {
+      return type.type;
+    }
+  }
+};
+const getMethodId = abi => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-call
+  return keccak256(_jsonInterfaceMethodToString(abi)).slice(2, 10);
+};
+const getMethodName = abi => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-call
+  return _jsonInterfaceMethodToString(abi);
+};
+const deepRemoveUnwantedArrayProperties = arr => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-return
+  return [...arr.map(item => {
+    if (Array.isArray(item)) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return deepRemoveUnwantedArrayProperties(item);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return item;
+  })];
+};
+
+// remove 0x from addresses
+const deepStripTupleAddresses = (input, tupleTypes) => input.map((item, i) => {
+  // We find tupleTypes to not be an array where internalType is present in the ABI indicating item is a structure
+  const type = tupleTypes[i] ? tupleTypes[i].type : null;
+  if (type === 'address' && typeof item === 'string') {
+    return item;
+  }
+  if (type === 'address[]' && Array.isArray(item)) {
+    return item.map(a => a);
+  }
+  if (Array.isArray(item)) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return deepStripTupleAddresses(item, tupleTypes);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return item;
+});
+const toHexString = byteArray => {
+  return Array.from(byteArray, function (byte) {
+    return ('0' + (byte & 0xFF).toString(16)).slice(-2);
+  }).join('');
+};
+export class InputDataDecoder {
+  constructor(prop) {
+    this.abi = [];
+    if (typeof prop === 'string') {
+      try {
+        this.abi = JSON.parse(prop);
+      } catch (err) {
+        throw new Error(`Invalid ABI: ${err.message}`);
+      }
+    } else if (checkArrayAbiItems(prop)) {
+      this.abi = prop;
+    } else {
+      throw new TypeError('Must pass ABI array object or file path to constructor');
+    }
+  }
+  decodeConstructor(data) {
+    if (isBuffer(data)) {
+      data = data.toString('utf8');
+    }
+    if (typeof data !== 'string') {
+      data = '';
+    }
+    data = data.trim();
+    for (let i = 0; i < this.abi.length; i++) {
+      const obj = this.abi[i];
+      if (obj.type !== 'constructor') {
+        continue;
+      }
+      const method = obj.name || null;
+      const methodName = getMethodName(obj);
+      const types = obj.inputs ? obj.inputs.map(x => x.type) : [];
+      const names = obj.inputs ? obj.inputs.map(x => x.name) : [];
+
+      // take last 32 bytes
+      data = data.slice(-256);
+      if (data.length !== 256) {
+        throw new Error('fail');
+      }
+      if (data.indexOf('0x') !== 0) {
+        data = `0x${data}`;
+      }
+      const _inputs = ethers.utils.defaultAbiCoder.decode(types, data);
+      const inputs = deepRemoveUnwantedArrayProperties(_inputs);
+      return {
+        methodName,
+        method,
+        types,
+        inputs,
+        names
+      };
+    }
+    throw new Error('not found');
+  }
+  decodeData(data) {
+    if (isBuffer(data)) {
+      data = data.toString('utf8');
+    }
+    if (typeof data !== 'string') {
+      data = '';
+    }
+    data = data.trim();
+    const dataBuf = Buffer.from(data.replace(/^0x/, ''), 'hex');
+    const methodId = toHexString(dataBuf.subarray(0, 4));
+    const inputsBuf = dataBuf.subarray(4);
+    let result = {
+      method: null,
+      methodName: null,
+      types: [],
+      inputs: [],
+      names: []
+    };
+    for (const abi of this.abi) {
+      try {
+        if (abi.type === 'constructor') {
+          continue;
+        }
+        if (abi.type === 'event') {
+          continue;
+        }
+        const method = abi.name || null;
+        const methodName = getMethodName(abi);
+        const types = abi.inputs ? abi.inputs.map(x => {
+          if (x.type.includes('tuple')) {
+            return x;
+          } else {
+            return x.type;
+          }
+        }) : [];
+        const names = abi.inputs ? abi.inputs.map(x => {
+          if (x.type.includes('tuple') && x.components) {
+            return [x.name, x.components.map(a => a.name)];
+          } else {
+            return x.name;
+          }
+        }) : [];
+        const hash = getMethodId(abi);
+        if (hash === methodId) {
+          let inputs = [];
+          try {
+            // @ts-ignore
+            inputs = ethers.utils.defaultAbiCoder.decode(types, inputsBuf);
+          } catch (err) {
+            try {
+              const ifc = new ethers.utils.Interface([]);
+              inputs = ifc.decodeFunctionData(ethers.utils.FunctionFragment.fromObject(abi), data);
+            } catch (err) {}
+          }
+
+          // TODO: do this normalization into normalizeAddresses
+          let _inputs = [];
+          _inputs = inputs.map((input, i) => {
+            if (types[i].components) {
+              const tupleTypes = types[i].components;
+
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument
+              return deepStripTupleAddresses(input, tupleTypes);
+            }
+            if (types[i] === 'address' && typeof input === 'string') {
+              return input;
+            }
+            if (types[i] === 'address[]' && Array.isArray(input)) {
+              return input.map(address => address);
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return input;
+          });
+
+          // Map any tuple types into arrays
+          const typesToReturn = types.map(genType);
+
+          // defaultAbiCoder attaches some unwanted properties to the list object
+          _inputs = deepRemoveUnwantedArrayProperties(_inputs);
+          result = {
+            methodName,
+            method,
+            types: typesToReturn,
+            inputs: _inputs,
+            names
+          };
+        }
+      } catch (err) {
+        console.log(err);
+      }
+    }
+    if (!result.method) {
+      for (const obj of this.abi) {
+        if (obj.type === 'constructor') {
+          continue;
+        }
+        if (obj.type === 'event') {
+          continue;
+        }
+        const method = obj.name || null;
+        try {
+          const ifc = new ethers.utils.Interface([]);
+          const _result = ifc.decodeFunctionData(ethers.utils.FunctionFragment.fromObject(obj), data);
+          const inputs = deepRemoveUnwantedArrayProperties(_result);
+          result.method = method;
+          result.methodName = getMethodName(obj);
+          result.inputs = inputs;
+          result.names = obj.inputs ? obj.inputs.map(x => {
+            if (x.type.includes('tuple')) {
+              var _x$components;
+              return [x.name, ((_x$components = x.components) === null || _x$components === void 0 ? void 0 : _x$components.map(a => a.name)) || ''];
+            } else {
+              return x.name;
+            }
+          }) : [];
+          const types = obj.inputs ? obj.inputs.map(x => {
+            if (x.type.includes('tuple')) {
+              return x;
+            } else {
+              return x.type;
+            }
+          }) : [];
+          result.types = types.map(genType);
+        } catch (err) {}
+      }
+    }
+    if (!result.method) {
+      try {
+        const decoded = this.decodeConstructor(data);
+        if (decoded) {
+          return decoded;
+        }
+      } catch (err) {}
+    }
+    return result;
+  }
+}

package/utils/eth/parseTransaction/index.d.ts

@@ -0,0 +1,6 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ResponseParseEvmContractInput, ResponseQrParseRLP } from '@subwallet/extension-base/background/KoniTypes';
+import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare const isContractAddress: (address: string, evmApi: _EvmApi) => Promise<boolean>;
+export declare const parseContractInput: (input: string, contractAddress: string, network: _ChainInfo | null) => Promise<ResponseParseEvmContractInput>;
+export declare const parseEvmRlp: (data: string, networkMap: Record<string, _ChainInfo>, evmApiMap: Record<string, _EvmApi>) => Promise<ResponseQrParseRLP>;

package/utils/eth/parseTransaction/index.js

@@ -0,0 +1,220 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _ERC20_ABI, _ERC721_ABI } from '@subwallet/extension-base/services/chain-service/helper';
+import { _getEvmAbiExplorer, _getEvmChainId, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { createTransactionFromRLP } from '@subwallet/extension-base/utils/eth';
+import { InputDataDecoder } from '@subwallet/extension-base/utils/eth/parseTransaction/base';
+import axios from 'axios';
+import BigN from 'bignumber.js';
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const ABIs = [_ERC20_ABI, _ERC721_ABI];
+const genName = name => {
+  if (typeof name === 'string') {
+    return name;
+  } else {
+    if (Array.isArray(name[1])) {
+      const _name = name[0];
+      const children = genName(name[1]);
+      return `${_name}(${children})`;
+    } else {
+      return name.join(', ');
+    }
+  }
+};
+const genInput = input => {
+  if (Array.isArray(input)) {
+    const arr = input.map(genInput);
+    return `[${arr.join(', ')}]`;
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
+    return input.toString();
+  }
+};
+const parseType = _types => {
+  const types = _types.trim();
+  if (types.indexOf('(') !== 0) {
+    if (!types.includes(',')) {
+      return types.trim();
+    } else {
+      const arr = [];
+      let s = types;
+      do {
+        if (s.indexOf('(') === 0) {
+          const start = s.indexOf('(');
+          const end = s.lastIndexOf(')');
+          const _new = s.slice(start, end + 1);
+          arr.push(_new);
+          s = s.replace(_new, '');
+        } else {
+          const start = s.indexOf(',');
+          if (start !== -1) {
+            const str = s.slice(0, start);
+            arr.push(str);
+            s = s.slice(start + 1).trim();
+          } else {
+            arr.push(s);
+            s = '';
+          }
+        }
+      } while (s.length);
+      return arr.map(s => s.trim());
+    }
+  } else {
+    const start = types.indexOf('(');
+    const end = types.lastIndexOf(')');
+    const _new = types.slice(start + 1, end);
+    return parseType(_new);
+  }
+};
+const parseResult = (type, input, name) => {
+  const types = parseType(type);
+  if (Array.isArray(types)) {
+    const inputs = input;
+    const _name = name[0];
+    const names = name[1];
+    const children = [];
+    types.forEach((type, index) => {
+      children.push(parseResult(type, inputs[index], names[index]));
+    });
+    return {
+      type: type,
+      name: _name,
+      value: genInput(input),
+      children: children
+    };
+  } else {
+    return {
+      type: types,
+      name: genName(name),
+      value: genInput(input)
+    };
+  }
+};
+export const isContractAddress = async (address, evmApi) => {
+  if (!evmApi) {
+    return false;
+  } else {
+    const code = await evmApi.api.eth.getCode(address);
+    return code !== '0x';
+  }
+};
+export const parseContractInput = async (input, contractAddress, network) => {
+  let result = input;
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const _ABIs = [...ABIs];
+  if (contractAddress && network) {
+    if (_getEvmAbiExplorer(network)) {
+      const res = await axios.get(_getEvmAbiExplorer(network), {
+        params: {
+          address: contractAddress
+        }
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (res.status === 200 && res.data.status === '1') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        _ABIs.unshift(res.data.result);
+      }
+    }
+  }
+  for (const abi of _ABIs) {
+    const decoder = new InputDataDecoder(abi);
+    const raw = decoder.decodeData(input);
+    if (raw.method && raw.methodName) {
+      const temp = {
+        method: raw.method,
+        methodName: raw.methodName,
+        args: []
+      };
+      raw.types.forEach((type, index) => {
+        temp.args.push(parseResult(type, raw.inputs[index], raw.names[index]));
+      });
+      result = temp;
+      break;
+    }
+  }
+  return {
+    result
+  };
+};
+const getChainInfoByChainId = (networkMap, chainId) => {
+  if (!chainId) {
+    for (const n in networkMap) {
+      if (!Object.prototype.hasOwnProperty.call(networkMap, n)) {
+        continue;
+      }
+      const networkInfo = networkMap[n];
+      if (_isChainEvmCompatible(networkInfo)) {
+        return networkInfo;
+      }
+    }
+    return null;
+  }
+  for (const n in networkMap) {
+    if (!Object.prototype.hasOwnProperty.call(networkMap, n)) {
+      continue;
+    }
+    const networkInfo = networkMap[n];
+    if (_getEvmChainId(networkInfo) === chainId) {
+      return networkInfo;
+    }
+  }
+  return null;
+};
+export const parseEvmRlp = async (data, networkMap, evmApiMap) => {
+  const tx = createTransactionFromRLP(data);
+  if (!tx) {
+    throw new Error(`Cannot create tx from ${data}`);
+  }
+  const result = {
+    input: tx.data,
+    data: tx.data,
+    gasPrice: new BigN(tx.gasPrice).toNumber(),
+    gas: new BigN(tx.gas).toNumber(),
+    to: tx.action,
+    value: new BigN(tx.value).toNumber(),
+    nonce: new BigN(tx.nonce).toNumber()
+  };
+  const network = getChainInfoByChainId(networkMap, parseInt(tx.ethereumChainId));
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const _ABIs = [...ABIs];
+  if (tx.action && network) {
+    if (await isContractAddress(tx.action, evmApiMap[network.slug])) {
+      if (_getEvmAbiExplorer(network) !== '') {
+        const res = await axios.get(_getEvmAbiExplorer(network), {
+          params: {
+            address: tx.action
+          }
+        });
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if (res.status === 200 && res.data.status === '1') {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          _ABIs.unshift(res.data.result);
+        }
+      }
+    }
+  }
+  for (const abi of _ABIs) {
+    const decoder = new InputDataDecoder(abi);
+    const raw = decoder.decodeData(tx.data);
+    if (raw.method && raw.methodName) {
+      const temp = {
+        method: raw.method,
+        methodName: raw.methodName,
+        args: []
+      };
+      raw.types.forEach((type, index) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+        temp.args.push(parseResult(type, raw.inputs[index], raw.names[index]));
+      });
+      result.data = temp;
+      break;
+    }
+  }
+  return result;
+};

package/utils/eth.d.ts

@@ -0,0 +1,18 @@
+import BigN from 'bignumber.js';
+import BNEther from 'bn.js';
+import { SignedTransaction } from 'web3-core';
+export declare class Transaction {
+    readonly nonce: string;
+    readonly gasPrice: string;
+    readonly gas: string;
+    readonly action: string;
+    readonly value: string;
+    readonly data: string;
+    readonly ethereumChainId: string;
+    readonly isSafe: boolean;
+    constructor(nonce: string, gasPrice: string, gas: string, action: string, value: string, data: string, ethereumChainId: string);
+}
+export declare const anyNumberToBN: (value?: string | number | BNEther) => BigN;
+export declare const rlpItem: (rlp: string, position: number) => `0x${string}`;
+export declare const createTransactionFromRLP: (rlp: string) => Transaction | null;
+export declare const signatureToHex: (sig: SignedTransaction) => string;

package/utils/eth.js

@@ -0,0 +1,64 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import BigN from 'bignumber.js';
+import RLP from 'rlp';
+import { hexStripPrefix, numberToHex, u8aToHex } from '@polkadot/util';
+const hexToNumberString = s => {
+  const temp = parseInt(s, 16);
+  if (isNaN(temp)) {
+    return '0';
+  } else {
+    return temp.toString();
+  }
+};
+export class Transaction {
+  constructor(nonce, gasPrice, gas, action, value, data, ethereumChainId) {
+    this.nonce = hexToNumberString(nonce);
+    this.gasPrice = hexToNumberString(gasPrice);
+    this.gas = hexToNumberString(gas);
+    this.action = action;
+    this.value = hexToNumberString(value);
+    this.data = data || '';
+    this.ethereumChainId = parseInt(ethereumChainId, 16).toString();
+    this.isSafe = true;
+  }
+}
+export const anyNumberToBN = value => {
+  if (typeof value === 'string' || typeof value === 'number') {
+    return new BigN(value);
+  } else if (typeof value === 'undefined') {
+    return new BigN(0);
+  } else {
+    return new BigN(value.toNumber());
+  }
+};
+export const rlpItem = (rlp, position) => {
+  const decodeArr = RLP.decode(rlp);
+  const u8a = decodeArr[position] || [0];
+  return u8aToHex(u8a);
+};
+export const createTransactionFromRLP = rlp => {
+  try {
+    const nonce = rlpItem(rlp, 0);
+    const gasPrice = rlpItem(rlp, 1);
+    const gas = rlpItem(rlp, 2);
+    const action = rlpItem(rlp, 3);
+    const value = rlpItem(rlp, 4);
+    const data = rlpItem(rlp, 5);
+    const ethereumChainId = rlpItem(rlp, 6);
+    return new Transaction(nonce, gasPrice, gas, action, value, data, ethereumChainId);
+  } catch (e) {
+    console.log(e.message);
+    return null;
+  }
+};
+export const signatureToHex = sig => {
+  const v = parseInt(sig.v);
+  const r = hexStripPrefix(sig.r);
+  const s = hexStripPrefix(sig.s);
+  const hexR = r.length % 2 === 1 ? `0${r}` : r;
+  const hexS = s.length % 2 === 1 ? `0${s}` : s;
+  const hexV = hexStripPrefix(numberToHex(v));
+  return hexR + hexS + hexV;
+};

package/utils/index.d.ts

@@ -1 +1,38 @@
+/// <reference types="bn.js" />
+import { CrowdloanParaState, NetworkJson } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountAuthType, AccountJson } from '@subwallet/extension-base/background/types';
+import { BN } from '@polkadot/util';
 export { canDerive } from './canDerive';
+export declare const notDef: (x: any) => boolean;
+export declare const isDef: (x: any) => boolean;
+export declare const nonEmptyArr: (x: any) => boolean;
+export declare const isEmptyArray: (x: any) => boolean;
+export declare function isAccountAll(address?: string): boolean;
+export declare function reformatAddress(address: string, networkPrefix: number, isEthereum?: boolean): string;
+export declare function filterAddressByNetworkKey(addresses: string[], networkKey: string, isEthereum?: boolean): string[];
+export declare function categoryAddresses(addresses: string[]): string[][];
+export declare function categoryNetworks(networks: NetworkJson[]): string[][];
+export declare function convertToEvmAddress(substrateAddress: string): string;
+export declare function isUrl(targetString: string): boolean;
+export declare function inJestTest(): boolean;
+export declare const parseIpfsLink: (ipfsLink: string) => string;
+export declare function hexToStr(buf: string): string;
+export declare function utf16ToString(uInt16Array: Array<number>): string;
+export declare function hexToUTF16(hex: string): Uint8Array;
+export declare const isValidSubstrateAddress: (address: string) => boolean;
+export declare const toUnit: (balance: number, decimals: number) => number;
+export declare function sumBN(inputArr: BN[]): BN;
+export declare const convertFundStatus: (status: string) => CrowdloanParaState | undefined;
+export declare const isAddressesEqual: (addresses: string[], prevAddresses: string[]) => boolean;
+export declare const isValidProvider: (provider: string) => boolean;
+export declare const getCurrentProvider: (data: NetworkJson) => string | null;
+export declare const getNftProvider: (data: NetworkJson) => string;
+export declare function mergeNetworkProviders(customNetwork: NetworkJson, predefinedNetwork: NetworkJson): {
+    currentProviderMethod: string;
+    parsedProviderKey: string;
+    parsedCustomProviders: Record<string, string>;
+};
+export declare const filterAndSortingAccountByAuthType: (accounts: AccountJson[], accountAuthType: AccountAuthType, sorting?: boolean) => AccountJson[];
+export declare function parseRawNumber(value: string): number;
+export declare function parseNumberToDisplay(amount: BN, decimals: number | undefined): string;
+export declare function isSameAddress(address1: string, address2: string): boolean;