@subwallet/extension-base 1.3.36-0 → 1.3.38-0

package/cjs/services/swap-service/handler/uniswap-handler.js

@@ -11,12 +11,13 @@ var _logicValidation = require("@subwallet/extension-base/core/logic-validation"
 var _web = require("@subwallet/extension-base/koni/api/contract-handler/evm/web3");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _acrossBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge");
+var _utils = require("@subwallet/extension-base/services/swap-service/utils");
 var _types = require("@subwallet/extension-base/types");
-var _utils = require("@subwallet/extension-base/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
-var _utils2 = require("../../chain-service/utils");
-var _utils3 = require("../../fee-service/utils");
+var _utils3 = require("../../chain-service/utils");
+var _utils4 = require("../../fee-service/utils");
 var _baseHandler = require("./base-handler");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
@@ -101,7 +102,8 @@ class UniswapHandler {
     const stepFuncList = [];
     /**
      * approve - permit - swap or
-     * approve - permit - swap - approve - bridge
+     * approve - permit - swap - approve - bridge or
+     * approve - bridge - approve - permit - swap
      */
 
     params.path.forEach(step => {
@@ -118,11 +120,26 @@ class UniswapHandler {
     return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
   }
   async getApprovalStep(params, stepIndex) {
-    if (stepIndex === 0) {
+    /**
+     * Explain: All processes will go through one of below processes. If a step do not have, it returns undefined and
+     * the stepIndex is still counted up
+     *
+     * Processes:
+     * approve - permit - swap or
+     * approve - permit - swap - approve - bridge or
+     * approve - bridge - approve - permit - swap
+     */
+    const actionList = JSON.stringify(params.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_types.DynamicSwapType.SWAP]);
+    const swapBridge = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const bridgeSwap = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP]);
+    const isApproveBridge = stepIndex === 3 && swapBridge || stepIndex === 0 && bridgeSwap;
+    const isApproveSwap = stepIndex === 0 && swap || stepIndex === 0 && swapBridge || stepIndex === 2 && bridgeSwap;
+    if (isApproveSwap) {
       return this.getApproveSwap(params);
     }
-    if (stepIndex === 3) {
-      return this.getApproveBridge(params);
+    if (isApproveBridge) {
+      return this.getApproveBridge(params, bridgeSwap);
     }
     return Promise.resolve(undefined);
   }
@@ -160,9 +177,9 @@ class UniswapHandler {
       return undefined;
     }
     const fromTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
-    const fromChainInfo = this.chainService.getChainInfoByKey((0, _utils2._getAssetOriginChain)(fromTokenInfo));
+    const fromChainInfo = this.chainService.getChainInfoByKey((0, _utils3._getAssetOriginChain)(fromTokenInfo));
     const evmApi = this.chainService.getEvmApi(fromChainInfo.slug);
-    const tokenContract = (0, _utils2._getContractAddressOfToken)(fromTokenInfo);
+    const tokenContract = (0, _utils3._getContractAddressOfToken)(fromTokenInfo);
     const approval = checkApprovalResponse.approval;
     if (!approval) {
       return Promise.resolve(undefined);
@@ -177,7 +194,7 @@ class UniswapHandler {
     const tx = await (0, _web.getERC20SpendingApprovalTx)(spender, sender, tokenContract, evmApi);
     const evmFeeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), fromTokenInfo.originChain, 'evm');
     const estimatedFee = await (0, _web.estimateTxFee)(tx, evmApi, evmFeeInfo);
-    const nativeTokenSlug = (0, _utils2._getChainNativeTokenSlug)(fromChainInfo);
+    const nativeTokenSlug = (0, _utils3._getChainNativeTokenSlug)(fromChainInfo);
     const feeInfo = {
       feeComponent: [{
         feeType: _types.SwapFeeType.NETWORK_FEE,
@@ -193,7 +210,7 @@ class UniswapHandler {
       // @ts-ignore
       metadata: {
         tokenApprove: fromTokenInfo.slug,
-        contractAddress: (0, _utils2._getContractAddressOfToken)(fromTokenInfo) || approval.to,
+        contractAddress: (0, _utils3._getContractAddressOfToken)(fromTokenInfo) || approval.to,
         spenderAddress: spender,
         owner: sender,
         // todo: use approval.from?
@@ -203,22 +220,30 @@ class UniswapHandler {
     };
     return Promise.resolve([submitStep, feeInfo]);
   }
-  async getApproveBridge(params) {
-    const quote = params.selectedQuote;
-    if (!quote) {
+  async getApproveBridge(params, isBridgeFirst) {
+    const {
+      path,
+      request,
+      selectedQuote
+    } = params;
+    if (!selectedQuote) {
       return Promise.resolve(undefined);
     }
-    console.log('params', params);
-    const sendingAmount = quote.toAmount;
-    const senderAddress = params.request.address;
-    const fromTokenInfo = this.chainService.getAssetBySlug(quote.pair.to);
-    const fromChainInfo = this.chainService.getChainInfoByKey((0, _utils2._getAssetOriginChain)(fromTokenInfo));
-    const fromChainId = (0, _utils2._getEvmChainId)(fromChainInfo);
+    const bridgePairInfo = path.find(action => action.action === _types.DynamicSwapType.BRIDGE);
+    if (!bridgePairInfo || !bridgePairInfo.pair) {
+      return Promise.resolve(undefined);
+    }
+    const _sendingAmount = isBridgeFirst ? request.fromAmount : selectedQuote.toAmount;
+    const sendingAmount = (0, _bignumber.default)(_sendingAmount).multipliedBy(2).toFixed(0, 1); // ensure approve enough amount
+    const senderAddress = request.address;
+    const fromTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.from);
+    const fromChainInfo = this.chainService.getChainInfoByKey((0, _utils3._getAssetOriginChain)(fromTokenInfo));
+    const fromChainId = (0, _utils3._getEvmChainId)(fromChainInfo);
     const evmApi = this.chainService.getEvmApi(fromChainInfo.slug);
-    const tokenContract = (0, _utils2._getContractAddressOfToken)(fromTokenInfo);
-    const toTokenInfo = this.chainService.getAssetBySlug(params.request.pair.to);
-    const toChainInfo = this.chainService.getChainInfoByKey((0, _utils2._getAssetOriginChain)(toTokenInfo));
-    if ((0, _utils2._isNativeToken)(fromTokenInfo)) {
+    const tokenContract = (0, _utils3._getContractAddressOfToken)(fromTokenInfo);
+    const toTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.to);
+    const toChainInfo = this.chainService.getChainInfoByKey((0, _utils3._getAssetOriginChain)(toTokenInfo));
+    if ((0, _utils3._isNativeToken)(fromTokenInfo)) {
       return Promise.resolve(undefined);
     }
     if (!fromChainId) {
@@ -227,9 +252,10 @@ class UniswapHandler {
     const inputData = {
       destinationTokenInfo: toTokenInfo,
       originTokenInfo: fromTokenInfo,
-      sendingValue: sendingAmount,
+      sendingValue: _sendingAmount,
       sender: senderAddress,
       recipient: senderAddress,
+      // todo: there's a case swap - bridge to another address
       destinationChain: toChainInfo,
       originChain: fromChainInfo
     };
@@ -242,7 +268,7 @@ class UniswapHandler {
     const tx = await (0, _web.getERC20SpendingApprovalTx)(spokePoolAddress, senderAddress, tokenContract, evmApi);
     const evmFeeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), fromTokenInfo.originChain, 'evm');
     const estimatedFee = await (0, _web.estimateTxFee)(tx, evmApi, evmFeeInfo);
-    const nativeTokenSlug = (0, _utils2._getChainNativeTokenSlug)(fromChainInfo);
+    const nativeTokenSlug = (0, _utils3._getChainNativeTokenSlug)(fromChainInfo);
     const feeInfo = {
       feeComponent: [{
         feeType: _types.SwapFeeType.NETWORK_FEE,
@@ -302,6 +328,10 @@ class UniswapHandler {
     if (!selectedQuote) {
       return Promise.resolve(undefined);
     }
+    const actionList = JSON.stringify(path.map(step => step.action));
+    const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const sendingValue = swapXcm ? (0, _bignumber.default)(request.fromAmount).multipliedBy(_utils.DEFAULT_EXCESS_AMOUNT_WEIGHT).toFixed(0, 1) : request.fromAmount;
+    const expectedReceive = swapXcm ? (0, _bignumber.default)(selectedQuote.toAmount).multipliedBy(_utils.DEFAULT_EXCESS_AMOUNT_WEIGHT).toFixed(0, 1) : selectedQuote.toAmount;
     const originTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
     const destinationTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.to);
     const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
@@ -311,12 +341,12 @@ class UniswapHandler {
       type: _types.SwapStepType.SWAP,
       // @ts-ignore
       metadata: {
-        sendingValue: request.fromAmount.toString(),
-        expectedReceive: selectedQuote.toAmount,
+        sendingValue,
+        expectedReceive,
         originTokenInfo,
         destinationTokenInfo,
-        sender: (0, _utils._reformatAddressWithChain)(request.address, originChain),
-        receiver: (0, _utils._reformatAddressWithChain)(request.recipient || request.address, destinationChain),
+        sender: (0, _utils2._reformatAddressWithChain)(request.address, originChain),
+        receiver: (0, _utils2._reformatAddressWithChain)(request.recipient || request.address, destinationChain),
         version: 2
       }
     };
@@ -328,6 +358,20 @@ class UniswapHandler {
       request,
       selectedQuote
     } = params;
+    /**
+     * Explain: All processes will go through one of below processes. If a step do not have, it returns undefined and
+     * the stepIndex is still counted up
+     *
+     * Processes:
+     * approve - permit - swap or
+     * approve - permit - swap - approve - bridge or
+     * approve - bridge - approve - permit - swap
+     */
+    const actionList = JSON.stringify(path.map(step => step.action));
+    const bridgeSwap = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP]);
+    const swapBridge = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const isBridgeFirst = stepIndex === 1 && bridgeSwap;
+    const isBridgeSecond = stepIndex === 4 && swapBridge;
 
     // stepIndex is not corresponding index in path, because uniswap include approval and permit step
     const bridgePairInfo = path.find(action => action.action === _types.DynamicSwapType.BRIDGE);
@@ -344,9 +388,18 @@ class UniswapHandler {
     if (!fromChainInfo || !toChainInfo || !fromChainInfo || !toChainInfo) {
       throw Error('Token or chain not found');
     }
-    const senderAddress = (0, _utils._reformatAddressWithChain)(request.address, fromChainInfo);
-    const receiverAddress = (0, _utils._reformatAddressWithChain)(request.recipient || request.address, toChainInfo);
-    const sendingValue = (0, _bignumber.default)(selectedQuote.toAmount).div(1.02).toFixed(0, 1);
+    let receiverAddress;
+    let mockSendingValue;
+    const senderAddress = (0, _utils2._reformatAddressWithChain)(request.address, fromChainInfo);
+    if (isBridgeFirst) {
+      receiverAddress = (0, _utils2._reformatAddressWithChain)(request.address, toChainInfo);
+      mockSendingValue = (0, _bignumber.default)(selectedQuote.fromAmount).toFixed(0, 1);
+    } else if (isBridgeSecond) {
+      receiverAddress = (0, _utils2._reformatAddressWithChain)(request.recipient || request.address, toChainInfo);
+      mockSendingValue = (0, _bignumber.default)(selectedQuote.toAmount).toFixed(0, 1);
+    } else {
+      return undefined;
+    }
     try {
       const evmApi = await this.chainService.getEvmApi(fromChainInfo.slug).isReady;
       const feeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), fromTokenInfo.originChain, 'evm');
@@ -358,33 +411,45 @@ class UniswapHandler {
         evmApi,
         feeInfo,
         // Mock sending value to get payment info
-        sendingValue,
+        sendingValue: mockSendingValue,
         sender: senderAddress,
         recipient: receiverAddress
       });
-
-      // // todo: wait until this ready to get destination fee. the real receiveAmount is deduce by this fee
-      // const acrossQuote = await getAcrossQuote({
-      //   destinationChain: toChainInfo,
-      //   destinationTokenInfo: toTokenInfo,
-      //   originChain: fromChainInfo,
-      //   originTokenInfo: fromTokenInfo,
-      //   recipient: receiverAddress,
-      //   sender: senderAddress,
-      //   sendingValue,
-      //   feeInfo
-      // });
-
+      const acrossQuote = await (0, _acrossBridge.getAcrossQuote)({
+        destinationChain: toChainInfo,
+        destinationTokenInfo: toTokenInfo,
+        originChain: fromChainInfo,
+        originTokenInfo: fromTokenInfo,
+        recipient: receiverAddress,
+        sender: senderAddress,
+        sendingValue: mockSendingValue,
+        feeInfo
+      });
+      const acrossQuoteMetadata = acrossQuote.metadata;
       const estimatedBridgeFee = await (0, _web.estimateTxFee)(tx, evmApi, feeInfo);
-      const expectedReceive = (0, _bignumber.default)(sendingValue).minus(estimatedBridgeFee).toFixed(0, 1);
+      const estimatedDestinationFee = (0, _bignumber.default)(mockSendingValue).minus(acrossQuoteMetadata.outputAmount).toFixed(0, 1); // todo: should better handle on backend and return desFee metadata instead of minus like this
+
+      let sendingValue;
+      let expectedReceive;
+      if (isBridgeFirst) {
+        expectedReceive = selectedQuote.fromAmount;
+        sendingValue = (0, _bignumber.default)(estimatedDestinationFee).multipliedBy(_utils.FEE_RATE_MULTIPLIER.medium).plus(selectedQuote.fromAmount).toFixed(0, 1);
+      } else if (isBridgeSecond) {
+        expectedReceive = selectedQuote.toAmount;
+        sendingValue = (0, _bignumber.default)(selectedQuote.toAmount).multipliedBy(_utils.DEFAULT_EXCESS_AMOUNT_WEIGHT).toFixed(0, 1);
+      } else {
+        return undefined;
+      }
+      console.log('[i] estimatedBridgeFee', estimatedBridgeFee);
+      console.log('[i] estimatedDestinationFee', estimatedDestinationFee);
       const fee = {
         feeComponent: [{
           feeType: _types.SwapFeeType.NETWORK_FEE,
           amount: estimatedBridgeFee,
-          tokenSlug: (0, _utils2._getChainNativeTokenSlug)(fromChainInfo)
+          tokenSlug: (0, _utils3._getChainNativeTokenSlug)(fromChainInfo)
         }],
-        defaultFeeToken: (0, _utils2._getChainNativeTokenSlug)(fromChainInfo),
-        feeOptions: [(0, _utils2._getChainNativeTokenSlug)(fromChainInfo)]
+        defaultFeeToken: (0, _utils3._getChainNativeTokenSlug)(fromChainInfo),
+        feeOptions: [(0, _utils3._getChainNativeTokenSlug)(fromChainInfo)]
       };
       const step = {
         // @ts-ignore
@@ -479,7 +544,7 @@ class UniswapHandler {
     if (approval) {
       var _priority$options, _priority$options$Fee, _priority$options2;
       const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
-      const priority = await (0, _utils3.calculateGasFeeParams)(evmApi, evmApi.chainSlug);
+      const priority = await (0, _utils4.calculateGasFeeParams)(evmApi, evmApi.chainSlug);
       transactionConfig = {
         from: approval.from,
         to: approval.to,
@@ -511,7 +576,7 @@ class UniswapHandler {
   }
   async approveSpendingBridge(approveStep) {
     const fromAsset = this.chainService.getAssetBySlug(approveStep.tokenApprove);
-    const fromChain = (0, _utils2._getAssetOriginChain)(fromAsset);
+    const fromChain = (0, _utils3._getAssetOriginChain)(fromAsset);
     const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
     const sender = approveStep.owner;
     const sendingValue = approveStep.amount;
@@ -652,7 +717,7 @@ class UniswapHandler {
           submitSwapOrder,
           cronCheckTxSuccess
         },
-        transferNativeAmount: (0, _utils2._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
+        transferNativeAmount: (0, _utils3._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
         extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
         chainType: _KoniTypes.ChainType.EVM,
         isDutch: true
@@ -670,7 +735,7 @@ class UniswapHandler {
       txChain: fromAsset.originChain,
       txData,
       extrinsic: extrinsic,
-      transferNativeAmount: (0, _utils2._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
+      transferNativeAmount: (0, _utils3._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
       extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
       chainType: _KoniTypes.ChainType.EVM
     };
@@ -745,7 +810,7 @@ class UniswapHandler {
     if (swapIndex <= -1) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
-    if (swapXcm && bridgeIndex <= -1) {
+    if ((swapXcm || xcmSwap) && bridgeIndex <= -1) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     if (swap) {
@@ -756,7 +821,7 @@ class UniswapHandler {
       return this.swapBaseHandler.validateSwapXcmProcess(params, swapIndex, bridgeIndex);
     }
     if (xcmSwap) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+      return this.swapBaseHandler.validateXcmSwapProcess(params, swapIndex, bridgeIndex);
     }
     if (xcmSwapXcm) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];

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

@@ -46,7 +46,7 @@ class SwapService {
     var _subwalletApiSdk$swap;
     const availableQuotes = [];
 
-    // hotfix
+    // hotfix // todo: remove later
     const request = {
       ..._request,
       isSupportKyberVersion: true

package/cjs/utils/cardano.js

@@ -3,8 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.convertCardanoHexToBech32 = exports.convertCardanoAddressToHex = void 0;
+exports.validateAddressNetwork = exports.convertCardanoHexToBech32 = exports.convertCardanoAddressToHex = void 0;
 var _cardanoSerializationLibNodejs = require("@emurgo/cardano-serialization-lib-nodejs");
+var _keyring = require("@subwallet/keyring");
 // Copyright 2019-2022 @polkadot/extension authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -17,4 +18,11 @@ const convertCardanoHexToBech32 = hexAddress => {
   const addr = _cardanoSerializationLibNodejs.Address.from_hex(hexAddress);
   return addr.to_bech32();
 };
-exports.convertCardanoHexToBech32 = convertCardanoHexToBech32;
+exports.convertCardanoHexToBech32 = convertCardanoHexToBech32;
+const validateAddressNetwork = (address, chainInfo) => {
+  if (!(chainInfo !== null && chainInfo !== void 0 && chainInfo.cardanoInfo) || !chainInfo.isTestnet) {
+    return (0, _keyring.isCardanoMainnetAddress)(address);
+  }
+  return (0, _keyring.isCardanoTestnetAddress)(address);
+};
+exports.validateAddressNetwork = validateAddressNetwork;

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

@@ -43,6 +43,7 @@ export declare function validationConnectMiddleware(koni: KoniState, url: string
 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 validationAuthCardanoMiddleware(koni: KoniState, url: string, payload: PayloadValidated): Promise<PayloadValidated>;
 export declare function validationCardanoSignDataMiddleware(koni: KoniState, url: string, payload_: PayloadValidated): Promise<PayloadValidated>;
 export declare function convertErrorMessage(message_: string, name?: string): string[];
 export declare function convertErrorFormat(errors: Error[]): ErrorValidation[];

package/core/logic-validation/request.js

@@ -7,10 +7,11 @@ import { EvmProviderError } from '@subwallet/extension-base/background/errors/Ev
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { CardanoProviderErrorType, EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
-import { BN_ZERO, combineEthFee, createPromiseHandler, isSameAddress, stripUrl, wait } from '@subwallet/extension-base/utils';
+import { BN_ZERO, combineEthFee, createPromiseHandler, isSameAddress, reformatAddress, stripUrl, wait } from '@subwallet/extension-base/utils';
+import { validateAddressNetwork } from '@subwallet/extension-base/utils/cardano';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
-import { isCardanoAddress, isSubstrateAddress } from '@subwallet/keyring';
+import { isCardanoAddress, isCardanoBaseAddress, isCardanoRewardAddress, isSubstrateAddress } from '@subwallet/keyring';
 import { keyring } from '@subwallet/ui-keyring';
 import { getSdkError } from '@walletconnect/utils';
 import BigN from 'bignumber.js';
@@ -127,36 +128,33 @@ export async function generateValidationProcess(koni, url, payloadValidate, vali
   }
   return resultValidated;
 }
+function handleAuthError(payload, message, errorPosition, errors) {
+  payload.errorPosition = errorPosition;
+  errors.push(new Error(convertErrorMessage(message)[0]));
+  return payload;
+}
 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));
+    return handleAuthError(payload, 'Not found address to sign', 'dApp', errors);
   } 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));
+        return handleAuthError(payload, 'Unable to find account', 'dApp', errors);
       } 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));
+          return handleAuthError(payload, 'Account not in allowed list', 'dApp', errors);
         }
         payload.authInfo = authInfo;
       }
     } catch (e) {
-      const [message] = convertErrorMessage(e.message);
-      payload.errorPosition = 'dApp';
-      errors.push(new Error(message));
+      return handleAuthError(payload, e.message, 'dApp', errors);
     }
   }
   return payload;
@@ -544,11 +542,51 @@ export function validationAuthWCMiddleware(koni, url, payload, topic) {
   });
   return promise;
 }
+export async function validationAuthCardanoMiddleware(koni, url, payload) {
+  const authList = await koni.getAuthList();
+  const authInfo = authList[stripUrl(url)];
+  const {
+    address,
+    errors
+  } = payload;
+  if (!authInfo || !authInfo.isAllowed) {
+    return handleAuthError(payload, 'Account not in allowed list', 'dApp', errors);
+  }
+  const currentAddress = authInfo.currentAccount;
+  const currentNetwork = authInfo.currentNetworkMap.cardano || 'cardano';
+  const currentNetworkId = +(currentNetwork === 'cardano');
+  if (!currentAddress || !authInfo.isAllowedMap[currentAddress]) {
+    return handleAuthError(payload, 'Unable to find account', 'dApp', errors);
+  }
+  const pair = keyring.getPair(currentAddress);
+  if (!pair) {
+    return handleAuthError(payload, 'Unable to find account', 'dApp', errors);
+  }
+  payload.pair = pair;
+  if (isCardanoBaseAddress(address)) {
+    if (!authInfo.isAllowedMap[address]) {
+      return handleAuthError(payload, 'Account not in allowed list', 'dApp', errors);
+    }
+    const addressByChainFormat = reformatAddress(currentAddress, currentNetworkId);
+    if (!isSameAddress(addressByChainFormat, address)) {
+      return handleAuthError(payload, 'Current account is changed', 'dApp', errors);
+    }
+  } else if (isCardanoRewardAddress(address)) {
+    const rewardAddress = pair.cardano.rewardAddress;
+    const addressByChainFormat = reformatAddress(rewardAddress, currentNetworkId);
+    if (!isSameAddress(addressByChainFormat, address)) {
+      return handleAuthError(payload, 'Current account is changed', 'dApp', errors);
+    }
+  }
+  return payload;
+}
 export async function validationCardanoSignDataMiddleware(koni, url, payload_) {
   const {
     address,
+    authInfo,
     errors,
-    pair: pair_
+    pair: pair_,
+    type
   } = payload_;
   const payload = payload_.payloadAfterValidated;
   const {
@@ -570,6 +608,15 @@ export async function validationCardanoSignDataMiddleware(koni, url, payload_) {
   if (!isCardanoAddress(address)) {
     handleError('Not found cardano address');
   }
+  const currentCardanoNetwork = koni.requestService.getDAppChainInfo({
+    autoActive: true,
+    accessType: 'cardano',
+    defaultChain: authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentNetworkMap[type],
+    url
+  });
+  if (!validateAddressNetwork(address, currentCardanoNetwork)) {
+    handleError('Invalid address network');
+  }
   const pair = pair_ || keyring.getPair(address);
   if (!(pair !== null && pair !== void 0 && pair.meta.isExtneral)) {
     canSign = true;
@@ -577,6 +624,7 @@ export async function validationCardanoSignDataMiddleware(koni, url, payload_) {
   const payloadAfterValidated = {
     address,
     payload: payload,
+    currentAddress: authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentAccount,
     hashPayload: payload,
     canSign: canSign,
     id: ''

package/koni/background/handlers/Extension.d.ts

@@ -59,6 +59,7 @@ export default class KoniExtension {
     private changeAuthorizationAll;
     private _changeAuthorization;
     toggleAuthorization2(url: string): Promise<ResponseAuthorizeList>;
+    private switchCurrentNetworkAuthorization;
     private changeAuthorization;
     private _changeAuthorizationPerAcc;
     private _changeAuthorizationBlock;

package/koni/background/handlers/Extension.js

@@ -36,7 +36,7 @@ import { _isPolygonChainBridge, getClaimPolygonBridge, isClaimedPolygonBridge }
 import { _isPosChainBridge, getClaimPosBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge';
 import { _DEFAULT_MANTA_ZK_CHAIN, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
-import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _isAssetSmartContractNft, _isChainEvmCompatible, _isChainSubstrateCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isNativeTokenBySlug, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByCardano, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _isAssetSmartContractNft, _isChainEnabled, _isChainEvmCompatible, _isChainSubstrateCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isNativeTokenBySlug, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByCardano, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
 import { calculateToAmountByReservePool } from '@subwallet/extension-base/services/fee-service/utils';
 import { batchExtrinsicSetFeeHydration, getAssetHubTokensCanPayFee, getHydrationTokensCanPayFee } from '@subwallet/extension-base/services/fee-service/utils/tokenPayFee';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
@@ -45,7 +45,7 @@ import { isProposalExpired, isSupportWalletConnectChain, isSupportWalletConnectN
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { AccountsStore } from '@subwallet/extension-base/stores';
 import { AccountSignMode, BasicTxErrorType, BasicTxWarningCode, CommonStepType, EarningProcessType, ProcessType, StakingTxErrorType, StepStatus, SwapFeeType, YieldPoolType, YieldStepType } from '@subwallet/extension-base/types';
-import { _analyzeAddress, calculateMaxTransferable, combineAllAccountProxy, createTransactionFromRLP, detectTransferTxType, getAccountSignMode, isSameAddress, MODULE_SUPPORT, reformatAddress, signatureToHex, transformAccounts, transformAddresses, uniqueStringArray } from '@subwallet/extension-base/utils';
+import { _analyzeAddress, calculateMaxTransferable, combineAllAccountProxy, createPromiseHandler, createTransactionFromRLP, detectTransferTxType, getAccountSignMode, isSameAddress, MODULE_SUPPORT, reformatAddress, signatureToHex, transformAccounts, transformAddresses, uniqueStringArray } from '@subwallet/extension-base/utils';
 import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { getKeypairTypeByAddress, isAddress, isCardanoAddress, isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
@@ -648,6 +648,63 @@ export default class KoniExtension {
       });
     });
   }
+  async switchCurrentNetworkAuthorization({
+    authSwitchNetworkType,
+    networkKey,
+    url
+  }) {
+    const authUrls = await this.#koniState.getAuthList();
+    const chainInfo = this.#koniState.chainService.getChainInfoByKey(networkKey);
+    const chainState = this.#koniState.getChainStateByKey(networkKey);
+    const {
+      promise,
+      resolve
+    } = createPromiseHandler();
+    const typeInfoMap = {
+      substrate: 'substrateInfo',
+      evm: 'evmInfo',
+      cardano: 'cardanoInfo',
+      ton: 'tonInfo'
+    };
+    const typeInfoKey = typeInfoMap[authSwitchNetworkType];
+    if (!typeInfoKey || !chainInfo[typeInfoKey]) {
+      throw new Error(t('Network {{networkKey}} is not {{authSwitchNetworkType}}', {
+        replace: {
+          networkKey,
+          authSwitchNetworkType
+        }
+      }));
+    }
+    const authUrl = authUrls[url];
+    if (!authUrl) {
+      throw new Error(t('Not found {{url}} in auth list', {
+        replace: {
+          url
+        }
+      }));
+    }
+    if (chainInfo && !_isChainEnabled(chainState)) {
+      await this.enableChainWithPriorityAssets({
+        chainSlug: networkKey,
+        enableTokens: true
+      });
+    }
+    if (!authUrl.accountAuthTypes.includes(authSwitchNetworkType)) {
+      throw new Error(t('Network {{networkKey}} is not supported by {{authSwitchNetworkType}}', {
+        replace: {
+          networkKey,
+          authSwitchNetworkType
+        }
+      }));
+    }
+    authUrl.currentNetworkMap[authSwitchNetworkType] = networkKey;
+    this.#koniState.setAuthorize(authUrls, () => {
+      resolve({
+        list: authUrls
+      });
+    });
+    return promise;
+  }
   changeAuthorization(data, id, port) {
     const cb = createSubscription(id, port);
     this._changeAuthorization(data.url, data.connectValue, items => {
@@ -4255,6 +4312,8 @@ export default class KoniExtension {
         return this.getAuthListV2();
       case 'pri(authorize.toggle)':
         return this.toggleAuthorization2(request);
+      case 'pri(authorize.switchCurrentNetwork)':
+        return this.switchCurrentNetworkAuthorization(request);
       case 'pri(settings.changeBalancesVisibility)':
         return await this.toggleBalancesVisibility();