@subwallet/extension-base 1.3.35-0 → 1.3.37-0

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

@@ -207,6 +207,22 @@ class TransactionService {
       extrinsicHash: transactionId
     };
   }
+  fillDutchTransactionDefaultInfo(transaction) {
+    const isInternal = !transaction.url;
+    const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, isInternal, (0, _helpers2.isWalletConnectRequest)(transaction.id));
+    return {
+      ...transaction,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime(),
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      url: transaction.url || _constants2.EXTENSION_REQUEST_URL,
+      status: _KoniTypes.ExtrinsicStatus.QUEUED,
+      isInternal,
+      id: transactionId,
+      extrinsicHash: transactionId
+    };
+  }
   async addTransaction(inputTransaction) {
     const transactions = this.transactions;
     // Fill transaction default info
@@ -219,6 +235,15 @@ class TransactionService {
     });
     return await this.sendTransaction(transaction);
   }
+  addDutchTransaction(inputTransaction) {
+    const transactions = this.transactions;
+    const transaction = this.fillDutchTransactionDefaultInfo(inputTransaction);
+    transactions[transaction.id] = transaction;
+    this.transactionSubject.next({
+      ...transactions
+    });
+    return this.sendDutchTransaction(transaction);
+  }
   generateBeforeHandleResponseErrors(errors) {
     return {
       errors,
@@ -334,6 +359,62 @@ class TransactionService {
     'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
     return validatedTransaction;
   }
+  async handleDutchTransaction(transaction) {
+    var _transaction$step2;
+    const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, true);
+    const validatedTransaction = {
+      ...transaction,
+      id: transactionId,
+      extrinsicHash: '',
+      status: undefined,
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      processId: (_transaction$step2 = transaction.step) === null || _transaction$step2 === void 0 ? void 0 : _transaction$step2.processId
+    };
+    const txInput = {
+      ...transaction,
+      isInternal: true,
+      status: _KoniTypes.ExtrinsicStatus.QUEUED,
+      id: transactionId,
+      extrinsicHash: transactionId,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime()
+    };
+    const emitter = this.addDutchTransaction(txInput);
+    await new Promise(resolve => {
+      if (transaction.resolveOnDone) {
+        emitter.on('success', data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        });
+      } else {
+        emitter.on('signed', data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        });
+      }
+      emitter.on('error', data => {
+        if (data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+      emitter.on('timeout', data => {
+        if (transaction.errorOnTimeOut && data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+    });
+
+    // @ts-ignore
+    'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+    'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+    'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+    return validatedTransaction;
+  }
   async sendTransaction(transaction) {
     // Send Transaction
     const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : this.signAndSendTonTransaction(transaction));
@@ -381,10 +462,7 @@ class TransactionService {
       if (step) {
         const rejectError = data.errors.find(error => {
           // TODO: REFACTOR ERROR CODE
-          if ([_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType)) {
-            return true;
-          }
-          return false;
+          return [_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
         });
 
         /**
@@ -457,10 +535,7 @@ class TransactionService {
       if (step) {
         const rejectError = data.errors.find(error => {
           // TODO: REFACTOR ERROR CODE
-          if ([_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType)) {
-            return true;
-          }
-          return false;
+          return [_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
         });
 
         /**
@@ -482,6 +557,83 @@ class TransactionService {
     eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
     return emitter;
   }
+  sendDutchTransaction(transaction) {
+    // Send Transaction
+    const emitter = this.signAndSendEvmDutchTransaction(transaction);
+    const {
+      eventsHandler,
+      step
+    } = transaction;
+    emitter.on('send', data => {
+      this.onSend(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          transactionId: transaction.id,
+          status: _types.StepStatus.SUBMITTING,
+          chain: transaction.chain
+        });
+      }
+    });
+    emitter.on('extrinsicHash', data => {
+      this.onHasTransactionHash(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          extrinsicHash: data.extrinsicHash,
+          status: _types.StepStatus.PROCESSING
+        });
+      }
+    });
+    emitter.on('success', data => {
+      this.handlePostProcessing(data.id);
+      this.onSuccess(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: _types.StepStatus.COMPLETE
+        });
+      }
+    });
+    emitter.on('error', data => {
+      // this.handlePostProcessing(data.id); // might enable this later
+      this.onFailed({
+        ...data,
+        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
+      });
+      if (step) {
+        const rejectError = data.errors.find(error => {
+          // TODO: REFACTOR ERROR CODE
+          return [_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
+        });
+
+        /**
+         * Now simple check, first step have step id = 1.
+         * Improve to fetch the process from db
+         * */
+        if (rejectError && step.stepId === 1) {
+          this.deleteProcess(step);
+        } else {
+          this.updateProcessStepStatus(step, {
+            status: _types.StepStatus.FAILED
+          });
+        }
+      }
+    });
+    emitter.on('timeout', data => {
+      this.onTimeOut({
+        ...data,
+        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.TIMEOUT)]
+      });
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: _types.StepStatus.TIMEOUT
+        });
+      }
+    });
+
+    // Todo: handle any event with transaction.eventsHandler
+
+    eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
+    return emitter;
+  }
   removeTransaction(id) {
     if (this.transactions[id]) {
       delete this.transactions[id];
@@ -505,7 +657,7 @@ class TransactionService {
     return (0, _utils3.getExplorerLink)(chainInfo, transaction.extrinsicHash, 'tx');
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
-    var _transaction$step2;
+    var _transaction$step3;
     const transaction = this.getTransaction(id);
     const extrinsicType = transaction.extrinsicType;
     const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
@@ -530,7 +682,7 @@ class TransactionService {
       // Will be added in next step
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
       startBlock: startBlock || 0,
-      processId: (_transaction$step2 = transaction.step) === null || _transaction$step2 === void 0 ? void 0 : _transaction$step2.processId
+      processId: (_transaction$step3 = transaction.step) === null || _transaction$step3 === void 0 ? void 0 : _transaction$step3.processId
     };
     const nativeAsset = (0, _utils2._getChainNativeTokenBasicInfo)(chainInfo);
     const baseNativeAmount = {
@@ -1369,7 +1521,79 @@ class TransactionService {
     });
     return emitter;
   }
-  signAndSendSubstrateTransaction(_ref12) {
+  signAndSendEvmDutchTransaction(_ref12) {
+    let {
+      address,
+      id,
+      isPassConfirmation,
+      step,
+      transaction,
+      url
+    } = _ref12;
+    const emitter = new _eventemitter.default();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+
+    // todo: review this object
+    const evmSignaturePayload = {
+      id: id,
+      type: 'eth_signTypedData_v4',
+      payload: transaction,
+      address: address,
+      hashPayload: '',
+      canSign: true,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+    this.state.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'submitApiRequest', evmSignaturePayload, {
+      isPassConfirmation
+    }).then(_ref13 => {
+      let {
+        isApproved,
+        payload: signature
+      } = _ref13;
+      if (isApproved) {
+        emitter.emit('signed', eventData);
+        emitter.emit('send', eventData);
+        transaction.submitSwapOrder().then(isSendSuccess => {
+          if (!isSendSuccess) {
+            throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, (0, _i18next.t)('Failed to sign'));
+          }
+          this.handleTransactionTimeout(emitter, eventData);
+          transaction.cronCheckTxSuccess().then(order => {
+            if (!order) {
+              eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED));
+              emitter.emit('error', eventData);
+            } else {
+              eventData.extrinsicHash = order.txHash;
+              emitter.emit('extrinsicHash', eventData);
+              emitter.emit('success', eventData);
+            }
+          }).catch(e => {
+            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
+            emitter.emit('error', eventData);
+          });
+        }).catch(e => {
+          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
+          emitter.emit('error', eventData);
+        });
+      } else {
+        this.removeTransaction(id);
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+        emitter.emit('error', eventData);
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+  signAndSendSubstrateTransaction(_ref14) {
     var _this$state$chainServ;
     let {
       address,
@@ -1381,7 +1605,7 @@ class TransactionService {
       tokenPayFeeSlug,
       transaction,
       url
-    } = _ref12;
+    } = _ref14;
     const tip = (feeCustom === null || feeCustom === void 0 ? void 0 : feeCustom.tip) || '0';
     const feeAssetId = tokenPayFeeSlug && !(0, _utils2._isNativeTokenBySlug)(tokenPayFeeSlug) && _constants._SUPPORT_TOKEN_PAY_FEE_GROUP.assetHub.includes(chain) ? (_this$state$chainServ = this.state.chainService.getAssetBySlug(tokenPayFeeSlug).metadata) === null || _this$state$chainServ === void 0 ? void 0 : _this$state$chainServ.multilocation : undefined;
     const emitter = new _eventemitter.default();
@@ -1470,20 +1694,20 @@ class TransactionService {
             if (!eventData.extrinsicHash) {
               eventData.extrinsicHash = txState.txHash.toHex();
             }
-            txState.events.filter(_ref13 => {
+            txState.events.filter(_ref15 => {
               let {
                 event: {
                   section
                 }
-              } = _ref13;
+              } = _ref15;
               return section === 'system';
-            }).forEach(_ref14 => {
+            }).forEach(_ref16 => {
               let {
                 event: {
                   data: [error],
                   method
                 }
-              } = _ref14;
+              } = _ref16;
               if (method === 'ExtrinsicFailed') {
                 eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
                 emitter.emit('error', eventData);
@@ -1506,7 +1730,7 @@ class TransactionService {
     });
     return emitter;
   }
-  signAndSendTonTransaction(_ref15) {
+  signAndSendTonTransaction(_ref17) {
     let {
       address,
       chain,
@@ -1515,7 +1739,7 @@ class TransactionService {
       step,
       transaction,
       url
-    } = _ref15;
+    } = _ref17;
     const walletContract = _uiKeyring.default.getPair(address).ton.currentContract;
     const emitter = new _eventemitter.default();
     const eventData = {
@@ -1532,11 +1756,11 @@ class TransactionService {
           ...payload,
           messagePayload: (0, _utils.cellToBase64Str)(message),
           messages: []
-        }, {}).then(_ref16 => {
+        }, {}).then(_ref18 => {
           let {
             isApproved,
             payload
-          } = _ref16;
+          } = _ref18;
           if (!isApproved) {
             this.removeTransaction(id);
             eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
@@ -1571,8 +1795,8 @@ class TransactionService {
         if (!externalMsgHash) {
           return;
         }
-        tonApi.getStatusByExtMsgHash(externalMsgHash, extrinsicType).then(_ref17 => {
-          let [status, hex] = _ref17;
+        tonApi.getStatusByExtMsgHash(externalMsgHash, extrinsicType).then(_ref19 => {
+          let [status, hex] = _ref19;
           if (status && hex) {
             eventData.extrinsicHash = hex;
             emitter.emit('extrinsicHash', eventData);
@@ -1601,13 +1825,13 @@ class TransactionService {
     });
     return emitter;
   }
-  signAndSendCardanoTransaction(_ref18) {
+  signAndSendCardanoTransaction(_ref20) {
     let {
       chain,
       id,
       transaction,
       url
-    } = _ref18;
+    } = _ref20;
     const emitter = new _eventemitter.default();
     const eventData = {
       id,
@@ -1617,11 +1841,11 @@ class TransactionService {
     };
     const transactionConfig = transaction;
     const cardanoApi = this.state.chainService.getCardanoApi(chain);
-    this.state.requestService.addConfirmationCardano(id, url || _constants2.EXTENSION_REQUEST_URL, 'cardanoSendTransactionRequest', transactionConfig, {}).then(_ref19 => {
+    this.state.requestService.addConfirmationCardano(id, url || _constants2.EXTENSION_REQUEST_URL, 'cardanoSendTransactionRequest', transactionConfig, {}).then(_ref21 => {
       let {
         isApproved,
         payload
-      } = _ref19;
+      } = _ref21;
       if (!isApproved) {
         this.removeTransaction(id);
         eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
@@ -1812,9 +2036,9 @@ class TransactionService {
     }
   }
   async createProcessNotification(transactionId) {
-    var _transaction$step3;
+    var _transaction$step4;
     const transaction = this.getTransaction(transactionId);
-    if (transaction && (_transaction$step3 = transaction.step) !== null && _transaction$step3 !== void 0 && _transaction$step3.processId) {
+    if (transaction && (_transaction$step4 = transaction.step) !== null && _transaction$step4 !== void 0 && _transaction$step4.processId) {
       const process = this.aliveProcessMap.get(transaction.step.processId);
       if (process) {
         await this.state.inappNotificationService.createProcessNotification(process);

package/cjs/types/swap/index.js

@@ -42,13 +42,14 @@ exports.SwapProviderId = SwapProviderId;
   SwapProviderId["WESTEND_ASSET_HUB"] = "WESTEND_ASSET_HUB";
   SwapProviderId["SIMPLE_SWAP"] = "SIMPLE_SWAP";
   SwapProviderId["UNISWAP"] = "UNISWAP";
+  SwapProviderId["KYBER"] = "KYBER";
 })(SwapProviderId || (exports.SwapProviderId = SwapProviderId = {}));
 const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET,
 // SwapProviderId.HYDRADX_TESTNET,
 SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB,
 // SwapProviderId.ROCOCO_ASSET_HUB,
 // SwapProviderId.WESTEND_ASSET_HUB,
-SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP];
+SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP, SwapProviderId.KYBER];
 exports._SUPPORTED_SWAP_PROVIDERS = _SUPPORTED_SWAP_PROVIDERS;
 // process handling
 let SwapFeeType;

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.js

@@ -8,6 +8,7 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 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 { 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';
@@ -547,8 +548,10 @@ export function validationAuthWCMiddleware(koni, url, payload, topic) {
 export async function validationCardanoSignDataMiddleware(koni, url, payload_) {
   const {
     address,
+    authInfo,
     errors,
-    pair: pair_
+    pair: pair_,
+    type
   } = payload_;
   const payload = payload_.payloadAfterValidated;
   const {
@@ -570,6 +573,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;

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 => {
@@ -2720,6 +2777,7 @@ export default class KoniExtension {
   getTransaction({
     id
   }) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const {
       transaction,
       ...transactionResult
@@ -2730,6 +2788,7 @@ export default class KoniExtension {
     const cb = createSubscription(id, port);
     function convertRs(rs, processMap) {
       return Object.fromEntries(Object.entries(rs).map(([key, value]) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const {
           additionalValidator,
           eventsHandler,
@@ -3767,6 +3826,7 @@ export default class KoniExtension {
       chainType,
       extrinsic,
       extrinsicType,
+      isDutch,
       isPermit,
       transferNativeAmount,
       txChain,
@@ -3823,6 +3883,24 @@ export default class KoniExtension {
         step
       });
     }
+    if (isDutch) {
+      return await this.#koniState.transactionService.handleDutchTransaction({
+        address,
+        chain: txChain,
+        transaction: extrinsic,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        data: txData,
+        extrinsicType,
+        // change this depends on step
+        chainType,
+        resolveOnDone: !isLastStep,
+        transferNativeAmount,
+        ...this.createPassConfirmationParams(isPassConfirmation),
+        errorOnTimeOut,
+        eventsHandler,
+        step
+      });
+    }
     return await this.#koniState.transactionService.handleTransaction({
       address,
       chain: txChain,
@@ -4234,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();