@subwallet/extension-base 1.2.25-0 → 1.2.25-1

package/cjs/services/transaction-service/index.js

@@ -835,6 +835,7 @@ class TransactionService {
     const payload = transaction;
     const evmApi = this.state.chainService.getEvmApi(chain);
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
+    const hasError = !!(payload.errors && payload.errors.length > 0);
     const accountPair = _uiKeyring.default.getPair(address);
     const account = {
       address,
@@ -849,9 +850,9 @@ class TransactionService {
 
     // Fill contract info
     if (!payload.parseData) {
-      const isToContract = await (0, _parseTransaction.isContractAddress)(payload.to || '', evmApi);
-      payload.isToContract = isToContract;
       try {
+        const isToContract = await (0, _parseTransaction.isContractAddress)(payload.to || '', evmApi);
+        payload.isToContract = isToContract;
         payload.parseData = isToContract ? payload.data ? (await (0, _parseTransaction.parseContractInput)(payload.data || '', payload.to || '', chainInfo)).result : '' : payload.data || '';
       } catch (e) {
         console.warn('Unable to parse contract input data');
@@ -865,11 +866,13 @@ class TransactionService {
     // Set unique nonce to avoid transaction errors
     if (!payload.nonce) {
       const evmApi = this.state.chainService.getEvmApi(chain);
-      payload.nonce = await evmApi.api.eth.getTransactionCount(address);
+      if (evmApi.isApiConnected) {
+        payload.nonce = await (evmApi === null || evmApi === void 0 ? void 0 : evmApi.api.eth.getTransactionCount(address));
+      }
     }
     if (!payload.chainId) {
       var _chainInfo$evmInfo$ev, _chainInfo$evmInfo;
-      payload.chainId = (_chainInfo$evmInfo$ev = (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.evmChainId) !== null && _chainInfo$evmInfo$ev !== void 0 ? _chainInfo$evmInfo$ev : 1;
+      payload.chainId = (_chainInfo$evmInfo$ev = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.evmChainId) !== null && _chainInfo$evmInfo$ev !== void 0 ? _chainInfo$evmInfo$ev : 1;
     }
 
     // Autofill from
@@ -878,9 +881,10 @@ class TransactionService {
     }
     const isExternal = !!account.isExternal;
     const isInjected = !!account.isInjected;
-
-    // generate hashPayload for EVM transaction
-    payload.hashPayload = this.generateHashPayload(chain, payload);
+    if (!hasError) {
+      // generate hashPayload for EVM transaction
+      payload.hashPayload = this.generateHashPayload(chain, payload);
+    }
     const emitter = new _eventemitter.default();
     const txObject = {
       nonce: (_payload$nonce = payload.nonce) !== null && _payload$nonce !== void 0 ? _payload$nonce : 0,

package/cjs/services/wallet-connect-service/handler/Eip155RequestHandler.js

@@ -10,22 +10,17 @@ var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime
 var _utils = require("@json-rpc-tools/utils");
 var _helpers = require("@subwallet/extension-base/services/wallet-connect-service/helpers");
 var _types = require("@subwallet/extension-base/services/wallet-connect-service/types");
-var _utils2 = require("@subwallet/extension-base/utils");
-var _utils3 = require("@walletconnect/utils");
+var _utils2 = require("@walletconnect/utils");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 var _walletConnectService = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("walletConnectService");
 var _koniState = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("koniState");
-var _checkAccount = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("checkAccount");
 var _handleError = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("handleError");
 class Eip155RequestHandler {
   constructor(koniState, walletConnectService) {
     Object.defineProperty(this, _handleError, {
       value: _handleError2
     });
-    Object.defineProperty(this, _checkAccount, {
-      value: _checkAccount2
-    });
     Object.defineProperty(this, _walletConnectService, {
       writable: true,
       value: void 0
@@ -50,11 +45,8 @@ class Eip155RequestHandler {
     const method = request.method;
     const requestSession = (0, _classPrivateFieldLooseBase2.default)(this, _walletConnectService)[_walletConnectService].getSession(topic);
     const url = requestSession.peer.metadata.url;
-    const sessionAccounts = requestSession.namespaces.eip155.accounts.map(account => account.split(':')[2]);
     if ([_types.EIP155_SIGNING_METHODS.PERSONAL_SIGN, _types.EIP155_SIGNING_METHODS.ETH_SIGN, _types.EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA, _types.EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V3, _types.EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4].includes(method)) {
-      const address = (0, _helpers.getEip155MessageAddress)(method, request.params);
-      (0, _classPrivateFieldLooseBase2.default)(this, _checkAccount)[_checkAccount](address, sessionAccounts);
-      (0, _classPrivateFieldLooseBase2.default)(this, _koniState)[_koniState].evmSign((0, _helpers.getWCId)(id), url, method === _types.EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA ? _types.EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4 : method, request.params, sessionAccounts).then(async signature => {
+      (0, _classPrivateFieldLooseBase2.default)(this, _koniState)[_koniState].evmSign((0, _helpers.getWCId)(id), url, method === _types.EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA ? _types.EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4 : method, request.params, topic).then(async signature => {
         await (0, _classPrivateFieldLooseBase2.default)(this, _walletConnectService)[_walletConnectService].responseRequest({
           topic: topic,
           response: (0, _utils.formatJsonRpcResult)(id, signature)
@@ -65,46 +57,30 @@ class Eip155RequestHandler {
     } else if (method === _types.EIP155_SIGNING_METHODS.ETH_SEND_TRANSACTION) {
       const [tx] = (0, _helpers.parseRequestParams)(request.params);
       const address = tx.from;
-      (0, _classPrivateFieldLooseBase2.default)(this, _checkAccount)[_checkAccount](address, sessionAccounts);
       const chainId = parseInt(_chainId.split(':')[1]);
       const [networkKey, chainInfo] = (0, _classPrivateFieldLooseBase2.default)(this, _koniState)[_koniState].findNetworkKeyByChainId(chainId);
       if (!networkKey || !chainInfo) {
-        throw new Error((0, _utils3.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + address);
+        throw new Error((0, _utils2.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + address);
       }
-      const chainState = (0, _classPrivateFieldLooseBase2.default)(this, _koniState)[_koniState].getChainStateByKey(networkKey);
-      const createRequest = () => {
-        (0, _classPrivateFieldLooseBase2.default)(this, _koniState)[_koniState].evmSendTransaction((0, _helpers.getWCId)(id), url, networkKey, sessionAccounts, tx).then(async signature => {
-          await (0, _classPrivateFieldLooseBase2.default)(this, _walletConnectService)[_walletConnectService].responseRequest({
-            topic: topic,
-            response: (0, _utils.formatJsonRpcResult)(id, signature)
-          });
-        }).catch(e => {
-          (0, _classPrivateFieldLooseBase2.default)(this, _handleError)[_handleError](topic, id, e);
-        });
-      };
-      if (!chainState.active) {
-        (0, _classPrivateFieldLooseBase2.default)(this, _koniState)[_koniState].chainService.enableChain(networkKey).then(createRequest).catch(() => {
-          throw new Error((0, _utils3.getSdkError)('USER_REJECTED').message + ' Can not active chain: ' + chainInfo.name);
+      (0, _classPrivateFieldLooseBase2.default)(this, _koniState)[_koniState].evmSendTransaction((0, _helpers.getWCId)(id), url, tx, networkKey, topic).then(async signature => {
+        await (0, _classPrivateFieldLooseBase2.default)(this, _walletConnectService)[_walletConnectService].responseRequest({
+          topic: topic,
+          response: (0, _utils.formatJsonRpcResult)(id, signature)
         });
-      } else {
-        createRequest();
-      }
+      }).catch(e => {
+        (0, _classPrivateFieldLooseBase2.default)(this, _handleError)[_handleError](topic, id, e);
+      });
     } else {
-      throw Error((0, _utils3.getSdkError)('INVALID_METHOD').message + ' ' + method);
+      throw Error((0, _utils2.getSdkError)('INVALID_METHOD').message + ' ' + method);
     }
   }
 }
 exports.default = Eip155RequestHandler;
-function _checkAccount2(address, accounts) {
-  if (!accounts.find(account => (0, _utils2.isSameAddress)(account, address))) {
-    throw new Error((0, _utils3.getSdkError)('UNSUPPORTED_ACCOUNTS').message + ' ' + address);
-  }
-}
 function _handleError2(topic, id, e) {
   console.log(e);
   let message = e.message;
   if (message.includes('User Rejected Request')) {
-    message = (0, _utils3.getSdkError)('USER_REJECTED').message;
+    message = (0, _utils2.getSdkError)('USER_REJECTED').message;
   }
   (0, _classPrivateFieldLooseBase2.default)(this, _walletConnectService)[_walletConnectService].responseRequest({
     topic: topic,

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

@@ -0,0 +1,4 @@
+export * from './swap';
+export * from './request';
+export * from './earning';
+export * from './transfer';

package/core/logic-validation/index.js

@@ -0,0 +1,7 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./swap.js";
+export * from "./request.js";
+export * from "./earning.js";
+export * from "./transfer.js";

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

@@ -0,0 +1,23 @@
+import { ConfirmationType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { AuthUrlInfo } from '@subwallet/extension-base/services/request-service/types';
+import { KeyringPair } from '@subwallet/keyring/types';
+export declare type ValidateStepFunction = (koni: KoniState, url: string, payload: PayloadValidated, topic?: string) => Promise<PayloadValidated>;
+export interface PayloadValidated {
+    networkKey: string;
+    address: string;
+    pair?: KeyringPair;
+    authInfo?: AuthUrlInfo;
+    method?: string;
+    payloadAfterValidated: any;
+    errorPosition?: 'dApp' | 'ui';
+    confirmationType?: ConfirmationType;
+    errors: Error[];
+}
+export declare function generateValidationProcess(koni: KoniState, url: string, payloadValidate: PayloadValidated, validationMiddlewareSteps: ValidateStepFunction[], topic?: string): Promise<PayloadValidated>;
+export declare function validationAuthMiddleware(koni: KoniState, url: string, payload: PayloadValidated): Promise<PayloadValidated>;
+export declare function validationConnectMiddleware(koni: KoniState, url: string, payload: PayloadValidated): Promise<PayloadValidated>;
+export declare function validationEvmDataTransactionMiddleware(koni: KoniState, url: string, payload: PayloadValidated): Promise<PayloadValidated>;
+export declare function validationEvmSignMessageMiddleware(koni: KoniState, url: string, payload_: PayloadValidated): Promise<PayloadValidated>;
+export declare function validationAuthWCMiddleware(koni: KoniState, url: string, payload: PayloadValidated, topic?: string): Promise<PayloadValidated>;
+export declare function convertErrorMessage(message_: string, name?: string): string[];

package/core/logic-validation/request.js

@@ -0,0 +1,475 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+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 { calculateGasFeeParams } from '@subwallet/extension-base/services/fee-service/utils';
+import { BN_ZERO, createPromiseHandler, isSameAddress, stripUrl, wait } from '@subwallet/extension-base/utils';
+import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
+import { keyring } from '@subwallet/ui-keyring';
+import { getSdkError } from '@walletconnect/utils';
+import BigN from 'bignumber.js';
+import BN from 'bn.js';
+import { t } from 'i18next';
+import { isString } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export async function generateValidationProcess(koni, url, payloadValidate, validationMiddlewareSteps, topic) {
+  let resultValidated = payloadValidate;
+  for (const step of validationMiddlewareSteps) {
+    resultValidated = await step(koni, url, resultValidated, topic);
+    if (resultValidated.errorPosition === 'dApp') {
+      throw resultValidated.errors[0];
+    } else if (resultValidated.errorPosition === 'ui') {
+      break;
+    }
+  }
+  return resultValidated;
+}
+export async function validationAuthMiddleware(koni, url, payload) {
+  const {
+    address,
+    errors
+  } = payload;
+  if (!address || !isString(address)) {
+    payload.errorPosition = 'dApp';
+    const [message] = convertErrorMessage('Not found address to sign');
+    errors.push(new Error(message));
+  } else {
+    try {
+      payload.pair = keyring.getPair(address);
+      if (!payload.pair) {
+        payload.errorPosition = 'dApp';
+        const [message] = convertErrorMessage('Unable to find account');
+        errors.push(new Error(message));
+      } else {
+        const authList = await koni.getAuthList();
+        const authInfo = authList[stripUrl(url)];
+        if (!authInfo || !authInfo.isAllowed || !authInfo.isAllowedMap[payload.pair.address]) {
+          payload.errorPosition = 'dApp';
+          const [message] = convertErrorMessage('Account not in allowed list', '');
+          errors.push(new Error(message));
+        }
+        payload.authInfo = authInfo;
+      }
+    } catch (e) {
+      const [message] = convertErrorMessage(e.message);
+      payload.errorPosition = 'dApp';
+      errors.push(new Error(message));
+    }
+  }
+  return payload;
+}
+export async function validationConnectMiddleware(koni, url, payload) {
+  let currentChain;
+  let autoActiveChain = false;
+  let {
+    address,
+    authInfo,
+    errors,
+    networkKey
+  } = {
+    ...payload
+  };
+  const handleError = message_ => {
+    payload.errorPosition = 'ui';
+    payload.confirmationType = 'errorConnectNetwork';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new EvmProviderError(EvmProviderErrorType.CHAIN_DISCONNECTED, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (authInfo !== null && authInfo !== void 0 && authInfo.currentEvmNetworkKey) {
+    currentChain = authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentEvmNetworkKey;
+  }
+  if (authInfo !== null && authInfo !== void 0 && authInfo.isAllowed) {
+    autoActiveChain = true;
+  }
+  const currentEvmNetwork = koni.requestService.getDAppChainInfo({
+    autoActive: autoActiveChain,
+    accessType: 'evm',
+    defaultChain: currentChain,
+    url
+  });
+  networkKey = networkKey || (currentEvmNetwork === null || currentEvmNetwork === void 0 ? void 0 : currentEvmNetwork.slug) || '';
+  if (networkKey) {
+    const chainStatus = koni.getChainStateByKey(networkKey);
+    const chainInfo = koni.getChainInfo(networkKey);
+    if (!chainStatus.active) {
+      try {
+        await koni.chainService.enableChain(networkKey);
+      } catch (e) {
+        handleError('Can not active chain: ' + chainInfo.name);
+      }
+    }
+    const evmApi = koni.getEvmApi(networkKey);
+    const web3 = evmApi === null || evmApi === void 0 ? void 0 : evmApi.api;
+    let currentProviderConnected = false;
+    const checkProviderConnected = async () => {
+      try {
+        currentProviderConnected = !!(await web3.eth.getBalance(address));
+      } catch (e) {
+        handleError(e.message);
+      }
+    };
+
+    // Calculate transaction data
+    try {
+      await Promise.race([checkProviderConnected(), wait(3000).then(async () => {
+        if (!currentProviderConnected) {
+          await koni.chainService.initSingleApi(networkKey);
+          await checkProviderConnected();
+        }
+      })]);
+    } catch (e) {
+      handleError(e.message);
+    }
+  } else {
+    handleError('This network is currently not supported');
+  }
+  return {
+    ...payload,
+    networkKey,
+    errors
+  };
+}
+export async function validationEvmDataTransactionMiddleware(koni, url, payload) {
+  const errors = payload.errors || [];
+  let estimateGas = '';
+  const transactionParams = payload.payloadAfterValidated;
+  const {
+    address: fromAddress,
+    networkKey,
+    pair
+  } = payload;
+  const evmApi = koni.getEvmApi(networkKey || '');
+  const web3 = evmApi === null || evmApi === void 0 ? void 0 : evmApi.api;
+  const autoFormatNumber = val => {
+    if (typeof val === 'string' && val.startsWith('0x')) {
+      return new BN(val.replace('0x', ''), 16).toString();
+    } else if (typeof val === 'number') {
+      return val.toString();
+    }
+    return val;
+  };
+  const handleError = message_ => {
+    payload.errorPosition = 'ui';
+    payload.confirmationType = 'evmWatchTransactionRequest';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new TransactionError(BasicTxErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (!web3) {
+    handleError('connection error');
+  }
+  const transaction = {
+    from: transactionParams.from,
+    to: transactionParams.to,
+    value: autoFormatNumber(transactionParams.value),
+    gas: autoFormatNumber(transactionParams.gas),
+    gasPrice: autoFormatNumber(transactionParams.gasPrice || transactionParams.gasLimit),
+    maxPriorityFeePerGas: autoFormatNumber(transactionParams.maxPriorityFeePerGas),
+    maxFeePerGas: autoFormatNumber(transactionParams.maxFeePerGas),
+    data: transactionParams.data
+  };
+
+  // Address is validated in before step
+  if (!fromAddress || !isEthereumAddress(fromAddress)) {
+    handleError('the sender address must be the ethereum address type');
+  }
+  if (transaction.to && !isEthereumAddress(transaction.to)) {
+    handleError('invalid recipient address');
+  }
+  if (fromAddress === transaction.to) {
+    handleError('receiving address must be different from sending address');
+  }
+  if (!transaction.to) {
+    if (transaction.data) {
+      if (transaction.value) {
+        try {
+          const valueBn = new BigN(transaction.value.toString());
+          if (!valueBn.eq(BN_ZERO)) {
+            handleError('Recipient address not found');
+          }
+        } catch (e) {
+          handleError('invalid number');
+        }
+      }
+    } else {
+      handleError('Recipient address not found');
+    }
+  }
+  if (!transaction.gas) {
+    const getTransactionGas = async () => {
+      try {
+        transaction.gas = await web3.eth.estimateGas({
+          ...transaction
+        });
+      } catch (e) {
+        handleError(e.message);
+      }
+    };
+
+    // Calculate transaction data
+    try {
+      await Promise.race([getTransactionGas(), wait(3000).then(async () => {
+        if (!transaction.gas) {
+          await koni.chainService.initSingleApi(networkKey || '');
+          await getTransactionGas();
+        }
+      })]);
+    } catch (e) {
+      handleError(e.message);
+    }
+  }
+  if (!transaction.gas) {
+    handleError(new TransactionError(BasicTxErrorType.INTERNAL_ERROR).message);
+  } else {
+    if (transactionParams.maxPriorityFeePerGas && transactionParams.maxFeePerGas) {
+      const maxFee = new BigN(transactionParams.maxFeePerGas);
+      estimateGas = maxFee.multipliedBy(transaction.gas).toFixed(0);
+    } else if (transactionParams.gasPrice) {
+      estimateGas = new BigN(transactionParams.gasPrice).multipliedBy(transaction.gas).toFixed(0);
+    } else {
+      try {
+        const priority = await calculateGasFeeParams(evmApi, networkKey || '');
+        if (priority.baseGasFee) {
+          transaction.maxPriorityFeePerGas = priority.maxPriorityFeePerGas.toString();
+          transaction.maxFeePerGas = priority.maxFeePerGas.toString();
+          const maxFee = priority.maxFeePerGas;
+          estimateGas = maxFee.multipliedBy(transaction.gas).toFixed(0);
+        } else {
+          transaction.gasPrice = priority.gasPrice;
+          estimateGas = new BigN(priority.gasPrice).multipliedBy(transaction.gas).toFixed(0);
+        }
+      } catch (e) {
+        handleError(e.message);
+      }
+    }
+    try {
+      // Validate balance
+      const balance = new BN((await web3.eth.getBalance(fromAddress)) || 0);
+      if (!estimateGas) {
+        handleError('Can\'t calculate estimate gas fee');
+      } else if (balance.lt(new BN(estimateGas).add(new BN(autoFormatNumber(transactionParams.value) || '0')))) {
+        handleError('Insufficient balance');
+      }
+    } catch (e) {
+      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) {
+    handleError(e.message);
+  }
+  const hasError = errors && errors.length > 0 || !networkKey;
+  const evmNetwork = koni.getChainInfo(networkKey || '');
+  let isToContract = false;
+  let hashPayload = '';
+  let parseData = '';
+  try {
+    hashPayload = hasError ? '' : koni.transactionService.generateHashPayload(networkKey, transaction);
+    isToContract = await isContractAddress(transaction.to || '', evmApi);
+    parseData = isToContract ? transaction.data && !hasError ? (await parseContractInput(transaction.data, transaction.to || '', evmNetwork)).result : '' : transaction.data || '';
+  } catch (e) {
+    handleError(e.message);
+  }
+  return {
+    ...payload,
+    errors,
+    payloadAfterValidated: {
+      ...transaction,
+      account,
+      estimateGas,
+      hashPayload,
+      isToContract,
+      parseData,
+      canSign: !hasError
+    }
+  };
+}
+export async function validationEvmSignMessageMiddleware(koni, url, payload_) {
+  const {
+    address,
+    errors,
+    method,
+    pair: pair_
+  } = payload_;
+  let payload = payload_.payloadAfterValidated;
+  const {
+    promise,
+    resolve
+  } = createPromiseHandler();
+  let hashPayload = '';
+  let canSign = false;
+  const handleError = message_ => {
+    payload_.errorPosition = 'ui';
+    payload_.confirmationType = 'evmSignatureRequest';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, message, undefined, name));
+  };
+  if (address === '' || !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');
+    }
+    if (['eth_signTypedData_v3', 'eth_signTypedData_v4'].indexOf(method) > -1) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-assignment
+      payload = JSON.parse(payload);
+    }
+    switch (method) {
+      case 'personal_sign':
+        canSign = true;
+        hashPayload = payload;
+        break;
+      case 'eth_sign':
+      case 'eth_signTypedData':
+      case 'eth_signTypedData_v1':
+      case 'eth_signTypedData_v3':
+      case 'eth_signTypedData_v4':
+        if (!account.isExternal) {
+          canSign = true;
+        }
+        break;
+      default:
+        handleError('Unsupported action');
+    }
+  } else {
+    handleError('Unsupported method');
+  }
+  const payloadAfterValidated = {
+    account: account,
+    type: method || '',
+    payload: payload,
+    hashPayload: hashPayload,
+    canSign: canSign,
+    id: ''
+  };
+  resolve({
+    ...payload_,
+    errors,
+    payloadAfterValidated
+  });
+  return promise;
+}
+export function validationAuthWCMiddleware(koni, url, payload, topic) {
+  const {
+    promise,
+    resolve
+  } = createPromiseHandler();
+  const {
+    address,
+    errors
+  } = payload;
+  if (!topic) {
+    payload.errorPosition = 'dApp';
+    errors.push(new Error(getSdkError('UNAUTHORIZED_EXTEND_REQUEST').message));
+  } else {
+    const requestSession = koni.walletConnectService.getSession(topic);
+    let sessionAccounts = [];
+    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 {
+      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;
+    }
+    if (!address || !isString(address)) {
+      payload.errorPosition = 'dApp';
+      const [message] = convertErrorMessage('Unable to find account');
+      errors.push(new Error(message));
+    } else {
+      try {
+        payload.pair = keyring.getPair(address);
+        if (!payload.pair) {
+          payload.errorPosition = 'dApp';
+          const [message] = convertErrorMessage('Unable to find account');
+          errors.push(new Error(message));
+        }
+        const isExitsAccount = sessionAccounts.find(account => isSameAddress(account, address));
+        if (!isExitsAccount) {
+          payload.errorPosition = 'dApp';
+          const [message] = convertErrorMessage('Account not in allowed list');
+          errors.push(new Error(message));
+        }
+      } catch (e) {
+        const [message] = convertErrorMessage(e.message);
+        payload.errorPosition = 'dApp';
+        errors.push(new Error(message));
+      }
+    }
+  }
+  resolve({
+    ...payload,
+    errors
+  });
+  return promise;
+}
+export function convertErrorMessage(message_, name) {
+  const message = message_.toLowerCase();
+
+  // Network error
+  if (message.includes('connection error') || message.includes('connection not open') || message.includes('connection timeout') || message.includes('can not active chain') || message.includes('invalid json rpc')) {
+    return [t('Re-enable the network or change RPC on the extension and try again'), t('Unstable network connection')];
+  }
+  if (message.includes('network is currently not supported')) {
+    return [t('This network is not yet supported on SubWallet. |Import the network|https://docs.subwallet.app/main/extension-user-guide/customize-your-networks#import-networks| on SubWallet and try again'), t('Network not supported')];
+  }
+
+  // Authentication
+  if (message.includes('not found address to sign') || message.includes('unable to find account') || message.includes('unable to retrieve keypair')) {
+    return ['Address not found on SubWallet. Re-check the address information in the extension then try again'];
+  }
+  if (message.includes('account not in allowed list')) {
+    return ['Account disconnected from the dApp. Open the extension to re-connect the account and try again'];
+  }
+
+  // Transaction
+
+  if (message.includes('recipient address not found')) {
+    return [t('Enter recipient address and try again'), t('Recipient address not found')];
+  }
+  if (message.includes('is not a number') || message.includes('invalid number value') || message.includes('invalid bignumberish')) {
+    return [t('Amount must be an integer. Enter an integer and try again'), t('Invalid amount')];
+  }
+  if (message.includes('calculate estimate gas fee') || message.includes('invalidcode')) {
+    return [t('Unable to calculate estimated gas for this transaction. Try again or contact support at agent@subwallet.app'), t('Gas calculation error')];
+  }
+  if (message.includes('invalid recipient address')) {
+    return [t('Make sure the recipient address is valid and in the same type as the sender address, then try again'), t('Invalid recipient address')];
+  }
+  if (message.includes('must be different from sending address')) {
+    return [t('The recipient address must be different from the sender address'), t('Invalid recipient address')];
+  }
+  if (message.includes('the sender address must be the ethereum address type')) {
+    return [t('The sender address must be the ethereum address type'), t('Invalid address type')];
+  }
+  if (message.includes('insufficient balance') || message.includes('insufficient funds')) {
+    return [t('Insufficient balance on the sender address. Top up your balance and try again'), t('Unable to sign transaction')];
+  }
+
+  // Sign Message
+  if (message.includes('not found address or payload to sign')) {
+    return [t('An error occurred when signing this request. Try again or contact support at agent@subwallet.app'), t('Unable to sign message')];
+  }
+  if (message.includes('unsupported method') || message.includes('unsupported action')) {
+    return [t('This sign method is not supported by SubWallet. Try again or contact support at agent@subwallet.app'), t('Method not supported')];
+  }
+  return [message, name || ''];
+}

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

@@ -7,7 +7,7 @@ import { OptionalSWTransaction, SWTransactionInput, SWTransactionResponse } from
 import { KeyringPair } from '@subwallet/keyring/types';
 import BigN from 'bignumber.js';
 export declare function validateTransferRequest(tokenInfo: _ChainAsset, from: _Address, to: _Address, value: string | undefined, transferAll: boolean | undefined): [TransactionError[], KeyringPair | undefined, BigN | undefined];
-export declare function additionalValidateTransfer(tokenInfo: _ChainAsset, extrinsicType: ExtrinsicType, receiverTransferTokenFreeBalance: string, transferAmount: string, senderTransferTokenTransferable?: string): [TransactionWarning | undefined, TransactionError | undefined];
+export declare function additionalValidateTransfer(tokenInfo: _ChainAsset, nativeTokenInfo: _ChainAsset, extrinsicType: ExtrinsicType, receiverTransferTokenFreeBalance: string, transferAmount: string, senderTransferTokenTransferable?: string, receiverNativeTransferable?: string): [TransactionWarning[], TransactionError[]];
 export declare function validateXcmTransferRequest(destTokenInfo: _ChainAsset | undefined, sender: _Address, sendingValue: string): [TransactionError[], KeyringPair | undefined, BigN | undefined];
 export declare function additionalValidateXcmTransfer(originTokenInfo: _ChainAsset, destinationTokenInfo: _ChainAsset, sendingAmount: string, senderTransferable: string, receiverNativeBalance: string, destChainInfo: _ChainInfo, isSnowBridge?: boolean): [TransactionWarning | undefined, TransactionError | undefined];
 export declare function checkSupportForTransaction(validationResponse: SWTransactionResponse, transaction: OptionalSWTransaction): void;