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

package/cjs/utils/index.js

@@ -8,11 +8,7 @@ var _exportNames = {
   isDef: true,
   nonEmptyArr: true,
   isEmptyArray: true,
-  isAccountAll: true,
-  reformatAddress: true,
   filterAddressByNetworkKey: true,
-  categoryAddresses: true,
-  categoryNetworks: true,
   convertToEvmAddress: true,
   isUrl: true,
   inJestTest: true,
@@ -32,6 +28,8 @@ var _exportNames = {
   filterAndSortingAccountByAuthType: true,
   parseRawNumber: true,
   isSameAddress: true,
+  isSameAddressType: true,
+  isAddressAndChainCompatible: true,
   getDomainFromUrl: true,
   waitTimeout: true,
   stripUrl: true,
@@ -47,8 +45,6 @@ Object.defineProperty(exports, "canDerive", {
     return _canDerive.canDerive;
   }
 });
-exports.categoryAddresses = categoryAddresses;
-exports.categoryNetworks = categoryNetworks;
 exports.convertFundStatus = void 0;
 exports.convertToEvmAddress = convertToEvmAddress;
 exports.filterAddressByNetworkKey = filterAddressByNetworkKey;
@@ -58,15 +54,15 @@ exports.getNftProvider = void 0;
 exports.hexToStr = hexToStr;
 exports.hexToUTF16 = hexToUTF16;
 exports.inJestTest = inJestTest;
-exports.isAccountAll = isAccountAll;
+exports.isAddressAndChainCompatible = isAddressAndChainCompatible;
 exports.isEmptyArray = exports.isDef = exports.isAddressesEqual = void 0;
 exports.isSameAddress = isSameAddress;
+exports.isSameAddressType = isSameAddressType;
 exports.isUrl = isUrl;
 exports.isValidSubstrateAddress = exports.isValidProvider = void 0;
 exports.mergeNetworkProviders = mergeNetworkProviders;
 exports.parseIpfsLink = exports.notDef = exports.nonEmptyArr = void 0;
 exports.parseRawNumber = parseRawNumber;
-exports.reformatAddress = reformatAddress;
 exports.stripUrl = void 0;
 exports.sumBN = sumBN;
 exports.toUnit = exports.swParseIPFSUrl = void 0;
@@ -74,8 +70,10 @@ exports.utf16ToString = utf16ToString;
 exports.wait = wait;
 exports.waitTimeout = waitTimeout;
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
-var _constants = require("@subwallet/extension-base/constants");
 var _config = require("@subwallet/extension-base/koni/api/nft/config");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _account = require("@subwallet/extension-base/utils/account");
+var _keyring = require("@subwallet/keyring");
 var _i18next = require("i18next");
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
@@ -104,15 +102,15 @@ Object.keys(_fetch).forEach(function (key) {
     }
   });
 });
-var _account = require("./account");
-Object.keys(_account).forEach(function (key) {
+var _account2 = require("./account");
+Object.keys(_account2).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _account[key]) return;
+  if (key in exports && exports[key] === _account2[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _account[key];
+      return _account2[key];
     }
   });
 });
@@ -140,6 +138,18 @@ Object.keys(_asset).forEach(function (key) {
     }
   });
 });
+var _auth = require("./auth");
+Object.keys(_auth).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _auth[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _auth[key];
+    }
+  });
+});
 var _environment = require("./environment");
 Object.keys(_environment).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -306,36 +316,11 @@ 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;
+
+/**
+ * @deprecated
+ * */
 exports.isEmptyArray = isEmptyArray;
-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, _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 => {
@@ -347,25 +332,12 @@ function filterAddressByNetworkKey(addresses, networkKey, isEthereum) {
     });
   }
 }
-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];
-}
+
+/**
+ * @deprecated
+ * */
 function convertToEvmAddress(substrateAddress) {
-  const addressBytes = (0, _utilCrypto.decodeAddress)(substrateAddress);
+  const addressBytes = (0, _keyring.decodeAddress)(substrateAddress);
   return (0, _utilCrypto.ethereumEncode)('0x' + Buffer.from(addressBytes.subarray(0, 20)).toString('hex'));
 }
 function isUrl(targetString) {
@@ -436,7 +408,7 @@ function hexToUTF16(hex) {
 }
 const isValidSubstrateAddress = address => {
   try {
-    (0, _utilCrypto.encodeAddress)((0, _util.isHex)(address) ? (0, _util.hexToU8a)(address) : (0, _utilCrypto.decodeAddress)(address));
+    (0, _keyring.encodeAddress)((0, _util.isHex)(address) ? (0, _util.hexToU8a)(address) : (0, _keyring.decodeAddress)(address));
     return true;
   } catch (error) {
     return false;
@@ -579,9 +551,23 @@ function isSameAddress(address1, address2) {
   if ((0, _utilCrypto.isEthereumAddress)(address1)) {
     return address1.toLowerCase() === address2.toLowerCase();
   }
-  return reformatAddress(address1, 0) === reformatAddress(address2, 0); // TODO: maybe there's a better way
+  return (0, _account.reformatAddress)(address1, 0) === (0, _account.reformatAddress)(address2, 0); // TODO: maybe there's a better way
 }
 
+function isSameAddressType(address1, address2) {
+  const isSameEvmAddress = (0, _utilCrypto.isEthereumAddress)(address1) && (0, _utilCrypto.isEthereumAddress)(address2);
+  const isSameTonAddress = (0, _keyring.isTonAddress)(address1) && (0, _keyring.isTonAddress)(address2);
+  const isSameSubstrateAddress = !(0, _utilCrypto.isEthereumAddress)(address1) && !(0, _keyring.isTonAddress)(address1) && !(0, _utilCrypto.isEthereumAddress)(address2) && !(0, _keyring.isTonAddress)(address2); // todo: need isSubstrateAddress util function to check exactly
+
+  return isSameEvmAddress || isSameTonAddress || isSameSubstrateAddress;
+}
+function isAddressAndChainCompatible(address, chain) {
+  const isEvmCompatible = (0, _utilCrypto.isEthereumAddress)(address) && (0, _utils._isChainEvmCompatible)(chain);
+  const isTonCompatible = (0, _keyring.isTonAddress)(address) && (0, _utils._isChainTonCompatible)(chain);
+  const isSubstrateCompatible = !(0, _utilCrypto.isEthereumAddress)(address) && !(0, _keyring.isTonAddress)(address) && (0, _utils._isChainSubstrateCompatible)(chain); // todo: need isSubstrateAddress util function to check exactly
+
+  return isEvmCompatible || isSubstrateCompatible || isTonCompatible;
+}
 function getDomainFromUrl(url) {
   return url.replace(/^(https?:\/\/)?(www\.)?/, '').split('/')[0];
 }

package/constants/environment.d.ts

@@ -0,0 +1 @@
+export declare const isProductionMode: boolean;

package/constants/environment.js

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
+const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
+export const isProductionMode = PRODUCTION_BRANCHES.indexOf(branchName) > -1;

package/constants/index.d.ts

@@ -1,3 +1,4 @@
+import { AccountAuthType } from '@subwallet/extension-base/background/types';
 export declare const BASE_SECOND_INTERVAL = 1000;
 export declare const BASE_MINUTE_INTERVAL: number;
 export declare const CRON_REFRESH_PRICE_INTERVAL = 30000;
@@ -22,6 +23,7 @@ export declare const ALL_ACCOUNT_KEY = "ALL";
 export declare const ALL_NETWORK_KEY = "all";
 export declare const ALL_GENESIS_HASH: null;
 export declare const IGNORE_GET_SUBSTRATE_FEATURES_LIST: string[];
+export declare const ALL_ACCOUNT_AUTH_TYPES: AccountAuthType[];
 export declare const IGNORE_QR_SIGNER: string[];
 export declare const XCM_MIN_AMOUNT_RATIO = 1.2;
 export declare const XCM_FEE_RATIO = 2;
@@ -30,6 +32,8 @@ export declare const NETWORK_MULTI_GAS_FEE: string[];
 export declare const ORDINAL_COLLECTION = "__Ordinal__";
 export declare const ORDINAL_METHODS: string[];
 export declare const PERMISSIONS_TO_REVOKE: string[];
+export * from './blocked-actions-list';
+export * from './environment';
+export * from './signing';
 export * from './staking';
 export * from './storage';
-export * from './blocked-actions-list';

package/constants/index.js

@@ -25,6 +25,7 @@ export const ALL_ACCOUNT_KEY = 'ALL';
 export const ALL_NETWORK_KEY = 'all';
 export const ALL_GENESIS_HASH = null;
 export const IGNORE_GET_SUBSTRATE_FEATURES_LIST = ['astarEvm', 'ethereum', 'ethereum_goerli', 'binance', 'binance_test', 'boba_rinkeby', 'boba', 'bobabase', 'bobabeam'];
+export const ALL_ACCOUNT_AUTH_TYPES = ['evm', 'substrate', 'ton'];
 export const IGNORE_QR_SIGNER = [];
 export const XCM_MIN_AMOUNT_RATIO = 1.2;
 export const XCM_FEE_RATIO = 2;
@@ -33,6 +34,8 @@ export const NETWORK_MULTI_GAS_FEE = ['*'];
 export const ORDINAL_COLLECTION = '__Ordinal__';
 export const ORDINAL_METHODS = ['drc-20', 'pol-20'];
 export const PERMISSIONS_TO_REVOKE = ['eth_accounts'];
+export * from "./blocked-actions-list.js";
+export * from "./environment.js";
+export * from "./signing.js";
 export * from "./staking.js";
-export * from "./storage.js";
-export * from "./blocked-actions-list.js";
+export * from "./storage.js";

package/constants/signing.d.ts

@@ -0,0 +1,4 @@
+import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountChainType } from '@subwallet/extension-base/types';
+export declare const SIGNING_COMPATIBLE_MAP: Record<ChainType, AccountChainType[]>;
+export declare const LEDGER_SIGNING_COMPATIBLE_MAP: Record<ChainType, AccountChainType[]>;

package/constants/signing.js

@@ -0,0 +1,15 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountChainType } from '@subwallet/extension-base/types';
+export const SIGNING_COMPATIBLE_MAP = {
+  [ChainType.SUBSTRATE]: [AccountChainType.SUBSTRATE, AccountChainType.ETHEREUM],
+  [ChainType.EVM]: [AccountChainType.ETHEREUM],
+  [ChainType.TON]: [AccountChainType.TON]
+};
+export const LEDGER_SIGNING_COMPATIBLE_MAP = {
+  [ChainType.SUBSTRATE]: [AccountChainType.SUBSTRATE],
+  [ChainType.EVM]: [AccountChainType.ETHEREUM],
+  [ChainType.TON]: [AccountChainType.TON]
+};

package/constants/storage.d.ts

@@ -3,3 +3,4 @@ export declare const DEFAULT_LANGUAGE = "en";
 export declare const CURRENCY = "current-currency";
 export declare const REMIND_EXPORT_ACCOUNT = "remind_export_account";
 export declare const LATEST_SESSION = "general.latest-session";
+export declare const UPGRADE_DUPLICATE_ACCOUNT_NAME = "general.upgrade-duplicate-account-name";

package/constants/storage.js

@@ -5,4 +5,5 @@ export const LANGUAGE = 'current-language';
 export const DEFAULT_LANGUAGE = 'en';
 export const CURRENCY = 'current-currency';
 export const REMIND_EXPORT_ACCOUNT = 'remind_export_account';
-export const LATEST_SESSION = 'general.latest-session';
+export const LATEST_SESSION = 'general.latest-session';
+export const UPGRADE_DUPLICATE_ACCOUNT_NAME = 'general.upgrade-duplicate-account-name';

package/core/consts.d.ts

@@ -0,0 +1 @@
+export declare const LEDGER_GENERIC_ALLOW_NETWORKS: string[];

package/core/consts.js

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export const LEDGER_GENERIC_ALLOW_NETWORKS = ['polkadot', 'statemint', 'bridgeHubPolkadot', 'collectives', 'centrifuge', 'manta_network', 'ajunaPolkadot', 'astar', 'bifrost_dot', 'hydradx_main', 'kusama', 'encointer', 'statemine', 'bridgeHubKusama', 'peopleKusama', 'altair', 'bajun', 'bifrost', 'calamari', 'shiden', 'tinkernet', 'rococo', 'rococo_assethub', 'hydradx_rococo', 'bifrost_testnet', 'westend', 'shibuya'];
+
+// export const ERROR_MESSAGE_MAP: Record<ValidationCondition, string> = {
+//   IS_NOT_NULL: 'Recipient address is required.',
+//   IS_ADDRESS: 'Invalid recipient address.',
+//   IS_VALID_ADDRESS_FOR_ECOSYSTEM: 'The recipient address must be {{chainType}} type',
+//   IS_VALID_SUBSTRATE_ADDRESS_FORMAT: 'Recipient should be a valid {{destChainName}} address',
+//   IS_NOT_DUPLICATE_ADDRESS: 'The recipient address can not be the same as the sender address',
+//   IS_SUPPORT_LEDGER_ACCOUNT: 'Ledger {{ledgerType}} address is not supported for this transfer'
+// };

package/core/logic-validation/recipientAddress.d.ts

@@ -0,0 +1,2 @@
+import { ValidateRecipientParams } from '@subwallet/extension-base/core/types';
+export declare function validateRecipientAddress(validateRecipientParams: ValidateRecipientParams): Promise<void>;

package/core/logic-validation/recipientAddress.js

@@ -0,0 +1,100 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ActionType, ValidationCondition } from '@subwallet/extension-base/core/types';
+import { _isAddress, _isNotDuplicateAddress, _isNotNull, _isSupportLedgerAccount, _isValidAddressForEcosystem, _isValidSubstrateAddressFormat, _isValidTonAddressFormat } from '@subwallet/extension-base/core/utils';
+import { AccountSignMode } from '@subwallet/extension-base/types';
+import { detectTranslate } from '@subwallet/extension-base/utils';
+import { isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
+function getConditions(validateRecipientParams) {
+  const {
+    account,
+    actionType,
+    autoFormatValue,
+    destChainInfo,
+    srcChain,
+    toAddress
+  } = validateRecipientParams;
+  const conditions = [];
+  const isSendAction = [ActionType.SEND_FUND, ActionType.SEND_NFT].includes(actionType);
+  conditions.push(ValidationCondition.IS_NOT_NULL);
+  conditions.push(ValidationCondition.IS_ADDRESS);
+  conditions.push(ValidationCondition.IS_VALID_ADDRESS_FOR_ECOSYSTEM);
+  if (isSubstrateAddress(toAddress) && !autoFormatValue) {
+    // todo: need isSubstrateAddress util function to check exactly
+    conditions.push(ValidationCondition.IS_VALID_SUBSTRATE_ADDRESS_FORMAT);
+  }
+  if (isTonAddress(toAddress)) {
+    conditions.push(ValidationCondition.IS_VALID_TON_ADDRESS_FORMAT);
+  }
+  if (srcChain === destChainInfo.slug && isSendAction && !destChainInfo.tonInfo) {
+    conditions.push(ValidationCondition.IS_NOT_DUPLICATE_ADDRESS);
+  }
+  if (account !== null && account !== void 0 && account.isHardware) {
+    conditions.push(ValidationCondition.IS_SUPPORT_LEDGER_ACCOUNT);
+    if (account.signMode === AccountSignMode.LEGACY_LEDGER) {
+      conditions.push(ValidationCondition.IS_VALID_SUBSTRATE_ADDRESS_FORMAT);
+    }
+  }
+  return conditions;
+}
+function getValidationFunctions(conditions) {
+  const validationFunctions = [];
+  for (const condition of conditions) {
+    switch (condition) {
+      case ValidationCondition.IS_NOT_NULL:
+        {
+          validationFunctions.push(_isNotNull);
+          break;
+        }
+      case ValidationCondition.IS_ADDRESS:
+        {
+          validationFunctions.push(_isAddress);
+          break;
+        }
+      case ValidationCondition.IS_VALID_ADDRESS_FOR_ECOSYSTEM:
+        {
+          validationFunctions.push(_isValidAddressForEcosystem);
+          break;
+        }
+      case ValidationCondition.IS_VALID_SUBSTRATE_ADDRESS_FORMAT:
+        {
+          validationFunctions.push(_isValidSubstrateAddressFormat);
+          break;
+        }
+      case ValidationCondition.IS_VALID_TON_ADDRESS_FORMAT:
+        {
+          validationFunctions.push(_isValidTonAddressFormat);
+          break;
+        }
+      case ValidationCondition.IS_NOT_DUPLICATE_ADDRESS:
+        {
+          validationFunctions.push(_isNotDuplicateAddress);
+          break;
+        }
+      case ValidationCondition.IS_SUPPORT_LEDGER_ACCOUNT:
+        {
+          validationFunctions.push(_isSupportLedgerAccount);
+          break;
+        }
+    }
+  }
+  return validationFunctions;
+}
+function runValidationFunctions(validateRecipientParams, validationFunctions) {
+  const validationResults = [];
+  for (const validationFunction of validationFunctions) {
+    validationResults.push(validationFunction(validateRecipientParams));
+  }
+  for (const result of validationResults) {
+    if (result) {
+      return Promise.reject(detectTranslate(result));
+    }
+  }
+  return Promise.resolve();
+}
+export function validateRecipientAddress(validateRecipientParams) {
+  const conditions = getConditions(validateRecipientParams);
+  const validationFunctions = getValidationFunctions(conditions);
+  return runValidationFunctions(validateRecipientParams, validationFunctions);
+}

package/core/logic-validation/request.js

@@ -4,10 +4,12 @@
 import { typedSignatureHash } from '@metamask/eth-sig-util';
 import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { BasicTxErrorType, EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
+import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { BN_ZERO, createPromiseHandler, isSameAddress, stripUrl, wait } from '@subwallet/extension-base/utils';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
+import { isSubstrateAddress } from '@subwallet/keyring';
 import { keyring } from '@subwallet/ui-keyring';
 import { getSdkError } from '@walletconnect/utils';
 import BigN from 'bignumber.js';
@@ -237,8 +239,7 @@ export async function validationEvmDataTransactionMiddleware(koni, url, payload)
   const transactionParams = payload.payloadAfterValidated;
   const {
     address: fromAddress,
-    networkKey,
-    pair
+    networkKey
   } = payload;
   const evmApi = koni.getEvmApi(networkKey || '');
   const web3 = evmApi === null || evmApi === void 0 ? void 0 : evmApi.api;
@@ -357,11 +358,6 @@ export async function validationEvmDataTransactionMiddleware(koni, url, payload)
       handleError(e.message);
     }
   }
-  const pair_ = pair || keyring.getPair(fromAddress);
-  const account = {
-    address: fromAddress,
-    ...(pair_ === null || pair_ === void 0 ? void 0 : pair_.meta)
-  };
   try {
     transaction.nonce = await web3.eth.getTransactionCount(fromAddress);
   } catch (e) {
@@ -384,7 +380,7 @@ export async function validationEvmDataTransactionMiddleware(koni, url, payload)
     errors,
     payloadAfterValidated: {
       ...transaction,
-      account,
+      address: fromAddress,
       estimateGas,
       hashPayload,
       isToContract,
@@ -419,10 +415,6 @@ export async function validationEvmSignMessageMiddleware(koni, url, payload_) {
     handleError('Not found address or payload to sign');
   }
   const pair = pair_ || keyring.getPair(address);
-  const account = {
-    address: pair.address,
-    ...pair.meta
-  };
   if (method) {
     if (['eth_sign', 'personal_sign', 'eth_signTypedData', 'eth_signTypedData_v1', 'eth_signTypedData_v3', 'eth_signTypedData_v4'].indexOf(method) < 0) {
       handleError('Unsupported action');
@@ -438,13 +430,13 @@ export async function validationEvmSignMessageMiddleware(koni, url, payload_) {
           hashPayload = payload;
           break;
         case 'eth_sign':
-          if (!account.isExternal) {
+          if (!pair.meta.isExternal) {
             canSign = true;
           }
           break;
         case 'eth_signTypedData':
         case 'eth_signTypedData_v1':
-          if (!account.isExternal) {
+          if (!pair.meta.isExternal) {
             canSign = true;
           }
           payload = validateTypedSignMessageDataV1({
@@ -454,7 +446,7 @@ export async function validationEvmSignMessageMiddleware(koni, url, payload_) {
           break;
         case 'eth_signTypedData_v3':
         case 'eth_signTypedData_v4':
-          if (!account.isExternal) {
+          if (!pair.meta.isExternal) {
             canSign = true;
           }
           payload = validateTypedSignMessageDataV3V4({
@@ -473,7 +465,7 @@ export async function validationEvmSignMessageMiddleware(koni, url, payload_) {
     handleError('Unsupported method');
   }
   const payloadAfterValidated = {
-    account: account,
+    address,
     type: method || '',
     payload: payload,
     hashPayload: hashPayload,
@@ -505,7 +497,7 @@ export function validationAuthWCMiddleware(koni, url, payload, topic) {
     if (isEthereumAddress(address)) {
       var _requestSession$names;
       sessionAccounts = ((_requestSession$names = requestSession.namespaces.eip155.accounts) === null || _requestSession$names === void 0 ? void 0 : _requestSession$names.map(account => account.split(':')[2])) || sessionAccounts;
-    } else {
+    } else if (isSubstrateAddress(address)) {
       var _requestSession$names2;
       sessionAccounts = ((_requestSession$names2 = requestSession.namespaces.polkadot.accounts) === null || _requestSession$names2 === void 0 ? void 0 : _requestSession$names2.map(account => account.split(':')[2])) || sessionAccounts;
     }

package/core/logic-validation/swap.js

@@ -3,8 +3,8 @@
 
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import { _getAssetDecimals, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { SwapErrorType } from '@subwallet/extension-base/types/swap';
 import { formatNumber } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';

package/core/logic-validation/transfer.d.ts

@@ -2,7 +2,7 @@ import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { _Address, AmountData, ExtrinsicType, FeeData } from '@subwallet/extension-base/background/KoniTypes';
 import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
-import { _EvmApi } from '@subwallet/extension-base/services/chain-service/types';
+import { _EvmApi, _TonApi } from '@subwallet/extension-base/services/chain-service/types';
 import { OptionalSWTransaction, SWTransactionInput, SWTransactionResponse } from '@subwallet/extension-base/services/transaction-service/types';
 import { KeyringPair } from '@subwallet/keyring/types';
 import BigN from 'bignumber.js';
@@ -14,5 +14,6 @@ export declare function checkSupportForFeature(validationResponse: SWTransaction
 export declare function checkSupportForAction(validationResponse: SWTransactionResponse, blockedActionsMap: Record<ExtrinsicType, string[]>): void;
 export declare function checkSupportForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction): void;
 export declare function estimateFeeForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction, chainInfo: _ChainInfo, evmApi: _EvmApi): Promise<FeeData>;
-export declare function checkSigningAccountForTransaction(validationResponse: SWTransactionResponse): void;
+export declare function checkSigningAccountForTransaction(validationResponse: SWTransactionResponse, chainInfoMap: Record<string, _ChainInfo>): void;
 export declare function checkBalanceWithTransactionFee(validationResponse: SWTransactionResponse, transactionInput: SWTransactionInput, nativeTokenInfo: _ChainAsset, nativeTokenAvailable: AmountData): void;
+export declare function checkTonAddressBounceableAndAccountNotActive(tonApi: _TonApi, validationResponse: SWTransactionResponse): Promise<void>;

package/core/logic-validation/transfer.js

@@ -2,15 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { BasicTxErrorType, BasicTxWarningCode, ExtrinsicType, TransferTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
-import { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
+import { LEDGER_SIGNING_COMPATIBLE_MAP, SIGNING_COMPATIBLE_MAP, XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { _canAccountBeReaped } from '@subwallet/extension-base/core/substrate/system-pallet';
+import { isBounceableAddress } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
 import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
-import { _getChainExistentialDeposit, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getTokenMinAmount, _isNativeToken, _isTokenEvmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getChainExistentialDeposit, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getTokenMinAmount, _isNativeToken, _isTokenEvmSmartContract, _isTokenTonSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
 import { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
-import { isSubstrateTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
-import { balanceFormatter, formatNumber } from '@subwallet/extension-base/utils';
+import { isSubstrateTransaction, isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { AccountSignMode, BasicTxErrorType, BasicTxWarningCode, TransferTxErrorType } from '@subwallet/extension-base/types';
+import { balanceFormatter, formatNumber, pairToAccount } from '@subwallet/extension-base/utils';
+import { isTonAddress } from '@subwallet/keyring';
 import { keyring } from '@subwallet/ui-keyring';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
@@ -35,6 +38,9 @@ export function validateTransferRequest(tokenInfo, from, to, value, transferAll)
   if (isEthereumAddress(from) && isEthereumAddress(to) && _isTokenEvmSmartContract(tokenInfo) && _getContractAddressOfToken(tokenInfo).length === 0) {
     errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found ERC20 address for this token')));
   }
+  if (isTonAddress(from) && isTonAddress(to) && _isTokenTonSmartContract(tokenInfo) && _getContractAddressOfToken(tokenInfo).length === 0) {
+    errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Not found TEP74 address for this token')));
+  }
   return [errors, keypair, transferValue];
 }
 export function additionalValidateTransfer(tokenInfo, nativeTokenInfo, extrinsicType, receiverTransferTokenFreeBalance, transferAmount, senderTransferTokenTransferable, receiverNativeTransferable) {
@@ -333,6 +339,8 @@ export async function estimateFeeForTransaction(validationResponse, transaction,
     try {
       if (isSubstrateTransaction(transaction)) {
         estimateFee.value = (await transaction.paymentInfo(validationResponse.address)).partialFee.toString();
+      } else if (isTonTransaction(transaction)) {
+        estimateFee.value = transaction.estimateFee; // todo: might need to update logic estimate fee inside for future actions excluding normal transfer Ton and Jetton
       } else {
         const gasLimit = await evmApi.api.eth.estimateGas(transaction);
         const priority = await calculateGasFeeParams(evmApi, chainInfo.slug);
@@ -354,14 +362,30 @@ export async function estimateFeeForTransaction(validationResponse, transaction,
   }
   return estimateFee;
 }
-export function checkSigningAccountForTransaction(validationResponse) {
-  const pair = keyring.getPair(validationResponse.address);
+export function checkSigningAccountForTransaction(validationResponse, chainInfoMap) {
+  const {
+    address,
+    chain,
+    chainType,
+    extrinsicType
+  } = validationResponse;
+  const pair = keyring.getPair(address);
   if (!pair) {
     validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('Unable to find account')));
   } else {
-    var _pair$meta;
-    if ((_pair$meta = pair.meta) !== null && _pair$meta !== void 0 && _pair$meta.isReadOnly) {
-      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('This account is watch-only')));
+    const accountJson = pairToAccount(pair, chainInfoMap);
+    if (!accountJson.transactionActions.includes(extrinsicType)) {
+      // check if the account can sign the transaction type
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('This feature is not available with this account')));
+    } else if (accountJson.specialChain && accountJson.specialChain !== chain) {
+      // check if the account can only be used on a specific chain (for ledger legacy)
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('This feature is not available with this account')));
+    } else {
+      const compatibleMap = [AccountSignMode.LEGACY_LEDGER, AccountSignMode.GENERIC_LEDGER].includes(accountJson.signMode) ? LEDGER_SIGNING_COMPATIBLE_MAP : SIGNING_COMPATIBLE_MAP;
+      if (!compatibleMap[chainType].includes(accountJson.chainType)) {
+        // check if the account chain type is compatible with the transaction chain type
+        validationResponse.errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('This feature is not available with this account')));
+      }
     }
   }
 }
@@ -396,4 +420,20 @@ export function checkBalanceWithTransactionFee(validationResponse, transactionIn
   if (isNeedCheckRemainingBalance && isRemainingBalanceValid) {
     edAsWarning ? validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT)) : validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
   }
+}
+export async function checkTonAddressBounceableAndAccountNotActive(tonApi, validationResponse) {
+  const {
+    to
+  } = validationResponse.data;
+  const isActive = await isAccountActive(tonApi, to);
+  if (isTonAddressBounceable(to) && !isActive) {
+    validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS));
+  }
+}
+function isTonAddressBounceable(address) {
+  return isBounceableAddress(address);
+}
+async function isAccountActive(tonApi, address) {
+  const state = await tonApi.getAccountState(address);
+  return state === 'active';
 }