@subwallet/extension-base 0.8.4-0 → 1.0.1

package/cjs/utils/eth/parseTransactionData.js

@@ -0,0 +1,284 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InputDataDecoder = void 0;
+var _buffer = require("buffer");
+var _ethers = require("ethers");
+var _isBuffer = _interopRequireDefault(require("is-buffer"));
+var _web3Utils = require("web3-utils");
+// Copyright 2019-2022 @subwallet/extension-koni-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// @ts-ignore
+
+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 (0, _web3Utils.keccak256)((0, _web3Utils._jsonInterfaceMethodToString)(abi)).slice(2, 10);
+};
+const getMethodName = abi => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-call
+  return (0, _web3Utils._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
+function deepStripTupleAddresses(input, tupleTypes) {
+  return 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('');
+};
+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 ((0, _isBuffer.default)(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.ethers.utils.defaultAbiCoder.decode(types, data);
+      const inputs = deepRemoveUnwantedArrayProperties(_inputs);
+      return {
+        methodName,
+        method,
+        types,
+        inputs,
+        names
+      };
+    }
+    throw new Error('not found');
+  }
+  decodeData(data) {
+    if ((0, _isBuffer.default)(data)) {
+      data = data.toString('utf8');
+    }
+    if (typeof data !== 'string') {
+      data = '';
+    }
+    data = data.trim();
+    const dataBuf = _buffer.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.ethers.utils.defaultAbiCoder.decode(types, inputsBuf);
+          } catch (err) {
+            try {
+              const ifc = new _ethers.ethers.utils.Interface([]);
+              inputs = ifc.decodeFunctionData(_ethers.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.ethers.utils.Interface([]);
+          const _result = ifc.decodeFunctionData(_ethers.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;
+  }
+}
+exports.InputDataDecoder = InputDataDecoder;

package/cjs/utils/eth.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.signatureToHex = exports.rlpItem = exports.createTransactionFromRLP = exports.anyNumberToBN = exports.Transaction = void 0;
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _rlp = _interopRequireDefault(require("rlp"));
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const hexToNumberString = s => {
+  const temp = parseInt(s, 16);
+  if (isNaN(temp)) {
+    return '0';
+  } else {
+    return temp.toString();
+  }
+};
+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;
+  }
+}
+exports.Transaction = Transaction;
+const anyNumberToBN = value => {
+  if (typeof value === 'string' || typeof value === 'number') {
+    return new _bignumber.default(value);
+  } else if (typeof value === 'undefined') {
+    return new _bignumber.default(0);
+  } else {
+    return new _bignumber.default(value.toNumber());
+  }
+};
+exports.anyNumberToBN = anyNumberToBN;
+const rlpItem = (rlp, position) => {
+  const decodeArr = _rlp.default.decode(rlp);
+  const u8a = decodeArr[position] || [0];
+  return (0, _util.u8aToHex)(u8a);
+};
+exports.rlpItem = rlpItem;
+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;
+  }
+};
+exports.createTransactionFromRLP = createTransactionFromRLP;
+const signatureToHex = sig => {
+  const v = parseInt(sig.v);
+  const r = (0, _util.hexStripPrefix)(sig.r);
+  const s = (0, _util.hexStripPrefix)(sig.s);
+  const hexR = r.length % 2 === 1 ? `0${r}` : r;
+  const hexS = s.length % 2 === 1 ? `0${s}` : s;
+  const hexV = (0, _util.hexStripPrefix)((0, _util.numberToHex)(v));
+  return hexR + hexS + hexV;
+};
+exports.signatureToHex = signatureToHex;

package/cjs/utils/index.js

@@ -1,5 +1,6 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -9,4 +10,315 @@ Object.defineProperty(exports, "canDerive", {
     return _canDerive.canDerive;
   }
 });
-var _canDerive = require("./canDerive");
+exports.categoryAddresses = categoryAddresses;
+exports.categoryNetworks = categoryNetworks;
+exports.convertFundStatus = void 0;
+exports.convertToEvmAddress = convertToEvmAddress;
+exports.filterAddressByNetworkKey = filterAddressByNetworkKey;
+exports.getNftProvider = exports.getCurrentProvider = exports.filterAndSortingAccountByAuthType = void 0;
+exports.hexToStr = hexToStr;
+exports.hexToUTF16 = hexToUTF16;
+exports.inJestTest = inJestTest;
+exports.isAccountAll = isAccountAll;
+exports.isEmptyArray = exports.isDef = exports.isAddressesEqual = void 0;
+exports.isSameAddress = isSameAddress;
+exports.isUrl = isUrl;
+exports.isValidSubstrateAddress = exports.isValidProvider = void 0;
+exports.mergeNetworkProviders = mergeNetworkProviders;
+exports.parseIpfsLink = exports.notDef = exports.nonEmptyArr = void 0;
+exports.parseNumberToDisplay = parseNumberToDisplay;
+exports.parseRawNumber = parseRawNumber;
+exports.reformatAddress = reformatAddress;
+exports.sumBN = sumBN;
+exports.toUnit = void 0;
+exports.utf16ToString = utf16ToString;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+var _canDerive = require("./canDerive");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const notDef = x => x === null || typeof x === 'undefined';
+exports.notDef = notDef;
+const isDef = x => !notDef(x);
+exports.isDef = isDef;
+const nonEmptyArr = x => Array.isArray(x) && x.length > 0;
+exports.nonEmptyArr = nonEmptyArr;
+const isEmptyArray = x => !Array.isArray(x) || Array.isArray(x) && x.length === 0;
+exports.isEmptyArray = isEmptyArray;
+function isAccountAll(address) {
+  return address === _constants.ALL_ACCOUNT_KEY;
+}
+function reformatAddress(address, networkPrefix) {
+  let isEthereum = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if ((0, _utilCrypto.isEthereumAddress)(address)) {
+    return address;
+  }
+  if (isAccountAll(address)) {
+    return address;
+  }
+  const publicKey = (0, _utilCrypto.decodeAddress)(address);
+  if (isEthereum) {
+    return (0, _utilCrypto.ethereumEncode)(publicKey);
+  }
+  if (networkPrefix < 0) {
+    return address;
+  }
+  return (0, _utilCrypto.encodeAddress)(publicKey, networkPrefix);
+}
+function filterAddressByNetworkKey(addresses, networkKey, isEthereum) {
+  if (isEthereum) {
+    return addresses.filter(address => {
+      return (0, _utilCrypto.isEthereumAddress)(address);
+    });
+  } else {
+    return addresses.filter(address => {
+      return !(0, _utilCrypto.isEthereumAddress)(address);
+    });
+  }
+}
+function categoryAddresses(addresses) {
+  const substrateAddresses = [];
+  const evmAddresses = [];
+  addresses.forEach(address => {
+    if ((0, _utilCrypto.isEthereumAddress)(address)) {
+      evmAddresses.push(address);
+    } else {
+      substrateAddresses.push(address);
+    }
+  });
+  return [substrateAddresses, evmAddresses];
+}
+function categoryNetworks(networks) {
+  const substrateAddresses = [];
+  const evmAddresses = [];
+  return [substrateAddresses, evmAddresses];
+}
+function convertToEvmAddress(substrateAddress) {
+  const addressBytes = (0, _utilCrypto.decodeAddress)(substrateAddress);
+  return (0, _utilCrypto.ethereumEncode)('0x' + Buffer.from(addressBytes.subarray(0, 20)).toString('hex'));
+}
+function isUrl(targetString) {
+  let url;
+  try {
+    url = new URL(targetString);
+  } catch (_) {
+    return false;
+  }
+  return url.protocol === 'http:' || url.protocol === 'https:' || url.protocol === 'wss:';
+}
+function inJestTest() {
+  return process.env.JEST_WORKER_ID !== undefined;
+}
+const parseIpfsLink = ipfsLink => {
+  if (!ipfsLink.includes('ipfs://ipfs/')) {
+    return ipfsLink;
+  }
+  return ipfsLink.split('ipfs://ipfs/')[1];
+};
+exports.parseIpfsLink = parseIpfsLink;
+function hexToStr(buf) {
+  let str = '';
+  let hexStart = buf.indexOf('0x');
+  if (hexStart < 0) {
+    hexStart = 0;
+  } else {
+    hexStart = 2;
+  }
+  for (let i = hexStart, strLen = buf.length; i < strLen; i += 2) {
+    const ch = buf[i] + buf[i + 1];
+    const num = parseInt(ch, 16);
+
+    // eslint-disable-next-line eqeqeq
+    if (num != 0) {
+      str += String.fromCharCode(num);
+    } else {
+      break;
+    }
+  }
+  return str;
+}
+
+// eslint-disable-next-line camelcase
+function utf16ToString(uInt16Array) {
+  let str = '';
+
+  // eslint-disable-next-line camelcase
+  for (let i = 0; i < uInt16Array.length; i++) {
+    str += String.fromCharCode(uInt16Array[i]);
+  }
+  return str;
+}
+function hexToUTF16(hex) {
+  const buf = [];
+  let hexStart = hex.indexOf('0x');
+  if (hexStart < 0) {
+    hexStart = 0;
+  } else {
+    hexStart = 2;
+  }
+  for (let i = hexStart, strLen = hex.length; i < strLen; i += 2) {
+    const ch = hex[i] + hex[i + 1];
+    const num = parseInt(ch, 16);
+    buf.push(num);
+  }
+  return new Uint8Array(buf);
+}
+const isValidSubstrateAddress = address => {
+  try {
+    (0, _utilCrypto.encodeAddress)((0, _util.isHex)(address) ? (0, _util.hexToU8a)(address) : (0, _utilCrypto.decodeAddress)(address));
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+exports.isValidSubstrateAddress = isValidSubstrateAddress;
+const toUnit = (balance, decimals) => {
+  if (balance === 0) {
+    return 0;
+  }
+  return balance / 10 ** decimals;
+};
+exports.toUnit = toUnit;
+function sumBN(inputArr) {
+  let rs = new _util.BN(0);
+  inputArr.forEach(input => {
+    rs = rs.add(input);
+  });
+  return rs;
+}
+const convertFundStatus = status => {
+  if (status === 'Won' || status === 'Retiring') {
+    return _KoniTypes.CrowdloanParaState.COMPLETED;
+  } else if (status === 'Started') {
+    return _KoniTypes.CrowdloanParaState.ONGOING;
+  } else if (status === 'Dissolved') {
+    return _KoniTypes.CrowdloanParaState.FAILED;
+  } else {
+    return undefined;
+  }
+};
+exports.convertFundStatus = convertFundStatus;
+const isAddressesEqual = (addresses, prevAddresses) => {
+  if (addresses.length !== prevAddresses.length) {
+    return false;
+  }
+  for (const address of addresses) {
+    if (!prevAddresses.includes(address)) {
+      return false;
+    }
+  }
+  return true;
+};
+exports.isAddressesEqual = isAddressesEqual;
+const isValidProvider = provider => {
+  if (isUrl(provider)) {
+    return true;
+  } else if (provider.startsWith('wss://') || provider.startsWith('light://')) {
+    return true;
+  }
+  return false;
+};
+exports.isValidProvider = isValidProvider;
+const getCurrentProvider = data => {
+  if (!(data !== null && data !== void 0 && data.currentProvider)) {
+    return null;
+  }
+  if (data.currentProvider.startsWith('custom') && data.customProviders) {
+    return data.customProviders[data.currentProvider];
+  } else {
+    return data.providers[data.currentProvider];
+  }
+};
+exports.getCurrentProvider = getCurrentProvider;
+const getNftProvider = data => {
+  if (data.nftProvider) {
+    return data.providers[data.nftProvider];
+  }
+  return '';
+};
+exports.getNftProvider = getNftProvider;
+function mergeNetworkProviders(customNetwork, predefinedNetwork) {
+  // merge providers for 2 networks with the same genesisHash
+  if (customNetwork.customProviders) {
+    const parsedCustomProviders = {};
+    const currentProvider = customNetwork.customProviders[customNetwork.currentProvider || ''] || '';
+    const currentProviderMethod = currentProvider.startsWith('http') ? 'http' : 'ws';
+    let parsedProviderKey = '';
+    for (const customProvider of Object.values(customNetwork.customProviders)) {
+      let exist = false;
+      for (const [key, provider] of Object.entries(predefinedNetwork.providers)) {
+        if (currentProvider === provider) {
+          // point currentProvider to predefined
+          parsedProviderKey = key;
+        }
+        if (provider === customProvider) {
+          exist = true;
+          break;
+        }
+      }
+      if (!exist) {
+        const index = Object.values(parsedCustomProviders).length;
+        parsedCustomProviders[`custom_${index}`] = customProvider;
+      }
+    }
+    for (const [key, parsedProvider] of Object.entries(parsedCustomProviders)) {
+      if (currentProvider === parsedProvider) {
+        parsedProviderKey = key;
+      }
+    }
+    return {
+      currentProviderMethod,
+      parsedProviderKey,
+      parsedCustomProviders
+    };
+  } else {
+    return {
+      currentProviderMethod: '',
+      parsedProviderKey: '',
+      parsedCustomProviders: {}
+    };
+  }
+}
+const filterAndSortingAccountByAuthType = function (accounts, accountAuthType) {
+  let sorting = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  let rs = [...accounts];
+  rs = rs.filter(acc => acc.address !== 'ALL');
+  if (accountAuthType === 'substrate') {
+    rs = rs.filter(acc => acc.type !== 'ethereum');
+  } else if (accountAuthType === 'evm') {
+    rs = rs.filter(acc => acc.type === 'ethereum');
+  } else {
+    if (sorting) {
+      rs.sort((acc, acc2) => {
+        if (acc.type === 'ethereum' && acc2.type === 'ethereum' || acc.type !== 'ethereum' && acc2.type !== 'ethereum') {
+          return 0;
+        } else {
+          return acc.type === 'ethereum' ? 1 : -1;
+        }
+      });
+    }
+  }
+  return rs;
+};
+exports.filterAndSortingAccountByAuthType = filterAndSortingAccountByAuthType;
+function parseRawNumber(value) {
+  return parseFloat(value.replaceAll(',', ''));
+}
+function parseNumberToDisplay(amount, decimals) {
+  if (!decimals) {
+    return '0';
+  }
+  const parsedAmount = parseRawNumber(amount.toString());
+  const bigN = new _bignumber.default(parsedAmount / 10 ** decimals);
+  const roundedString = bigN.toFixed(9);
+  const formattedString = parseFloat(roundedString); // remove excess zeros at the end
+
+  return formattedString.toString();
+}
+function isSameAddress(address1, address2) {
+  return reformatAddress(address1, 0) === reformatAddress(address2, 0); // TODO: maybe there's a better way
+}