@subwallet/extension-base 1.2.32-0 → 1.2.33-0

package/cjs/types/transaction/error.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.YieldValidationStatus = exports.TransferTxErrorType = exports.StakingTxErrorType = exports.BasicTxErrorType = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+let YieldValidationStatus;
+exports.YieldValidationStatus = YieldValidationStatus;
+(function (YieldValidationStatus) {
+  YieldValidationStatus["NOT_ENOUGH_FEE"] = "NOT_ENOUGH_FEE";
+  YieldValidationStatus["NOT_ENOUGH_BALANCE"] = "NOT_ENOUGH_BALANCE";
+  YieldValidationStatus["NOT_ENOUGH_MIN_JOIN_POOL"] = "NOT_ENOUGH_MIN_JOIN_POOL";
+  YieldValidationStatus["OK"] = "OK";
+})(YieldValidationStatus || (exports.YieldValidationStatus = YieldValidationStatus = {}));
+let BasicTxErrorType;
+exports.BasicTxErrorType = BasicTxErrorType;
+(function (BasicTxErrorType) {
+  BasicTxErrorType["NOT_ENOUGH_BALANCE"] = "NOT_ENOUGH_BALANCE";
+  BasicTxErrorType["CHAIN_DISCONNECTED"] = "CHAIN_DISCONNECTED";
+  BasicTxErrorType["INVALID_PARAMS"] = "INVALID_PARAMS";
+  BasicTxErrorType["DUPLICATE_TRANSACTION"] = "DUPLICATE_TRANSACTION";
+  BasicTxErrorType["UNABLE_TO_SIGN"] = "UNABLE_TO_SIGN";
+  BasicTxErrorType["USER_REJECT_REQUEST"] = "USER_REJECT_REQUEST";
+  BasicTxErrorType["UNABLE_TO_SEND"] = "UNABLE_TO_SEND";
+  BasicTxErrorType["SEND_TRANSACTION_FAILED"] = "SEND_TRANSACTION_FAILED";
+  BasicTxErrorType["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  BasicTxErrorType["UNSUPPORTED"] = "UNSUPPORTED";
+  BasicTxErrorType["TIMEOUT"] = "TIMEOUT";
+  BasicTxErrorType["NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "NOT_ENOUGH_EXISTENTIAL_DEPOSIT";
+})(BasicTxErrorType || (exports.BasicTxErrorType = BasicTxErrorType = {}));
+let StakingTxErrorType;
+exports.StakingTxErrorType = StakingTxErrorType;
+(function (StakingTxErrorType) {
+  StakingTxErrorType["NOT_ENOUGH_MIN_STAKE"] = "NOT_ENOUGH_MIN_STAKE";
+  StakingTxErrorType["EXCEED_MAX_NOMINATIONS"] = "EXCEED_MAX_NOMINATIONS";
+  StakingTxErrorType["EXIST_UNSTAKING_REQUEST"] = "EXIST_UNSTAKING_REQUEST";
+  StakingTxErrorType["INVALID_ACTIVE_STAKE"] = "INVALID_ACTIVE_STAKE";
+  StakingTxErrorType["EXCEED_MAX_UNSTAKING"] = "EXCEED_MAX_UNSTAKING";
+  StakingTxErrorType["INACTIVE_NOMINATION_POOL"] = "INACTIVE_NOMINATION_POOL";
+  StakingTxErrorType["CAN_NOT_GET_METADATA"] = "CAN_NOT_GET_METADATA";
+  StakingTxErrorType["NOT_ENOUGH_MIN_UNSTAKE"] = "NOT_ENOUGH_MIN_UNSTAKE";
+})(StakingTxErrorType || (exports.StakingTxErrorType = StakingTxErrorType = {}));
+let TransferTxErrorType;
+exports.TransferTxErrorType = TransferTxErrorType;
+(function (TransferTxErrorType) {
+  TransferTxErrorType["NOT_ENOUGH_VALUE"] = "NOT_ENOUGH_VALUE";
+  TransferTxErrorType["NOT_ENOUGH_FEE"] = "NOT_ENOUGH_FEE";
+  TransferTxErrorType["INVALID_TOKEN"] = "INVALID_TOKEN";
+  TransferTxErrorType["TRANSFER_ERROR"] = "TRANSFER_ERROR";
+  TransferTxErrorType["RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT";
+})(TransferTxErrorType || (exports.TransferTxErrorType = TransferTxErrorType = {}));

package/cjs/types/transaction/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _data = require("./data");
+Object.keys(_data).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _data[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _data[key];
+    }
+  });
+});
+var _error = require("./error");
+Object.keys(_error).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _error[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _error[key];
+    }
+  });
+});
+var _request = require("./request");
+Object.keys(_request).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _request[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _request[key];
+    }
+  });
+});
+var _warning = require("./warning");
+Object.keys(_warning).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _warning[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _warning[key];
+    }
+  });
+});

package/cjs/types/transaction/request.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/types/transaction/warning.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BasicTxWarningCode = void 0;
+// Copyright 2019-2022 @subwallet/extension-koni-ui authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+let BasicTxWarningCode;
+exports.BasicTxWarningCode = BasicTxWarningCode;
+(function (BasicTxWarningCode) {
+  BasicTxWarningCode["NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "notEnoughExistentialDeposit";
+  BasicTxWarningCode["IS_BOUNCEABLE_ADDRESS"] = "isBounceableAddress";
+})(BasicTxWarningCode || (exports.BasicTxWarningCode = BasicTxWarningCode = {}));

package/cjs/types/yield/actions/join/validate.js

@@ -1,16 +1 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.YieldValidationStatus = void 0;
-// Copyright 2019-2022 @subwallet/extension-base
-// SPDX-License-Identifier: Apache-2.0
-let YieldValidationStatus;
-exports.YieldValidationStatus = YieldValidationStatus;
-(function (YieldValidationStatus) {
-  YieldValidationStatus["NOT_ENOUGH_FEE"] = "NOT_ENOUGH_FEE";
-  YieldValidationStatus["NOT_ENOUGH_BALANCE"] = "NOT_ENOUGH_BALANCE";
-  YieldValidationStatus["NOT_ENOUGH_MIN_JOIN_POOL"] = "NOT_ENOUGH_MIN_JOIN_POOL";
-  YieldValidationStatus["OK"] = "OK";
-})(YieldValidationStatus || (exports.YieldValidationStatus = YieldValidationStatus = {}));
+"use strict";

package/cjs/utils/account/analyze.js

@@ -0,0 +1,166 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._analyzeAddress = void 0;
+var _domain = require("@subwallet/extension-base/koni/api/dotsama/domain");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _types = require("@subwallet/extension-base/types");
+var _utilCrypto = require("@polkadot/util-crypto");
+var _common = require("./common");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// TODO: Re-confirm to compare without
+const isStrValidWithAddress = (str, account, chainInfo) => {
+  if (account.chainType === _types.AccountChainType.SUBSTRATE) {
+    const reformated = (0, _common.reformatAddress)(account.address, (0, _utils._getChainSubstrateAddressPrefix)(chainInfo));
+    if (account.address.toLowerCase() === str || reformated.toLowerCase() === str) {
+      return 'extracted';
+    } else if (account.address.toLowerCase().includes(str) || reformated.toLowerCase().includes(str)) {
+      return 'valid';
+    }
+  } else if (account.chainType === _types.AccountChainType.TON) {
+    const isTestnet = chainInfo.isTestnet;
+    const reformated = (0, _common.reformatAddress)(account.address, isTestnet ? 0 : 1);
+    if (account.address.toLowerCase() === str || reformated.toLowerCase() === str) {
+      return 'extracted';
+    } else if (account.address.toLowerCase().includes(str) || reformated.toLowerCase().includes(str)) {
+      return 'valid';
+    }
+  } else {
+    if (account.address.toLowerCase() === str) {
+      return 'extracted';
+    } else if (account.address.toLowerCase().includes(str)) {
+      return 'valid';
+    }
+  }
+  return 'invalid';
+};
+const isNameValid = (str, name) => {
+  if (name === str) {
+    return 'extracted';
+  } else if (name.includes(str)) {
+    return 'valid';
+  } else {
+    return 'invalid';
+  }
+};
+const _analyzeAddress = async (data, accountProxies, contacts, chainInfo, substrateApi) => {
+  if (!data) {
+    return {
+      options: []
+    };
+  }
+  const chain = chainInfo.slug;
+  const _data = data.trim().toLowerCase();
+  const options = [];
+  const currentChainType = (0, _utils._chainInfoToChainType)(chainInfo);
+  let current;
+
+  // Filter account proxies
+  for (const accountProxy of accountProxies) {
+    const _name = accountProxy.name.trim().toLowerCase();
+    const nameCondition = isNameValid(_data, _name);
+    const filterAccounts = accountProxy.accounts.filter(account => account.chainType === currentChainType);
+    for (const account of filterAccounts) {
+      const addressCondition = isStrValidWithAddress(_data, account, chainInfo);
+      const condition = nameCondition !== 'invalid' ? nameCondition : addressCondition;
+      const rs = {
+        address: account.address,
+        proxyId: accountProxy.id,
+        analyzedGroup: _types.AnalyzedGroup.WALLET,
+        displayName: accountProxy.name,
+        formatedAddress: (0, _common._reformatAddressWithChain)(account.address, chainInfo)
+      };
+      if (condition !== 'invalid') {
+        if (account.specialChain) {
+          if (account.specialChain === chain) {
+            options.push(rs);
+            if (condition === 'extracted') {
+              current = rs;
+            }
+          }
+        } else {
+          options.push(rs);
+          if (condition === 'extracted') {
+            current = rs;
+          }
+        }
+      }
+    }
+  }
+  const filterContacts = contacts.filter(contact => contact.chainType === currentChainType);
+
+  // Filter address book addresses
+  for (const contact of filterContacts) {
+    const name = (contact === null || contact === void 0 ? void 0 : contact.name) || '';
+    const _name = name.trim().toLowerCase();
+    const nameCondition = isNameValid(_data, _name);
+    const addressCondition = isStrValidWithAddress(_data, contact, chainInfo);
+    const condition = nameCondition !== 'invalid' ? nameCondition : addressCondition;
+    const rs = {
+      address: contact.address,
+      analyzedGroup: contact.isRecent ? _types.AnalyzedGroup.RECENT : _types.AnalyzedGroup.CONTACT,
+      displayName: name,
+      formatedAddress: (0, _common._reformatAddressWithChain)(contact.address, chainInfo)
+    };
+    if (condition !== 'invalid') {
+      if (contact.isRecent) {
+        var _contact$recentChainS;
+        if ((_contact$recentChainS = contact.recentChainSlugs) !== null && _contact$recentChainS !== void 0 && _contact$recentChainS.includes(chain)) {
+          options.push(rs);
+          if (condition === 'extracted') {
+            current = rs;
+          }
+        }
+      } else {
+        options.push(rs);
+        if (condition === 'extracted') {
+          current = rs;
+        }
+      }
+    }
+  }
+  if (substrateApi) {
+    await (substrateApi === null || substrateApi === void 0 ? void 0 : substrateApi.isReady);
+    const _raw = data.trim();
+    if (chain === 'aleph' || chain === 'alephTest') {
+      if ((0, _utilCrypto.isAddress)(_raw)) {
+        const domain = await (0, _domain.resolveAzeroAddressToDomain)(_raw, chain, substrateApi.api);
+        if (domain) {
+          const rs = {
+            address: _raw,
+            analyzedGroup: _types.AnalyzedGroup.DOMAIN,
+            displayName: domain,
+            formatedAddress: (0, _common._reformatAddressWithChain)(_raw, chainInfo)
+          };
+          options.push(rs);
+          if (!current) {
+            current = rs;
+          }
+        }
+      } else {
+        const address = await (0, _domain.resolveAzeroDomainToAddress)(_raw, chain, substrateApi.api);
+        if (address) {
+          const rs = {
+            address: address,
+            analyzedGroup: _types.AnalyzedGroup.DOMAIN,
+            displayName: _raw,
+            formatedAddress: (0, _common._reformatAddressWithChain)(address, chainInfo)
+          };
+          options.push(rs);
+          if (!current) {
+            current = rs;
+          }
+        }
+      }
+    }
+  }
+  return {
+    options,
+    current
+  };
+};
+exports._analyzeAddress = _analyzeAddress;

package/cjs/utils/account/common.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._reformatAddressWithChain = void 0;
+exports.categoryAddresses = categoryAddresses;
+exports.getAccountChainTypeForAddress = void 0;
+exports.isAccountAll = isAccountAll;
+exports.modifyAccountName = void 0;
+exports.quickFormatAddressToCompare = quickFormatAddressToCompare;
+exports.reformatAddress = reformatAddress;
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _keyring = require("@subwallet/keyring");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function isAccountAll(address) {
+  return address === _constants.ALL_ACCOUNT_KEY;
+}
+function reformatAddress(address) {
+  let networkPrefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 42;
+  let isEthereum = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  try {
+    if (!address || address === '') {
+      return '';
+    }
+    if ((0, _utilCrypto.isEthereumAddress)(address)) {
+      return address;
+    }
+    if (isAccountAll(address)) {
+      return address;
+    }
+    const publicKey = (0, _keyring.decodeAddress)(address);
+    if (isEthereum) {
+      return (0, _utilCrypto.ethereumEncode)(publicKey);
+    }
+    const type = (0, _keyring.getKeypairTypeByAddress)(address);
+    if (networkPrefix < 0) {
+      return address;
+    }
+    return (0, _keyring.encodeAddress)(publicKey, networkPrefix, type);
+  } catch (e) {
+    console.warn('Get error while reformat address', address, e);
+    return address;
+  }
+}
+const _reformatAddressWithChain = (address, chainInfo) => {
+  const chainType = (0, _utils._chainInfoToChainType)(chainInfo);
+  if (chainType === _types.AccountChainType.SUBSTRATE) {
+    return reformatAddress(address, (0, _utils._getChainSubstrateAddressPrefix)(chainInfo));
+  } else if (chainType === _types.AccountChainType.TON) {
+    const isTestnet = chainInfo.isTestnet;
+    return reformatAddress(address, isTestnet ? 0 : 1);
+  } else {
+    return address;
+  }
+};
+exports._reformatAddressWithChain = _reformatAddressWithChain;
+const getAccountChainTypeForAddress = address => {
+  const type = (0, _keyring.getKeypairTypeByAddress)(address);
+  return (0, _utils2.getAccountChainType)(type);
+};
+exports.getAccountChainTypeForAddress = getAccountChainTypeForAddress;
+function categoryAddresses(addresses) {
+  const substrate = [];
+  const evm = [];
+  const ton = [];
+  const bitcoin = [];
+  addresses.forEach(address => {
+    if ((0, _utilCrypto.isEthereumAddress)(address)) {
+      evm.push(address);
+    } else if ((0, _keyring.isTonAddress)(address)) {
+      ton.push(address);
+    } else if ((0, _keyring.isBitcoinAddress)(address)) {
+      bitcoin.push(address);
+    } else {
+      substrate.push(address);
+    }
+  });
+  return {
+    bitcoin,
+    evm,
+    substrate,
+    ton
+  };
+}
+function quickFormatAddressToCompare(address) {
+  if (!(0, _keyring.isAddress)(address)) {
+    return address;
+  }
+  return reformatAddress(address, 42).toLowerCase();
+}
+
+/** @deprecated */
+const modifyAccountName = (type, name, modify) => {
+  if (!modify) {
+    return name;
+  }
+  let network = '';
+  switch (type) {
+    case 'sr25519':
+    case 'ed25519':
+    case 'ecdsa':
+      network = 'Substrate';
+      break;
+    case 'ethereum':
+      network = 'EVM';
+      break;
+    case 'ton':
+    case 'ton-native':
+      network = 'Ton';
+      break;
+  }
+  return network ? [name, network].join(' - ') : name;
+};
+exports.modifyAccountName = modifyAccountName;

package/cjs/utils/account/derive/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _info = require("./info");
+Object.keys(_info).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _info[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _info[key];
+    }
+  });
+});
+var _validate = require("./validate");
+Object.keys(_validate).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validate[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validate[key];
+    }
+  });
+});

package/cjs/utils/account/derive/info/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _solo = require("./solo");
+Object.keys(_solo).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _solo[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _solo[key];
+    }
+  });
+});
+var _unified = require("./unified");
+Object.keys(_unified).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _unified[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _unified[key];
+    }
+  });
+});