@subwallet/extension-base 0.8.4-0 → 1.0.2-1

package/cjs/utils/eth/parseTransaction/index.js

@@ -0,0 +1,229 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseEvmRlp = exports.parseContractInput = exports.isContractAddress = void 0;
+var _helper = require("@subwallet/extension-base/services/chain-service/helper");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _eth = require("@subwallet/extension-base/utils/eth");
+var _base = require("@subwallet/extension-base/utils/eth/parseTransaction/base");
+var _axios = _interopRequireDefault(require("axios"));
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const ABIs = [_helper._ERC20_ABI, _helper._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)
+    };
+  }
+};
+const isContractAddress = async (address, evmApi) => {
+  if (!evmApi) {
+    return false;
+  } else {
+    const code = await evmApi.api.eth.getCode(address);
+    return code !== '0x';
+  }
+};
+exports.isContractAddress = isContractAddress;
+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 ((0, _utils._getEvmAbiExplorer)(network)) {
+      const res = await _axios.default.get((0, _utils._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 _base.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
+  };
+};
+exports.parseContractInput = parseContractInput;
+const getChainInfoByChainId = (networkMap, chainId) => {
+  if (!chainId) {
+    for (const n in networkMap) {
+      if (!Object.prototype.hasOwnProperty.call(networkMap, n)) {
+        continue;
+      }
+      const networkInfo = networkMap[n];
+      if ((0, _utils._isChainEvmCompatible)(networkInfo)) {
+        return networkInfo;
+      }
+    }
+    return null;
+  }
+  for (const n in networkMap) {
+    if (!Object.prototype.hasOwnProperty.call(networkMap, n)) {
+      continue;
+    }
+    const networkInfo = networkMap[n];
+    if ((0, _utils._getEvmChainId)(networkInfo) === chainId) {
+      return networkInfo;
+    }
+  }
+  return null;
+};
+const parseEvmRlp = async (data, networkMap, evmApiMap) => {
+  const tx = (0, _eth.createTransactionFromRLP)(data);
+  if (!tx) {
+    throw new Error(`Cannot create tx from ${data}`);
+  }
+  const result = {
+    input: tx.data,
+    data: tx.data,
+    gasPrice: new _bignumber.default(tx.gasPrice).toNumber(),
+    gas: new _bignumber.default(tx.gas).toNumber(),
+    to: tx.action,
+    value: new _bignumber.default(tx.value).toNumber(),
+    nonce: new _bignumber.default(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 ((0, _utils._getEvmAbiExplorer)(network) !== '') {
+        const res = await _axios.default.get((0, _utils._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 _base.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;
+};
+exports.parseEvmRlp = parseEvmRlp;

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,326 @@ 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.getCurrentProvider = exports.filterAndSortingAccountByAuthType = void 0;
+exports.getDomainFromUrl = getDomainFromUrl;
+exports.getNftProvider = 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;
+  try {
+    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);
+  } catch (e) {
+    console.warn('Get error while reformat address', address, e);
+    return address;
+  }
+}
+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
+}
+
+function getDomainFromUrl(url) {
+  return url.replace(/^(https?:\/\/)?(www\.)?/, '').split('/')[0];
+}

package/cjs/utils/keyring.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractPrivateKey = extractPrivateKey;
+exports.unlockAccount = exports.lockAccount = void 0;
+var _uiKeyring = require("@subwallet/ui-keyring");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// import _decode from '@polkadot/keyring/pair/decode';
+
+function extract(address) {
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+  const rs = this.getPair(address);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  console.log(rs.publicKey);
+}
+function extractPrivateKey(keyring, address, password) {
+  extract.call(keyring, address);
+}
+const unlockAccount = signAddress => {
+  let publicKey;
+  try {
+    publicKey = _uiKeyring.keyring.decodeAddress(signAddress);
+  } catch (error) {
+    console.error(error);
+    return 'Unable to decode address';
+  }
+  const pair = _uiKeyring.keyring.getPair(publicKey);
+  if (!pair) {
+    return 'Unable to find pair';
+  }
+  if (pair.isLocked) {
+    try {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    } catch (e) {
+      return e.message;
+    }
+  }
+  return null;
+};
+exports.unlockAccount = unlockAccount;
+const lockAccount = address => {
+  try {
+    const pair = _uiKeyring.keyring.getPair(address);
+    if (pair) {
+      pair.lock();
+    }
+  } catch (error) {
+    console.error('Unable to lock account', error);
+  }
+};
+exports.lockAccount = lockAccount;

package/cjs/utils/request.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isInternalRequest = isInternalRequest;
+var _constants = require("@subwallet/extension-base/services/request-service/constants");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function isInternalRequest(url) {
+  return url === _constants.EXTENSION_REQUEST_URL;
+}