@subwallet/extension-base 1.3.72-0 → 1.3.74-0

package/cjs/koni/background/handlers/Extension.js

@@ -47,29 +47,32 @@ var _types3 = require("@subwallet/extension-base/services/chain-service/types");
 var _utils6 = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils7 = require("@subwallet/extension-base/services/fee-service/utils");
 var _tokenPayFee = require("@subwallet/extension-base/services/fee-service/utils/tokenPayFee");
+var _utils8 = require("@subwallet/extension-base/services/multisig-service/utils");
 var _constants3 = require("@subwallet/extension-base/services/request-service/constants");
 var _constants4 = require("@subwallet/extension-base/services/setting-service/constants");
+var _substrateProxyService = require("@subwallet/extension-base/services/substrate-proxy-service");
+var _types4 = require("@subwallet/extension-base/services/transaction-service/types");
 var _helpers2 = require("@subwallet/extension-base/services/wallet-connect-service/helpers");
 var _storage = require("@subwallet/extension-base/storage");
 var _stores = require("@subwallet/extension-base/stores");
-var _types4 = require("@subwallet/extension-base/types");
-var _utils8 = require("@subwallet/extension-base/utils");
+var _types5 = require("@subwallet/extension-base/types");
+var _utils9 = require("@subwallet/extension-base/utils");
 var _parseTransaction2 = require("@subwallet/extension-base/utils/eth/parseTransaction");
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _keyring = require("@subwallet/keyring");
-var _types5 = require("@subwallet/keyring/types");
-var _utils9 = require("@subwallet/keyring/utils");
+var _types6 = require("@subwallet/keyring/types");
+var _utils0 = require("@subwallet/keyring/utils");
 var _validate = require("@subwallet/keyring/utils/address/validate");
 var _uiKeyring = require("@subwallet/ui-keyring");
-var _utils0 = require("@walletconnect/utils");
+var _utils1 = require("@walletconnect/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var bitcoin = _interopRequireWildcard(require("bitcoinjs-lib"));
 var _i18next = require("i18next");
 var _rxjs = require("rxjs");
-var _types6 = require("@polkadot/types");
+var _types7 = require("@polkadot/types");
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
-var _utils1 = require("../utils");
+var _utils10 = require("../utils");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -217,7 +220,7 @@ class KoniExtension {
     const {
       reject
     } = queued;
-    reject(new _TransactionError.TransactionError(_types4.BasicTxErrorType.USER_REJECT_REQUEST));
+    reject(new _TransactionError.TransactionError(_types5.BasicTxErrorType.USER_REJECT_REQUEST));
     return true;
   }
 
@@ -285,7 +288,7 @@ class KoniExtension {
     const accounts = keyringService.context.accounts;
     const transformedAccounts = Object.values(accounts);
     const responseData = {
-      accounts: transformedAccounts !== null && transformedAccounts !== void 0 && transformedAccounts.length ? [(0, _utils8.combineAllAccountProxy)(transformedAccounts), ...transformedAccounts] : [],
+      accounts: transformedAccounts !== null && transformedAccounts !== void 0 && transformedAccounts.length ? [(0, _utils9.combineAllAccountProxy)(transformedAccounts), ...transformedAccounts] : [],
       currentAccountProxy: currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.proxyId
     };
     const accountProxyMapObservable = keyringService.context.observable.accounts;
@@ -299,7 +302,7 @@ class KoniExtension {
         currentAccount
       } = _ref7;
       const transformedAccounts = Object.values(accountProxies);
-      responseData.accounts = transformedAccounts !== null && transformedAccounts !== void 0 && transformedAccounts.length ? [(0, _utils8.combineAllAccountProxy)(transformedAccounts), ...transformedAccounts] : [];
+      responseData.accounts = transformedAccounts !== null && transformedAccounts !== void 0 && transformedAccounts.length ? [(0, _utils9.combineAllAccountProxy)(transformedAccounts), ...transformedAccounts] : [];
       responseData.currentAccountProxy = currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.proxyId;
       cb(responseData);
     });
@@ -321,29 +324,29 @@ class KoniExtension {
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const combineFunction = async (chainInfoMap, tokenInfoMap, accountProxyMap, _contacts) => {
       const accountProxies = Object.values(accountProxyMap);
-      const contacts = (0, _utils8.transformAddresses)(_contacts);
+      const contacts = (0, _utils9.transformAddresses)(_contacts);
       const chainInfo = chainInfoMap[chain];
       const tokenInfo = tokenInfoMap[token || ''];
       const substrateApi = this.#koniState.chainService.getSubstrateApi(chain);
       const accountProxiesFiltered = accountProxies.filter(accountProxy => {
         var _accountProxy$account;
         const signMode = (_accountProxy$account = accountProxy.accounts[0]) === null || _accountProxy$account === void 0 ? void 0 : _accountProxy$account.signMode;
-        if (signMode === _types4.AccountSignMode.GENERIC_LEDGER) {
-          if (accountProxy.chainTypes.includes(_types4.AccountChainType.ETHEREUM)) {
+        if (signMode === _types5.AccountSignMode.GENERIC_LEDGER) {
+          if (accountProxy.chainTypes.includes(_types5.AccountChainType.ETHEREUM)) {
             return (0, _utils6._isChainCompatibleLedgerEvm)(chainInfo);
           }
         }
-        if (signMode === _types4.AccountSignMode.ECDSA_SUBSTRATE_LEDGER) {
+        if (signMode === _types5.AccountSignMode.ECDSA_SUBSTRATE_LEDGER) {
           if (actionType === _types2.ActionType.SEND_NFT) {
             return false;
           }
           if (tokenInfo) {
-            return (0, _utils8.isSubstrateEcdsaLedgerAssetSupported)(tokenInfo, chainInfo);
+            return (0, _utils9.isSubstrateEcdsaLedgerAssetSupported)(tokenInfo, chainInfo);
           }
         }
         return true;
       });
-      const rs = await (0, _utils8._analyzeAddress)(data, accountProxiesFiltered, contacts, chainInfo, substrateApi);
+      const rs = await (0, _utils9._analyzeAddress)(data, accountProxiesFiltered, contacts, chainInfo, substrateApi);
       return {
         id,
         ...rs
@@ -387,7 +390,7 @@ class KoniExtension {
     const _cb = (0, _subscriptions.createSubscription)(id, port);
     let old = '';
     const subscription = this.#koniState.keyringService.context.observable.contacts.subscribe(subjectInfo => {
-      const addresses = (0, _utils8.transformAddresses)(subjectInfo);
+      const addresses = (0, _utils9.transformAddresses)(subjectInfo);
       const _new = JSON.stringify(addresses);
       if (old !== _new) {
         _cb({
@@ -404,7 +407,7 @@ class KoniExtension {
     });
     const subjectInfo = this.#koniState.keyringService.context.contacts;
     return {
-      addresses: (0, _utils8.transformAccounts)(subjectInfo)
+      addresses: (0, _utils9.transformAccounts)(subjectInfo)
     };
   }
 
@@ -417,7 +420,7 @@ class KoniExtension {
       chain
     } = _ref9;
     if ((0, _keyring.isAddress)(accountId)) {
-      const address = (0, _utils8.reformatAddress)(accountId);
+      const address = (0, _utils9.reformatAddress)(accountId);
       const account = _uiKeyring.keyring.getAccount(address);
       const contact = _uiKeyring.keyring.getAddress(address, 'address');
       if (account) {
@@ -463,7 +466,7 @@ class KoniExtension {
       meta
     } = _ref0;
     if ((0, _keyring.isAddress)(address)) {
-      const _address = (0, _utils8.reformatAddress)(address);
+      const _address = (0, _utils9.reformatAddress)(address);
       _uiKeyring.keyring.saveAddress(_address, meta);
       return true;
     } else {
@@ -479,7 +482,7 @@ class KoniExtension {
       address
     } = _ref1;
     if ((0, _keyring.isAddress)(address)) {
-      const _address = (0, _utils8.reformatAddress)(address);
+      const _address = (0, _utils9.reformatAddress)(address);
       _uiKeyring.keyring.forgetAddress(_address);
       return true;
     } else {
@@ -608,16 +611,16 @@ class KoniExtension {
   }
   getPairs() {
     const storedAccounts = this.#koniState.keyringService.context.pairs;
-    return (0, _utils8.transformAccounts)(storedAccounts);
+    return (0, _utils9.transformAccounts)(storedAccounts);
   }
   isAddressValidWithAuthType(address, accountAuthTypes) {
     const type = (0, _keyring.getKeypairTypeByAddress)(address);
     const validTypes = {
-      evm: _types5.EthereumKeypairTypes,
-      substrate: _types5.AllSubstrateKeypairTypes,
-      ton: _types5.TonKeypairTypes,
-      cardano: _types5.CardanoKeypairTypes,
-      bitcoin: _types5.BitcoinKeypairTypes
+      evm: _types6.EthereumKeypairTypes,
+      substrate: _types6.AllSubstrateKeypairTypes,
+      ton: _types6.TonKeypairTypes,
+      cardano: _types6.CardanoKeypairTypes,
+      bitcoin: _types6.BitcoinKeypairTypes
     };
     return !!accountAuthTypes && accountAuthTypes.some(authType => {
       var _validTypes$authType;
@@ -727,7 +730,7 @@ class KoniExtension {
     const {
       promise,
       resolve
-    } = (0, _utils8.createPromiseHandler)();
+    } = (0, _utils9.createPromiseHandler)();
     const typeInfoMap = {
       substrate: 'substrateInfo',
       evm: 'evmInfo',
@@ -1238,7 +1241,7 @@ class KoniExtension {
       const addresses = _uiKeyring.keyring.getAccounts().map(a => a.address);
 
       // Re-filter
-      cb(histories.filter(item => addresses.some(address => (0, _utils8.isSameAddress)(item.address, address))));
+      cb(histories.filter(item => addresses.some(address => (0, _utils9.isSameAddress)(item.address, address))));
     });
     this.createUnsubscriptionHandle(id, subscription.unsubscribe);
     port.onDisconnect.addListener(() => {
@@ -1247,7 +1250,7 @@ class KoniExtension {
     const addresses = _uiKeyring.keyring.getAccounts().map(a => a.address);
 
     // Re-filter
-    return historySubject.getValue().filter(item => addresses.some(address => (0, _utils8.isSameAddress)(item.address, address)));
+    return historySubject.getValue().filter(item => addresses.some(address => (0, _utils9.isSameAddress)(item.address, address)));
   }
   subscribeHistoryByChainAndAddress(_ref30, id, port) {
     let {
@@ -1304,7 +1307,6 @@ class KoniExtension {
       feeCustom,
       feeOption,
       from,
-      signerSubstrateProxyAddress,
       to,
       tokenPayFeeSlug,
       tokenSlug,
@@ -1474,10 +1476,10 @@ class KoniExtension {
       if (isCustomTokenPayFeeAssetHub || isCustomTokenPayFeeHydration) {
         var _inputTransaction$est, _nonNativeTokenPayFee;
         const nonNativeFee = BigInt(((_inputTransaction$est = inputTransaction.estimateFee) === null || _inputTransaction$est === void 0 ? void 0 : _inputTransaction$est.value) || '0'); // todo: estimateFee should be must-have, need to refactor interface
-        const nonNativeTokenPayFeeInfo = await this.#koniState.balanceService.getTokensHasBalance((0, _utils8.reformatAddress)(from), chain, tokenPayFeeSlug);
+        const nonNativeTokenPayFeeInfo = await this.#koniState.balanceService.getTokensHasBalance((0, _utils9.reformatAddress)(from), chain, tokenPayFeeSlug);
         const nonNativeTokenPayFeeBalance = BigInt(((_nonNativeTokenPayFee = nonNativeTokenPayFeeInfo[tokenPayFeeSlug]) === null || _nonNativeTokenPayFee === void 0 ? void 0 : _nonNativeTokenPayFee.free) || '0');
         if (nonNativeFee > nonNativeTokenPayFeeBalance) {
-          inputTransaction.errors.push(new _TransactionError.TransactionError(_types4.BasicTxErrorType.NOT_ENOUGH_BALANCE));
+          inputTransaction.errors.push(new _TransactionError.TransactionError(_types5.BasicTxErrorType.NOT_ENOUGH_BALANCE));
         }
       }
 
@@ -1516,10 +1518,10 @@ class KoniExtension {
     };
     const ignoreWarnings = [];
     if (transferAll) {
-      ignoreWarnings.push(_types4.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+      ignoreWarnings.push(_types5.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
     }
     if (transferBounceable) {
-      ignoreWarnings.push(_types4.BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS);
+      ignoreWarnings.push(_types5.BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS);
     }
     return this.#koniState.transactionService.handleTransaction({
       errors,
@@ -1538,7 +1540,6 @@ class KoniExtension {
       isTransferAll: isTransferNativeToken ? transferAll : false,
       isTransferLocalTokenAndPayThatTokenAsFee,
       edAsWarning: isTransferNativeToken,
-      signerSubstrateProxyAddress,
       additionalValidator: additionalValidator
     });
   }
@@ -1550,7 +1551,6 @@ class KoniExtension {
       from,
       isPassConfirmation,
       originNetworkKey,
-      signerSubstrateProxyAddress,
       to,
       tokenPayFeeSlug,
       tokenSlug,
@@ -1701,7 +1701,7 @@ class KoniExtension {
         if (isSubstrateXcm) {
           const isDryRunSuccess = await (0, _xcm.dryRunXcmExtrinsicV2)(params, false);
           if (!isDryRunSuccess) {
-            inputTransaction.errors.push(new _TransactionError.TransactionError(_types4.BasicTxErrorType.UNABLE_TO_SEND, 'Unable to perform transaction. Select another token or destination chain and try again'));
+            inputTransaction.errors.push(new _TransactionError.TransactionError(_types5.BasicTxErrorType.UNABLE_TO_SEND, 'Unable to perform transaction. Select another token or destination chain and try again'));
           }
         }
       };
@@ -1724,10 +1724,10 @@ class KoniExtension {
     }
     const ignoreWarnings = [];
     if (transferAll) {
-      ignoreWarnings.push(_types4.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+      ignoreWarnings.push(_types5.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
     }
     if (transferBounceable) {
-      ignoreWarnings.push(_types4.BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS);
+      ignoreWarnings.push(_types5.BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS);
     }
     return await this.#koniState.transactionService.handleTransaction({
       url: _constants3.EXTENSION_REQUEST_URL,
@@ -1746,8 +1746,7 @@ class KoniExtension {
       xcmFeeDryRun,
       errors,
       additionalValidator: additionalValidator,
-      eventsHandler: eventsHandler,
-      signerSubstrateProxyAddress
+      eventsHandler: eventsHandler
     });
   }
   async makeBitcoinDappTransferConfirmation(inputData) {
@@ -1862,7 +1861,7 @@ class KoniExtension {
       if (!address || !amount) {
         return total;
       }
-      if ((0, _utils8.isSameAddress)(address, from)) {
+      if ((0, _utils9.isSameAddress)(address, from)) {
         inputAmount = new _bignumber.default(amount);
       }
       return total.plus(new _bignumber.default(amount || 0));
@@ -1945,7 +1944,7 @@ class KoniExtension {
     } = request;
     const chainService = this.#koniState.chainService;
     const substrateApi = this.#koniState.getSubstrateApi(chain);
-    const address = (0, _utils8.reformatAddress)(_address);
+    const address = (0, _utils9.reformatAddress)(_address);
     const tokensHasBalanceInfoMap = await this.#koniState.balanceService.getTokensHasBalance(address, chain);
     const nativeTokenInfo = chainService.getNativeTokenInfo(chain);
     const nativeBalanceInfo = {
@@ -2234,7 +2233,7 @@ class KoniExtension {
     const extrinsicType = srcChain.slug !== destChain.slug ? _KoniTypes.ExtrinsicType.TRANSFER_XCM : _KoniTypes.ExtrinsicType.TRANSFER_BALANCE;
     const freeBalanceSubject = new _rxjs.Subject();
     const feeSubject = new _rxjs.Subject();
-    const feeChainType = (0, _utils8.detectTransferTxType)(srcToken, srcChain, destChain);
+    const feeChainType = (0, _utils9.detectTransferTxType)(srcToken, srcChain, destChain);
     if (!destToken) {
       throw new Error('Destination token not found');
     }
@@ -2268,12 +2267,12 @@ class KoniExtension {
           fee,
           freeBalance
         } = _ref39;
-        (0, _utils8.calculateMaxTransferable)(id, _request, freeBalance, fee).then(cb).catch(console.error);
+        (0, _utils9.calculateMaxTransferable)(id, _request, freeBalance, fee).then(cb).catch(console.error);
       }
     });
     const [unsubBalance, freeBalance] = await (async () => {
       try {
-        return await this.#koniState.balanceService.subscribeBalance(address, chain, token, _types4.BalanceType.TRANSFERABLE, extrinsicType, data => {
+        return await this.#koniState.balanceService.subscribeBalance(address, chain, token, _types5.BalanceType.TRANSFERABLE, extrinsicType, data => {
           freeBalanceSubject.next(data); // Must be called after subscription
         });
       } catch (e) {
@@ -2298,7 +2297,7 @@ class KoniExtension {
     port.onDisconnect.addListener(() => {
       this.cancelSubscription(id);
     });
-    return (0, _utils8.calculateMaxTransferable)(id, _request, freeBalance, fee);
+    return (0, _utils9.calculateMaxTransferable)(id, _request, freeBalance, fee);
   }
   async subscribeTransferableWhenConfirmation(_ref40, id, port) {
     let {
@@ -2325,19 +2324,19 @@ class KoniExtension {
       try {
         const _fee = fee;
         const _feeCustom = feeCustom;
-        const combineFee = (0, _utils8.combineBitcoinFee)(_fee, _feeOptions, _feeCustom);
+        const combineFee = (0, _utils9.combineBitcoinFee)(_fee, _feeOptions, _feeCustom);
         const bitcoinApi = this.#koniState.chainService.getBitcoinApi(chain);
-        let utxos = await (0, _utils8.getTransferableBitcoinUtxos)(bitcoinApi, address);
+        let utxos = await (0, _utils9.getTransferableBitcoinUtxos)(bitcoinApi, address);
         const recipients = [address, to || address];
         utxos = utxos.sort((a, b) => b.value - a.value);
-        const filteredUtxos = (0, _utils8.filterUneconomicalUtxos)({
+        const filteredUtxos = (0, _utils9.filterUneconomicalUtxos)({
           utxos,
           feeRate: combineFee.feeRate,
           recipients,
           sender: address
         });
         for (const utxo of filteredUtxos) {
-          sizeInfo = (0, _utils8.getSizeInfo)({
+          sizeInfo = (0, _utils9.getSizeInfo)({
             inputLength: neededUtxos.length,
             sender: address,
             recipients
@@ -2351,13 +2350,13 @@ class KoniExtension {
         }
 
         // re calculate
-        sizeInfo = (0, _utils8.getSizeInfo)({
+        sizeInfo = (0, _utils9.getSizeInfo)({
           inputLength: neededUtxos.length,
           sender: address,
           recipients
         });
         if (!sizeInfo) {
-          sizeInfo = (0, _utils8.getSizeInfo)({
+          sizeInfo = (0, _utils9.getSizeInfo)({
             inputLength: utxos.length || 1,
             sender: address,
             recipients
@@ -2368,10 +2367,10 @@ class KoniExtension {
         if (amountLeft.lte(0)) {
           error = 'Insufficient balance';
         } else {
-          const senderAddressInfo = (0, _utils9.getBitcoinAddressInfo)(address);
+          const senderAddressInfo = (0, _utils0.getBitcoinAddressInfo)(address);
           const dustLimit = _constants.BTC_DUST_AMOUNT[senderAddressInfo.type] || 546;
           if (amountLeft.lte(dustLimit)) {
-            sizeInfo = (0, _utils8.getSizeInfo)({
+            sizeInfo = (0, _utils9.getSizeInfo)({
               inputLength: neededUtxos.length,
               sender: address,
               recipients: [to || address]
@@ -2413,7 +2412,7 @@ class KoniExtension {
         convertData(freeBalance, fee, _feeOptions, feeCustom).then(cb).catch(console.error);
       }
     });
-    const [unsubBalance, freeBalance] = await this.#koniState.balanceService.subscribeBalance(address, chain, token, _types4.BalanceType.TRANSFERABLE, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE, data => {
+    const [unsubBalance, freeBalance] = await this.#koniState.balanceService.subscribeBalance(address, chain, token, _types5.BalanceType.TRANSFERABLE, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE, data => {
       freeBalanceSubject.next(data); // Must be called after subscription
     });
     const fee = await this.#koniState.feeService.subscribeChainFee(id, chain, feeType, data => {
@@ -2485,8 +2484,7 @@ class KoniExtension {
     const {
       params,
       recipientAddress,
-      senderAddress,
-      signerSubstrateProxyAddress
+      senderAddress
     } = inputData;
     const isSendingSelf = (0, _transfer2.isRecipientSelf)(senderAddress, recipientAddress);
 
@@ -2507,8 +2505,7 @@ class KoniExtension {
         isSendingSelf
       },
       extrinsicType: _KoniTypes.ExtrinsicType.SEND_NFT,
-      chainType: _KoniTypes.ChainType.SUBSTRATE,
-      signerSubstrateProxyAddress
+      chainType: _KoniTypes.ChainType.SUBSTRATE
     });
     return {
       ...rs,
@@ -2546,6 +2543,9 @@ class KoniExtension {
     }
     return result;
   }
+  async accountsCreateMultisig(request) {
+    return this.#koniState.keyringService.context.accountsCreateMultisig(request);
+  }
 
   /// External account
 
@@ -2732,7 +2732,7 @@ class KoniExtension {
       signed = await pair.evm.signMessage(data, 'personal_sign');
     } else {
       var _signedTranaction$r, _signedTranaction$s, _signedTranaction$v;
-      const tx = (0, _utils8.createTransactionFromRLP)(message);
+      const tx = (0, _utils9.createTransactionFromRLP)(message);
       if (!tx) {
         throw new Error((0, _i18next.t)('bg.koni.handler.Extension.failedToDecodeQr'));
       }
@@ -2757,7 +2757,7 @@ class KoniExtension {
         common
       });
       const signedTranaction = _tx.LegacyTransaction.fromSerializedTx((0, _util.hexToU8a)(pair.evm.signTransaction(transaction)));
-      signed = (0, _utils8.signatureToHex)({
+      signed = (0, _utils9.signatureToHex)({
         r: ((_signedTranaction$r = signedTranaction.r) === null || _signedTranaction$r === void 0 ? void 0 : _signedTranaction$r.toString(16)) || '',
         s: ((_signedTranaction$s = signedTranaction.s) === null || _signedTranaction$s === void 0 ? void 0 : _signedTranaction$s.toString(16)) || '',
         v: ((_signedTranaction$v = signedTranaction.v) === null || _signedTranaction$v === void 0 ? void 0 : _signedTranaction$v.toString(16)) || ''
@@ -2829,7 +2829,7 @@ class KoniExtension {
           chainName: chainInfo.name
         }
       });
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
     }
     const bondingValidation = (0, _bonding.validateBondingCondition)(chainInfo, amount, selectedValidators, address, chainStakingMetadata, nominatorMetadata);
     if (!amount || !selectedValidators || bondingValidation.length > 0) {
@@ -2857,7 +2857,7 @@ class KoniExtension {
     } = inputData;
     const chainStakingMetadata = await this.#koniState.getStakingMetadataByChain(chain, _KoniTypes.StakingType.NOMINATED);
     if (!chainStakingMetadata || !nominatorMetadata) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INTERNAL_ERROR)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const unbondingValidation = (0, _bonding.validateUnbondingCondition)(nominatorMetadata, amount, chain, chainStakingMetadata, validatorAddress);
     if (!amount || unbondingValidation.length > 0) {
@@ -2882,10 +2882,10 @@ class KoniExtension {
     } = inputData;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!address || !poolHandler) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const chain = poolHandler.chain;
-    const stakingType = poolHandler.type === _types4.YieldPoolType.NOMINATION_POOL ? _KoniTypes.StakingType.POOLED : _KoniTypes.StakingType.NOMINATED;
+    const stakingType = poolHandler.type === _types5.YieldPoolType.NOMINATION_POOL ? _KoniTypes.StakingType.POOLED : _KoniTypes.StakingType.NOMINATED;
     const substrateApi = this.#koniState.getSubstrateApi(chain);
     const extrinsic = await (0, _bonding.getClaimRewardExtrinsic)(substrateApi, chain, address, stakingType, bondReward);
     return await this.#koniState.transactionService.handleTransaction({
@@ -2906,7 +2906,7 @@ class KoniExtension {
     } = inputData;
     const chain = (_this$koniState$earni = this.#koniState.earningService.getPoolHandler(slug)) === null || _this$koniState$earni === void 0 ? void 0 : _this$koniState$earni.chain;
     if (!chain || !selectedUnstaking) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const substrateApi = this.#koniState.getSubstrateApi(chain);
     // @ts-ignore
@@ -2936,7 +2936,7 @@ class KoniExtension {
           chainName: chainInfo.name
         }
       });
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
     }
     const bondingValidation = (0, _relayChain.validatePoolBondingCondition)(chainInfo, amount, selectedPool, address, chainStakingMetadata, nominatorMetadata);
     if (!amount || bondingValidation.length > 0) {
@@ -2968,7 +2968,7 @@ class KoniExtension {
           chainName: chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.name
         }
       });
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
     }
     const unbondingValidation = (0, _relayChain.validateRelayUnbondingCondition)(amount, chainStakingMetadata, nominatorMetadata);
     if (!amount || unbondingValidation.length > 0) {
@@ -2986,6 +2986,439 @@ class KoniExtension {
     });
   }
 
+  // Multisig handlers
+  async approvePendingTx(inputData) {
+    const {
+      address,
+      callHash,
+      chain,
+      multisigMetadata,
+      timepoint
+    } = inputData;
+    if (!address || !chain || !multisigMetadata || !callHash || !timepoint) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.MultisigTxErrorType.INVALID_PARAMS)]);
+    }
+    const api = this.#koniState.getSubstrateApi(chain).api;
+    if (!api || !api.tx || !api.tx.multisig) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.MultisigTxErrorType.LACK_MULTISIG_PALLET)]);
+    }
+    const otherSignatories = multisigMetadata.signers.filter(s => !(0, _utils9.isSameAddress)(s, address));
+    const extrinsic = api.tx.multisig.approveAsMulti(multisigMetadata.threshold, (0, _utilCrypto.sortAddresses)(otherSignatories), timepoint, callHash, _utils8.DEFAULT_MAX_WEIGHT);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.MULTISIG_APPROVE_TX,
+      transaction: extrinsic,
+      url: _constants3.EXTENSION_REQUEST_URL
+    });
+  }
+  async executePendingTx(inputData) {
+    const {
+      address,
+      call,
+      chain,
+      decodedCallData,
+      multisigMetadata,
+      timepoint
+    } = inputData;
+    if (!address || !chain || !multisigMetadata || !timepoint || !call || !decodedCallData) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.MultisigTxErrorType.INVALID_PARAMS)]);
+    }
+    try {
+      const api = this.#koniState.getSubstrateApi(chain).api;
+      if (!api || !api.tx || !api.tx.multisig) {
+        return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.MultisigTxErrorType.LACK_MULTISIG_PALLET)]);
+      }
+      const otherSignatories = multisigMetadata.signers.filter(s => !(0, _utils9.isSameAddress)(s, address));
+      const originalCall = api.createType('Call', call);
+      const originalExtrinsic = api.tx(originalCall);
+      const {
+        weight
+      } = await originalExtrinsic.paymentInfo(otherSignatories[0]); // estimate max weight for execute multisig tx
+
+      const extrinsic = api.tx.multisig.asMulti(multisigMetadata.threshold, (0, _utilCrypto.sortAddresses)(otherSignatories), timepoint, call, weight);
+      return await this.#koniState.transactionService.handleTransaction({
+        address,
+        chain,
+        chainType: _KoniTypes.ChainType.SUBSTRATE,
+        data: inputData,
+        extrinsicType: _KoniTypes.ExtrinsicType.MULTISIG_EXECUTE_TX,
+        transaction: extrinsic,
+        url: _constants3.EXTENSION_REQUEST_URL
+      });
+    } catch (e) {
+      const errMsg = e.message;
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.MultisigTxErrorType.UNABLE_TO_CONSTRUCT_TX, errMsg)]);
+    }
+  }
+  async cancelPendingTx(inputData) {
+    const {
+      address,
+      callHash,
+      chain,
+      multisigMetadata,
+      timepoint
+    } = inputData;
+    if (!address || !chain || !multisigMetadata || !callHash) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.MultisigTxErrorType.INVALID_PARAMS)]);
+    }
+    const api = this.#koniState.getSubstrateApi(chain).api;
+    if (!api || !api.tx || !api.tx.multisig) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.MultisigTxErrorType.LACK_MULTISIG_PALLET)]);
+    }
+    const otherSignatories = multisigMetadata.signers.filter(s => !(0, _utils9.isSameAddress)(s, address));
+    const extrinsic = api.tx.multisig.cancelAsMulti(multisigMetadata.threshold, (0, _utilCrypto.sortAddresses)(otherSignatories), timepoint, callHash);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.MULTISIG_CANCEL_TX,
+      transaction: extrinsic,
+      url: _constants3.EXTENSION_REQUEST_URL
+    });
+  }
+
+  // Multisig Account
+  async initMultisigTx(request) {
+    const {
+      chain,
+      multisigMetadata: {
+        signers,
+        threshold
+      },
+      signer,
+      transactionId
+    } = request;
+
+    /**
+     * ─────────────────────────────
+     * Prepare original transaction
+     * ─────────────────────────────
+     */
+    const substrateApi = await this.#koniState.chainService.getSubstrateApi(chain).isReady;
+    const originTransaction = this.#koniState.transactionService.getTransaction(transactionId);
+    if (!(originTransaction !== null && originTransaction !== void 0 && originTransaction.transaction)) {
+      throw new Error(`[initMultisigTx] Origin transaction not found: ${transactionId}`);
+    }
+    const extrinsicOriginTransaction = originTransaction.transaction;
+    const callData = extrinsicOriginTransaction.method.toHex();
+
+    /**
+     * ─────────────────────────────
+     * Create multisig wrapped extrinsic
+     * ─────────────────────────────
+     */
+    const multisigExtrinsic = (0, _utils8.createInitMultisigExtrinsic)(substrateApi.api, threshold, signers, signer, extrinsicOriginTransaction);
+    const decodedCallData = (0, _utils8.decodeCallData)({
+      api: substrateApi.api,
+      callData
+    });
+
+    /**
+     * ─────────────────────────────
+     * Fee & deposit calculation
+     * ─────────────────────────────
+     */
+    const networkFee = (await multisigExtrinsic.paymentInfo(signer)).partialFee.toString();
+    const depositBase = substrateApi.api.consts.multisig.depositBase.toString();
+    const depositFactor = substrateApi.api.consts.multisig.depositFactor.toString();
+    const depositAmount = (0, _utils8.calcDepositAmount)(depositBase, threshold, depositFactor);
+
+    /**
+     * ─────────────────────────────
+     * Additional validation
+     * ─────────────────────────────
+     * Validate signer balance:
+     * - multisig deposit
+     * - network fee
+     */
+    const additionalValidator = async inputTransaction => {
+      const signerBalance = await this.getAddressTransferableBalance({
+        address: signer,
+        networkKey: chain,
+        token: this.#koniState.chainService.getNativeTokenInfo(chain).slug,
+        extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_TOKEN
+      });
+
+      // Hydration: token fee setting is not supported
+      // todo: check and return better error for the case set token fee on hydration
+      if (_constants._SUPPORT_TOKEN_PAY_FEE_GROUP.hydration.includes(chain)) {
+        var _substrateApi$api$que3;
+        const setTokenPayFee = await ((_substrateApi$api$que3 = substrateApi.api.query.multiTransactionPayment) === null || _substrateApi$api$que3 === void 0 ? void 0 : _substrateApi$api$que3.accountCurrencyMap(signer));
+        if (setTokenPayFee.toPrimitive()) {
+          inputTransaction.errors.push(new _TransactionError.TransactionError(_types5.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)('bg.koni.handler.Extension.notEnoughBalanceForMultisigDepositAndFee')));
+        }
+      }
+      const requiredBalance = BigInt(depositAmount) + BigInt(networkFee);
+      if (BigInt(signerBalance.value) < requiredBalance) {
+        inputTransaction.errors.push(new _TransactionError.TransactionError(_types5.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)('bg.koni.handler.Extension.notEnoughBalanceForMultisigDepositAndFee')));
+      }
+    };
+
+    /**
+     * ─────────────────────────────
+     * Event forwarding
+     * ─────────────────────────────
+     * Multisig INIT transaction:
+     * - `signed` is forwarded to notify that the multisig initialization
+     *   has been successfully submitted.
+     * - `error` / `timeout` are forwarded to propagate failures.
+     *
+     * Note:
+     * Multisig execution requires collecting enough approvals,
+     * so the transaction is not finalized at this stage.
+     * These forwarded events are only used to resolve
+     * the original wrapped transaction promise.
+     */
+    const eventsHandler = eventEmitter => {
+      const originEmitter = originTransaction === null || originTransaction === void 0 ? void 0 : originTransaction.emitterTransaction;
+      if (!originEmitter) {
+        return;
+      }
+      eventEmitter.on('signed', data => {
+        originEmitter.emit('signed', data);
+      });
+      eventEmitter.on('error', data => {
+        if (data.errors.length > 0) {
+          originEmitter.emit('error', data);
+        }
+      });
+      eventEmitter.on('timeout', data => {
+        if (data.errors.length > 0 && data.errors.some(e => e.errorType === _types5.BasicTxErrorType.TIMEOUT)) {
+          originEmitter.emit('timeout', data);
+        }
+      });
+    };
+
+    /**
+     * ─────────────────────────────
+     * Submit wrapped transaction
+     * ─────────────────────────────
+     */
+    return this.#koniState.transactionService.handleWrappedTransaction({
+      address: signer,
+      chain,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      extrinsicType: _KoniTypes.ExtrinsicType.MULTISIG_INIT_TX,
+      transaction: multisigExtrinsic,
+      skipFeeValidation: true,
+      wrappingStatus: _types4.SubstrateTransactionWrappingStatus.WRAP_RESULT,
+      data: {
+        // input
+        ...request,
+        // output
+        submittedCallData: multisigExtrinsic.toHex(),
+        callData,
+        decodedCallData,
+        depositAmount,
+        networkFee
+      },
+      additionalValidator,
+      eventsHandler
+    });
+  }
+
+  // Substrate Proxy Account
+  async handleSubstrateProxyWrappedTx(request) {
+    const {
+      chain,
+      proxyMetadata,
+      signer,
+      transactionId
+    } = request;
+    const {
+      proxiedAddress
+    } = proxyMetadata;
+
+    /**
+     * ─────────────────────────────
+     * Prepare original transaction
+     * ─────────────────────────────
+     */
+    const substrateApi = await this.#koniState.chainService.getSubstrateApi(chain).isReady;
+    const originTransaction = this.#koniState.transactionService.getTransaction(transactionId);
+    const extrinsicOriginTransaction = originTransaction === null || originTransaction === void 0 ? void 0 : originTransaction.transaction;
+    const callData = extrinsicOriginTransaction.method.toHex();
+    const decodedCallData = (0, _utils8.decodeCallData)({
+      api: substrateApi.api,
+      callData
+    });
+
+    /**
+     * ─────────────────────────────
+     * Determine proxy execution
+     * ─────────────────────────────
+     * If signer is the proxied address itself,
+     * a substrate proxy transaction is NOT required.
+     */
+    const isSignerProxiedAccount = (0, _utils9.isSameAddress)(signer, proxiedAddress);
+
+    /**
+     * ─────────────────────────────
+     * Fee calculation
+     * ─────────────────────────────
+     */
+
+    const substrateProxyExtrinsic = isSignerProxiedAccount ? extrinsicOriginTransaction : (0, _substrateProxyService.createInitSubstrateProxyExtrinsic)(substrateApi.api, proxiedAddress, extrinsicOriginTransaction);
+    const networkFee = (await substrateProxyExtrinsic.paymentInfo(signer)).partialFee.toString();
+
+    /**
+     * ─────────────────────────────
+     * Additional validation
+     * ─────────────────────────────
+     * Validate signer balance for proxy execution fee.
+     */
+    const additionalValidator = async inputTransaction => {
+      const signerBalance = await this.getAddressTransferableBalance({
+        address: signer,
+        networkKey: chain,
+        token: this.#koniState.chainService.getNativeTokenInfo(chain).slug,
+        extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_TOKEN
+      });
+
+      // todo: check and return better error for the case set token fee on hydration
+      if (_constants._SUPPORT_TOKEN_PAY_FEE_GROUP.hydration.includes(chain)) {
+        var _substrateApi$api$que4;
+        const setTokenPayFee = await ((_substrateApi$api$que4 = substrateApi.api.query.multiTransactionPayment) === null || _substrateApi$api$que4 === void 0 ? void 0 : _substrateApi$api$que4.accountCurrencyMap(signer));
+        if (setTokenPayFee.toPrimitive()) {
+          const account = (0, _utils9.getAccountJsonByAddress)(signer);
+          inputTransaction.errors.push(new _TransactionError.TransactionError(_types5.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)('bg.koni.handler.Extension.proxyAccountNotEnoughBalance', {
+            replace: {
+              accountName: account === null || account === void 0 ? void 0 : account.name
+            }
+          })));
+        }
+      }
+      if (BigInt(signerBalance.value) < BigInt(networkFee)) {
+        const account = (0, _utils9.getAccountJsonByAddress)(signer);
+        inputTransaction.errors.push(new _TransactionError.TransactionError(_types5.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)('bg.koni.handler.Extension.proxyAccountNotEnoughBalance', {
+          replace: {
+            accountName: account === null || account === void 0 ? void 0 : account.name
+          }
+        })));
+      }
+    };
+
+    /**
+     * ─────────────────────────────
+     * Event forwarding
+     * ─────────────────────────────
+     * The substrate proxy transaction acts as a wrapper.
+     * Its lifecycle events are forwarded to the original
+     * transaction to resolve the wrapped transaction promise.
+     * update history transaction accordingly.
+     */
+    const eventsHandler = eventEmitter => {
+      if (!(originTransaction !== null && originTransaction !== void 0 && originTransaction.emitterTransaction)) {
+        return;
+      }
+      const originEmitter = originTransaction.emitterTransaction;
+      eventEmitter.on('send', data => {
+        originEmitter.emit('send', {
+          ...data,
+          id: originTransaction.id
+        });
+      });
+      eventEmitter.on('signed', data => {
+        originEmitter.emit('signed', {
+          ...data,
+          id: originTransaction.id
+        });
+      });
+      eventEmitter.on('extrinsicHash', data => {
+        originEmitter.emit('extrinsicHash', {
+          ...data,
+          id: originTransaction.id
+        });
+      });
+      eventEmitter.on('success', data => {
+        originEmitter.emit('success', {
+          ...data,
+          id: originTransaction.id
+        });
+      });
+      eventEmitter.on('error', data => {
+        if (data.errors.length > 0) {
+          originEmitter.emit('error', {
+            ...data,
+            id: originTransaction.id
+          });
+        }
+      });
+      eventEmitter.on('timeout', data => {
+        if (data.errors.some(error => error.errorType === _types5.BasicTxErrorType.TIMEOUT)) {
+          originEmitter.emit('timeout', {
+            ...data,
+            id: originTransaction.id
+          });
+        }
+      });
+    };
+
+    /**
+     * ─────────────────────────────
+     * Execute wrapped transaction
+     * ─────────────────────────────
+     */
+
+    // Case 1: signer === proxied address → handle original transaction
+    if (isSignerProxiedAccount) {
+      let callDataFinal = callData;
+      let decodedCallDataFinal = decodedCallData;
+      const pendingMultisigTxRequest = originTransaction.data;
+      if (pendingMultisigTxRequest.call && pendingMultisigTxRequest.decodedCallData) {
+        callDataFinal = pendingMultisigTxRequest.call;
+        decodedCallDataFinal = pendingMultisigTxRequest.decodedCallData;
+      }
+      const response = await this.#koniState.transactionService.handleWrappedTransaction({
+        ...originTransaction,
+        skipFeeValidation: false,
+        data: {
+          ...originTransaction.data,
+          // output
+          decodedCallData: decodedCallDataFinal,
+          submittedCallData: substrateProxyExtrinsic.toHex(),
+          callData: callDataFinal,
+          networkFee
+        },
+        errors: [],
+        // Clear previous errors
+        wrappingStatus: _types4.SubstrateTransactionWrappingStatus.WRAP_RESULT,
+        eventsHandler
+      });
+
+      // Clear wrappingStatus since no wrapping is needed
+      delete response.wrappingStatus;
+      return response;
+    }
+
+    // Case 2: create and handle substrate proxy transaction
+    return await this.#koniState.transactionService.handleWrappedTransaction({
+      address: signer,
+      chain,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      extrinsicType: _KoniTypes.ExtrinsicType.SUBSTRATE_PROXY_INIT_TX,
+      transaction: substrateProxyExtrinsic,
+      skipFeeValidation: true,
+      transferNativeAmount: originTransaction.transferNativeAmount,
+      data: {
+        // input
+        ...request,
+        // output
+        decodedCallData,
+        submittedCallData: substrateProxyExtrinsic.toHex(),
+        callData,
+        networkFee
+      },
+      wrappingStatus: _types4.SubstrateTransactionWrappingStatus.WRAP_RESULT,
+      additionalValidator,
+      eventsHandler
+    });
+  }
+
   // EVM Transaction
   async parseContractInput(_ref50) {
     let {
@@ -3005,7 +3438,7 @@ class KoniExtension {
       networkKey
     } = inputData;
     if (!address) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const dotSamaApi = this.#koniState.getSubstrateApi(networkKey);
     const chainInfo = this.#koniState.getChainInfo(networkKey);
@@ -3188,15 +3621,15 @@ class KoniExtension {
     const {
       payload
     } = request;
-    let registry = new _types6.TypeRegistry();
+    let registry = new _types7.TypeRegistry();
     if (isJsonPayload(payload)) {
       const [, chainInfo] = this.#koniState.findNetworkKeyByGenesisHash(payload.genesisHash);
-      const registries = await Promise.all([(0, _utils1.setupApiRegistry)(chainInfo, this.#koniState), (0, _utils1.setupDatabaseRegistry)(chainInfo, payload, this.#koniState), (0, _utils1.setupDappRegistry)(payload, this.#koniState)]);
+      const registries = await Promise.all([(0, _utils10.setupApiRegistry)(chainInfo, this.#koniState), (0, _utils10.setupDatabaseRegistry)(chainInfo, payload, this.#koniState), (0, _utils10.setupDappRegistry)(payload, this.#koniState)]);
       const validRegistries = registries.filter(item => !!(item !== null && item !== void 0 && item.registry));
       if (validRegistries.length === 0) {
         registry.setSignedExtensions(payload.signedExtensions);
       } else {
-        registry = (0, _utils1.getSuitableRegistry)(validRegistries, payload);
+        registry = (0, _utils10.getSuitableRegistry)(validRegistries, payload);
       }
     }
     const result = request.sign(registry, pair);
@@ -3397,8 +3830,6 @@ class KoniExtension {
       return await this.#koniState.reloadStaking();
     } else if (data === 'balance') {
       return await this.#koniState.reloadBalance();
-    } else if (data === 'crowdloan') {
-      return await this.#koniState.reloadCrowdloan();
     }
     return Promise.resolve(false);
   }
@@ -3495,12 +3926,12 @@ class KoniExtension {
         if (namespace.chains) {
           const unSupportChains = namespace.chains.filter(chain => !(0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap));
           if (unSupportChains.length) {
-            throw new Error((0, _utils0.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
+            throw new Error((0, _utils1.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
           }
           availableNamespaces[key] = namespace;
         }
       } else {
-        throw new Error((0, _utils0.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
+        throw new Error((0, _utils1.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
       }
     });
     Object.entries(optionalNamespaces).forEach(_ref63 => {
@@ -3535,7 +3966,7 @@ class KoniExtension {
           const [_namespace] = address.split(':');
           return _namespace === key;
         });
-        const chains = (0, _utils8.uniqueStringArray)(namespace.chains);
+        const chains = (0, _utils9.uniqueStringArray)(namespace.chains);
         namespaces[key] = {
           accounts,
           methods: namespace.methods,
@@ -3674,7 +4105,7 @@ class KoniExtension {
   }
   async initSyncMantaPay(address) {
     var _this$koniState$chain5, _this$koniState$chain6, _this$koniState$chain7, _this$koniState$chain8;
-    if ((_this$koniState$chain5 = this.#koniState.chainService) !== null && _this$koniState$chain5 !== void 0 && (_this$koniState$chain6 = _this$koniState$chain5.mantaPay) !== null && _this$koniState$chain6 !== void 0 && _this$koniState$chain6.getSyncState().isSyncing || !_utils8.MODULE_SUPPORT.MANTA_ZK) {
+    if ((_this$koniState$chain5 = this.#koniState.chainService) !== null && _this$koniState$chain5 !== void 0 && (_this$koniState$chain6 = _this$koniState$chain5.mantaPay) !== null && _this$koniState$chain6 !== void 0 && _this$koniState$chain6.getSyncState().isSyncing || !_utils9.MODULE_SUPPORT.MANTA_ZK) {
       return;
     }
     this.#skipAutoLock = true;
@@ -3841,8 +4272,7 @@ class KoniExtension {
       isPassConfirmation,
       onSend,
       path,
-      processId,
-      signerSubstrateProxyAddress
+      processId
     } = inputData;
     const {
       address
@@ -3858,10 +4288,10 @@ class KoniExtension {
     if (!data) {
       if (step) {
         this.#koniState.transactionService.updateProcessStepStatus(step, {
-          status: _types4.StepStatus.FAILED
+          status: _types5.StepStatus.FAILED
         });
       }
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INTERNAL_ERROR)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const isLastStep = inputData.currentStep + 1 === path.steps.length;
     const yieldValidation = await this.#koniState.earningService.validateYieldJoin({
@@ -3872,7 +4302,7 @@ class KoniExtension {
     if (yieldValidation.length > 0) {
       if (step) {
         this.#koniState.transactionService.updateProcessStepStatus(step, {
-          status: _types4.StepStatus.FAILED
+          status: _types5.StepStatus.FAILED
         });
       }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(yieldValidation);
@@ -3883,7 +4313,7 @@ class KoniExtension {
     } catch (e) {
       if (step) {
         this.#koniState.transactionService.updateProcessStepStatus(step, {
-          status: _types4.StepStatus.FAILED
+          status: _types5.StepStatus.FAILED
         });
       }
       throw e;
@@ -3912,7 +4342,7 @@ class KoniExtension {
           feeComponent: [{
             amount: fee.amount || '0',
             // TODO: Add fee type
-            feeType: _types4.SwapFeeType.NETWORK_FEE,
+            feeType: _types5.SwapFeeType.NETWORK_FEE,
             tokenSlug: fee.slug
           }],
           defaultFeeToken: fee.slug,
@@ -3923,7 +4353,7 @@ class KoniExtension {
         const lastStep = path.steps[path.steps.length - 1];
         const combineInfo = {
           // In real case, only `YIELD` have multiple steps
-          type: lastStep.type === _types4.YieldStepType.JOIN_NOMINATION_POOL ? _types4.EarningProcessType.NOMINATION_POOL : lastStep.type === _types4.YieldStepType.NOMINATE ? _types4.EarningProcessType.NATIVE_STAKING : _types4.EarningProcessType.YIELD,
+          type: lastStep.type === _types5.YieldStepType.JOIN_NOMINATION_POOL ? _types5.EarningProcessType.NOMINATION_POOL : lastStep.type === _types5.YieldStepType.NOMINATE ? _types5.EarningProcessType.NATIVE_STAKING : _types5.EarningProcessType.YIELD,
           data,
           brief: {
             amount: data.amount,
@@ -3934,17 +4364,17 @@ class KoniExtension {
         };
         await this.#koniState.transactionService.createProcessIfNeed({
           id: processId,
-          address: (0, _utils8.reformatAddress)(address),
-          type: _types4.ProcessType.EARNING,
+          address: (0, _utils9.reformatAddress)(address),
+          type: _types5.ProcessType.EARNING,
           combineInfo,
           currentStepId: step.stepId,
           steps: path.steps.map((step, index) => {
             const fee = convertFee(path.totalFee[index]);
-            if (![_types4.YieldStepType.XCM, _types4.YieldStepType.DEFAULT, _types4.YieldStepType.TOKEN_APPROVAL].includes(step.type)) {
+            if (![_types5.YieldStepType.XCM, _types5.YieldStepType.DEFAULT, _types5.YieldStepType.TOKEN_APPROVAL].includes(step.type)) {
               const metadata = data;
               return {
                 ...step,
-                status: _types4.StepStatus.QUEUED,
+                status: _types5.StepStatus.QUEUED,
                 fee,
                 metadata: metadata
               };
@@ -3952,16 +4382,16 @@ class KoniExtension {
             return {
               ...step,
               fee,
-              status: _types4.StepStatus.QUEUED
+              status: _types5.StepStatus.QUEUED
             };
-          }).filter(step => step.type !== _types4.YieldStepType.DEFAULT),
-          status: _types4.StepStatus.QUEUED
+          }).filter(step => step.type !== _types5.YieldStepType.DEFAULT),
+          status: _types5.StepStatus.QUEUED
         });
       }
     }
-    let balanceTypeForPool = _types4.BalanceType.TRANSFERABLE;
-    if (!!poolHandler && [_types4.YieldPoolType.NATIVE_STAKING, _types4.YieldPoolType.NOMINATION_POOL].includes(poolHandler.type)) {
-      balanceTypeForPool = _types4.BalanceType.TOTAL_MINUS_RESERVED;
+    let balanceTypeForPool = _types5.BalanceType.TRANSFERABLE;
+    if (!!poolHandler && [_types5.YieldPoolType.NATIVE_STAKING, _types5.YieldPoolType.NOMINATION_POOL].includes(poolHandler.type)) {
+      balanceTypeForPool = _types5.BalanceType.TOTAL_MINUS_RESERVED;
     }
     return await this.#koniState.transactionService.handleTransaction({
       address,
@@ -3973,7 +4403,6 @@ class KoniExtension {
       // change this depends on step
       chainType,
       resolveOnDone: !isLastStep,
-      signerSubstrateProxyAddress,
       transferNativeAmount,
       balanceType: balanceTypeForPool,
       skipFeeValidation: isMintingStep && isPoolSupportAlternativeFee,
@@ -3986,7 +4415,6 @@ class KoniExtension {
   async handleYieldLeave(params) {
     const {
       address,
-      signerSubstrateProxyAddress,
       slug
     } = params;
     const leaveValidation = await this.#koniState.earningService.validateYieldLeave(params);
@@ -4002,7 +4430,6 @@ class KoniExtension {
       data: params,
       // TODO
       extrinsicType,
-      signerSubstrateProxyAddress,
       chainType: (handler === null || handler === void 0 ? void 0 : handler.transactionChainType) || _KoniTypes.ChainType.SUBSTRATE
     });
   }
@@ -4079,12 +4506,11 @@ class KoniExtension {
   async yieldSubmitWithdrawal(params) {
     const {
       address,
-      signerSubstrateProxyAddress,
       slug
     } = params;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!poolHandler) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const extrinsic = await this.#koniState.earningService.handleYieldWithdraw(params);
     return await this.#koniState.transactionService.handleTransaction({
@@ -4093,7 +4519,6 @@ class KoniExtension {
       transaction: extrinsic,
       data: params,
       extrinsicType: _KoniTypes.ExtrinsicType.STAKING_WITHDRAW,
-      signerSubstrateProxyAddress,
       chainType: (poolHandler === null || poolHandler === void 0 ? void 0 : poolHandler.transactionChainType) || _KoniTypes.ChainType.SUBSTRATE
     });
   }
@@ -4101,12 +4526,11 @@ class KoniExtension {
     const {
       address,
       selectedUnstaking,
-      signerSubstrateProxyAddress,
       slug
     } = params;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!poolHandler || !selectedUnstaking) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const chain = poolHandler.chain;
     const extrinsic = await this.#koniState.earningService.handleYieldCancelUnstake(params);
@@ -4116,19 +4540,17 @@ class KoniExtension {
       transaction: extrinsic,
       data: params,
       extrinsicType: _KoniTypes.ExtrinsicType.STAKING_CANCEL_UNSTAKE,
-      signerSubstrateProxyAddress,
       chainType: (poolHandler === null || poolHandler === void 0 ? void 0 : poolHandler.transactionChainType) || _KoniTypes.ChainType.SUBSTRATE
     });
   }
   async yieldSubmitClaimReward(params) {
     const {
       address,
-      signerSubstrateProxyAddress,
       slug
     } = params;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!address || !poolHandler) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const extrinsic = await this.#koniState.earningService.handleYieldClaimReward(params);
     return await this.#koniState.transactionService.handleTransaction({
@@ -4136,7 +4558,6 @@ class KoniExtension {
       chain: poolHandler.chain,
       transaction: extrinsic,
       data: params,
-      signerSubstrateProxyAddress,
       extrinsicType: _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD,
       chainType: (poolHandler === null || poolHandler === void 0 ? void 0 : poolHandler.transactionChainType) || _KoniTypes.ChainType.SUBSTRATE
     });
@@ -4147,7 +4568,7 @@ class KoniExtension {
     } = params;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!poolHandler) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const slippage = await this.#koniState.earningService.yieldGetEarningImpact(params);
     return slippage;
@@ -4155,12 +4576,11 @@ class KoniExtension {
   async handleYieldChangeValidator(params) {
     const {
       address,
-      signerSubstrateProxyAddress,
       slug
     } = params;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!poolHandler) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const extrinsic = await this.#koniState.earningService.handleYieldChangeValidator(params);
     return await this.#koniState.transactionService.handleTransaction({
@@ -4168,7 +4588,6 @@ class KoniExtension {
       chain: poolHandler.chain,
       transaction: extrinsic,
       data: params,
-      signerSubstrateProxyAddress,
       extrinsicType: _KoniTypes.ExtrinsicType.CHANGE_EARNING_VALIDATOR,
       chainType: _KoniTypes.ChainType.SUBSTRATE
     });
@@ -4393,10 +4812,10 @@ class KoniExtension {
     if (!quote || !address || !process) {
       if (step) {
         this.#koniState.transactionService.updateProcessStepStatus(step, {
-          status: _types4.StepStatus.FAILED
+          status: _types5.StepStatus.FAILED
         });
       }
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types4.BasicTxErrorType.INTERNAL_ERROR)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types5.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const isLastStep = inputData.currentStep + 1 === process.steps.length;
     const swapValidations = await this.#koniState.swapService.validateSwapProcessV2({
@@ -4409,7 +4828,7 @@ class KoniExtension {
     if (swapValidations.length > 0) {
       if (step) {
         this.#koniState.transactionService.updateProcessStepStatus(step, {
-          status: _types4.StepStatus.FAILED
+          status: _types5.StepStatus.FAILED
         });
       }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(swapValidations);
@@ -4420,7 +4839,7 @@ class KoniExtension {
     } catch (e) {
       if (step) {
         this.#koniState.transactionService.updateProcessStepStatus(step, {
-          status: _types4.StepStatus.FAILED
+          status: _types5.StepStatus.FAILED
         });
       }
       console.log('Error handling process step', e);
@@ -4455,8 +4874,8 @@ class KoniExtension {
         };
         await this.#koniState.transactionService.createProcessIfNeed({
           id: processId,
-          address: (0, _utils8.reformatAddress)(address),
-          type: _types4.ProcessType.SWAP,
+          address: (0, _utils9.reformatAddress)(address),
+          type: _types5.ProcessType.SWAP,
           currentStepId: step.stepId,
           combineInfo,
           steps: inputData.process.steps.map((step, index) => {
@@ -4464,10 +4883,10 @@ class KoniExtension {
             return {
               ...step,
               fee,
-              status: _types4.StepStatus.QUEUED
+              status: _types5.StepStatus.QUEUED
             };
-          }).filter(step => step.type !== _types4.CommonStepType.DEFAULT),
-          status: _types4.StepStatus.QUEUED
+          }).filter(step => step.type !== _types5.CommonStepType.DEFAULT),
+          status: _types5.StepStatus.QUEUED
         });
       }
     }
@@ -4541,8 +4960,8 @@ class KoniExtension {
     });
     return await this.#koniState.inappNotificationService.getUnreadNotificationsCountMap();
   }
-  markAllReadNotification(proxyId) {
-    return this.#koniState.inappNotificationService.markAllRead(proxyId);
+  markAllReadNotification(params) {
+    return this.#koniState.inappNotificationService.markAllRead(params);
   }
   switchReadNotificationStatus(params) {
     return this.#koniState.inappNotificationService.switchReadStatus(params);
@@ -4663,8 +5082,8 @@ class KoniExtension {
     if (!pair) {
       throw new Error('Pair not found');
     }
-    const signMode = (0, _utils8.getAccountSignMode)(address, pair.meta);
-    if (signMode !== _types4.AccountSignMode.PASSWORD) {
+    const signMode = (0, _utils9.getAccountSignMode)(address, pair.meta);
+    if (signMode !== _types5.AccountSignMode.PASSWORD) {
       throw new Error('Account can not use this feature');
     }
     const setting = await new Promise(resolve => this.#koniState.settingService.getSettings(resolve));
@@ -4672,16 +5091,16 @@ class KoniExtension {
       throw new Error('Wallet not enable this feature');
     }
     switch (type) {
-      case _types4.ProcessType.EARNING:
+      case _types5.ProcessType.EARNING:
 
       // eslint-disable-next-line no-fallthrough
-      case _types4.ProcessType.SWAP:
+      case _types5.ProcessType.SWAP:
         {
           const currentStep = requestData.currentStep;
           let stepNums;
           let submitData;
           let waitXcmData;
-          if (type === _types4.ProcessType.EARNING) {
+          if (type === _types5.ProcessType.EARNING) {
             const data = requestData;
             const poolHandler = this.#koniState.earningService.getPoolHandler(data.data.slug);
             if (poolHandler) {
@@ -4861,10 +5280,9 @@ class KoniExtension {
   async handleAddSubstrateProxyAccount(params) {
     const {
       address,
-      chain,
-      signerSubstrateProxyAddress
+      chain
     } = params;
-    const validationErrors = await this.#koniState.substrateProxyAccountService.validateAddSubstrateProxyAccount(params, signerSubstrateProxyAddress);
+    const validationErrors = await this.#koniState.substrateProxyAccountService.validateAddSubstrateProxyAccount(params);
     if (validationErrors.length > 0) {
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(validationErrors);
     }
@@ -4875,15 +5293,13 @@ class KoniExtension {
       transaction: extrinsic,
       data: params,
       extrinsicType: _KoniTypes.ExtrinsicType.ADD_SUBSTRATE_PROXY_ACCOUNT,
-      chainType: _KoniTypes.ChainType.SUBSTRATE,
-      signerSubstrateProxyAddress
+      chainType: _KoniTypes.ChainType.SUBSTRATE
     });
   }
   async handleRemoveSubstrateProxyAccount(params) {
     const {
       address,
-      chain,
-      signerSubstrateProxyAddress
+      chain
     } = params;
     const extrinsic = await this.#koniState.substrateProxyAccountService.removeSubstrateProxyAccounts(params);
     return await this.#koniState.transactionService.handleTransaction({
@@ -4892,8 +5308,7 @@ class KoniExtension {
       transaction: extrinsic,
       data: params,
       extrinsicType: _KoniTypes.ExtrinsicType.REMOVE_SUBSTRATE_PROXY_ACCOUNT,
-      chainType: _KoniTypes.ChainType.SUBSTRATE,
-      signerSubstrateProxyAddress
+      chainType: _KoniTypes.ChainType.SUBSTRATE
     });
   }
 
@@ -4909,8 +5324,7 @@ class KoniExtension {
       transaction: extrinsic,
       data: request,
       extrinsicType: _KoniTypes.ExtrinsicType.GOV_VOTE,
-      chainType: _KoniTypes.ChainType.SUBSTRATE,
-      signerSubstrateProxyAddress: request.signerSubstrateProxyAddress
+      chainType: _KoniTypes.ChainType.SUBSTRATE
     });
   }
   async handleRemoveVote(request) {
@@ -4921,8 +5335,7 @@ class KoniExtension {
       transaction: extrinsic,
       data: request,
       extrinsicType: _KoniTypes.ExtrinsicType.GOV_UNVOTE,
-      chainType: _KoniTypes.ChainType.SUBSTRATE,
-      signerSubstrateProxyAddress: request.signerSubstrateProxyAddress
+      chainType: _KoniTypes.ChainType.SUBSTRATE
     });
   }
   async handleUnlockVote(request) {
@@ -4933,8 +5346,7 @@ class KoniExtension {
       transaction: extrinsic,
       data: request,
       extrinsicType: _KoniTypes.ExtrinsicType.GOV_UNLOCK_VOTE,
-      chainType: _KoniTypes.ChainType.SUBSTRATE,
-      signerSubstrateProxyAddress: request.signerSubstrateProxyAddress
+      chainType: _KoniTypes.ChainType.SUBSTRATE
     });
   }
   async subscribeGovLockedInfo(id, port) {
@@ -4954,6 +5366,25 @@ class KoniExtension {
 
   /* Open Gov */
 
+  /* Multisig Acocunt */
+
+  async subscribePendingMultisigTx(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    await this.#koniState.multisigService.waitForStarted();
+    const pendingTxSubscription = this.#koniState.multisigService.subscribePendingMultisigTxMap().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, pendingTxSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.multisigService.getPendingMultisigTxMap();
+  }
+
+  /* Multisig Acocunt */
+
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
@@ -5160,6 +5591,8 @@ class KoniExtension {
         return this.accountsCreateSuriV2(request);
       case 'pri(accounts.create.externalV2)':
         return await this.accountsCreateExternalV2(request);
+      case 'pri(accounts.create.multisig)':
+        return await this.accountsCreateMultisig(request);
       case 'pri(accounts.create.hardwareV2)':
         return await this.accountsCreateHardwareV2(request);
       case 'pri(accounts.create.hardwareMultiple)':
@@ -5612,6 +6045,7 @@ class KoniExtension {
         return this.migrateSoloAccount(request);
       case 'pri(migrate.pingSession)':
         return this.pingSession(request);
+      /* Migrate Unified Account */
 
       /* Gov */
       case 'pri(openGov.vote)':
@@ -5622,6 +6056,24 @@ class KoniExtension {
         return this.handleUnlockVote(request);
       case 'pri(openGov.subscribeGovLockedInfo)':
         return this.subscribeGovLockedInfo(id, port);
+      /* Gov */
+
+      /* Multisig Account */
+      case 'pri(multisig.subscribePendingMultisigTxs)':
+        return await this.subscribePendingMultisigTx(id, port);
+      case 'pri(multisig.getPendingMultisigTxs)':
+        return this.#koniState.multisigService.getPendingTxsForMultisigAddress(request);
+      case 'pri(multisig.approvePendingTx)':
+        return await this.approvePendingTx(request);
+      case 'pri(multisig.executePendingTx)':
+        return await this.executePendingTx(request);
+      case 'pri(multisig.cancelPendingTx)':
+        return await this.cancelPendingTx(request);
+      case 'pri(multisig.initMultisigTx)':
+        return await this.initMultisigTx(request);
+      case 'pri(multisig.getSignableAccountInfos)':
+        return this.#koniState.keyringService.context.getSignableAccountInfos(request);
+      /* Multisig Account */
 
       // Proxy
       case 'pri(substrateProxyAccount.getGroupInfo)':
@@ -5630,7 +6082,8 @@ class KoniExtension {
         return this.handleAddSubstrateProxyAccount(request);
       case 'pri(substrateProxyAccount.remove)':
         return this.handleRemoveSubstrateProxyAccount(request);
-
+      case 'pri(substrateProxyAccount.handleProxyWrappedTx)':
+        return this.handleSubstrateProxyWrappedTx(request);
       // Default
       default:
         throw new Error(`Unable to handle message of type ${type}`);