@subwallet/extension-base 1.3.73-0 → 1.3.74-1

package/services/transaction-service/index.d.ts

@@ -11,6 +11,7 @@ export default class TransactionService {
     private aliveProcessMap;
     private readonly transactionSubject;
     private readonly aliveProcessSubject;
+    private previousWrappedTxId;
     private cacheProcessInfo;
     private get transactions();
     constructor(state: KoniState);
@@ -35,6 +36,36 @@ export default class TransactionService {
     addTransaction(inputTransaction: SWTransactionInput): Promise<TransactionEmitter>;
     addDutchTransaction(inputTransaction: SWDutchTransactionInput): TransactionEmitter;
     generateBeforeHandleResponseErrors(errors: TransactionError[]): SWTransactionResponse;
+    /**
+     * Wrapped transaction flow:
+     *
+     * Create base transaction (WRAPPABLE)
+     *   - skip fee validation
+     *   - NOT submitted to chain
+     *   - acts as the logical / UI-facing transaction
+     *   ↓
+     * Inject event emitter into base transaction
+     *   - base transaction listens to wrapped transaction events
+     *   - used to resolve the original transaction promise
+     *   ↓
+     * User selects signer in UI
+     *   - proxy account or multisig signatory
+     *   ↓
+     * Prepare wrapped transaction
+     *   - resolve actual signer
+     *   - build wrapped extrinsic (proxy / multisig)
+     *   - attach validators & event forwarders
+     *   ↓
+     * Mark base transaction as WRAP_SOURCE
+     *   ↓
+     * Create & submit wrapped transaction (WRAP_RESULT)
+     *   ↓
+     * Forward wrapped transaction events → base transaction
+     *   ↓
+     * Cleanup temporary data
+     *
+     */
+    handleWrappedTransaction(transaction: SWTransactionInput): Promise<SWTransactionResponse>;
     handleTransaction(transaction: SWTransactionInput): Promise<SWTransactionResponse>;
     handleTransactionAfterConfirmation(transaction: SWTransactionInput): Promise<SWTransactionResponse>;
     handlePermitTransaction(transaction: SWPermitTransactionInput): Promise<SWTransactionResponse>;

package/services/transaction-service/index.js

@@ -12,10 +12,11 @@ import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/reques
 import { TRANSACTION_TIMEOUT } from '@subwallet/extension-base/services/transaction-service/constants';
 import { parseLiquidStakingEvents, parseLiquidStakingFastUnstakeEvents, parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
 import { getBaseTransactionInfo, getTransactionId, isBitcoinTransaction, isCardanoTransaction, isSubstrateTransaction, isTonTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { SubstrateTransactionWrappingStatus } from '@subwallet/extension-base/services/transaction-service/types';
 import { getExplorerLink, parseTransactionData } from '@subwallet/extension-base/services/transaction-service/utils';
 import { isWalletConnectRequest } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { BasicTxErrorType, StepStatus, YieldPoolType } from '@subwallet/extension-base/types';
-import { anyNumberToBN, isSameAddress, pairToAccount, reformatAddress } from '@subwallet/extension-base/utils';
+import { anyNumberToBN, pairToAccount, reformatAddress } from '@subwallet/extension-base/utils';
 import { mergeTransactionAndSignature } from '@subwallet/extension-base/utils/eth/mergeTransactionAndSignature';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
@@ -28,12 +29,14 @@ import EventEmitter from 'eventemitter3';
 import { t } from 'i18next';
 import { BehaviorSubject, interval as rxjsInterval, map as rxjsMap } from 'rxjs';
 import { hexToU8a, isHex } from '@polkadot/util';
+import { blake2AsHex } from '@polkadot/util-crypto';
 import { GovVoteType } from "../open-gov/interface.js";
 export default class TransactionService {
   watchTransactionSubscribes = {};
   aliveProcessMap = new Map();
   transactionSubject = new BehaviorSubject({});
   aliveProcessSubject = new BehaviorSubject(this.aliveProcessMap);
+  previousWrappedTxId = {};
   cacheProcessInfo = {};
   get transactions() {
     return this.transactionSubject.getValue();
@@ -52,7 +55,7 @@ export default class TransactionService {
   }
   checkDuplicate(transaction) {
     // Check duplicated transaction
-    const existed = this.processingTransactions.filter(item => item.address === transaction.address && item.chain === transaction.chain);
+    const existed = this.processingTransactions.filter(item => item.address === transaction.address && item.chain === transaction.chain && item.id !== transaction.id);
     if (existed.length > 0) {
       return [new TransactionError(BasicTxErrorType.DUPLICATE_TRANSACTION)];
     }
@@ -120,26 +123,52 @@ export default class TransactionService {
     const isNonNativeTokenPayFee = tokenPayFeeSlug && !_isNativeTokenBySlug(tokenPayFeeSlug);
     const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.state.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
     const priceMap = (await this.state.priceService.getPrice()).priceMap;
-
-    // Get signer account
-    let signer = address;
-    const signerSubstrateProxyAddress = transactionInput.signerSubstrateProxyAddress;
     if (!transactionInput.skipFeeRecalculation) {
-      validationResponse.estimateFee = await estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee, signerSubstrateProxyAddress);
+      validationResponse.estimateFee = await estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
     }
     const chainInfoMap = this.state.chainService.getChainInfoMap();
-    let substrateProxyAccountNativeTokenAvailable;
-    if (signerSubstrateProxyAddress && !isSameAddress(signerSubstrateProxyAddress, address)) {
-      signer = signerSubstrateProxyAddress;
-      substrateProxyAccountNativeTokenAvailable = await this.state.balanceService.getTransferableBalance(signerSubstrateProxyAddress, chain, nativeTokenInfo.slug, extrinsicType);
+    if (transaction && isSubstrateTransaction(transaction)) {
+      var _chainInfo$substrateI, _chainInfo$substrateI2;
+      if ((_chainInfo$substrateI = chainInfo.substrateInfo) !== null && _chainInfo$substrateI !== void 0 && _chainInfo$substrateI.supportMultisig && !validationResponse.wrappingStatus) {
+        const pair = keyring.getPair(address);
+        if (pair.meta.isMultisig) {
+          validationResponse.wrappingStatus = SubstrateTransactionWrappingStatus.WRAPPABLE;
+          const pendingTransaction = this.state.multisigService.getPendingTxsForMultisigAddress({
+            multisigAddress: address,
+            chain
+          });
+          if (pendingTransaction.length > 0) {
+            const extrinsicTransaction = transactionInput.transaction;
+            const callData = extrinsicTransaction.method.toHex();
+            const callHash = blake2AsHex(callData);
+            const isExistPendingTx = pendingTransaction.find(tx => tx.callHash === callHash);
+            if (isExistPendingTx) {
+              validationResponse.errors.push(new TransactionError(BasicTxErrorType.DUPLICATE_TRANSACTION, t('bg.TRANSACTION_SERVICE.services.service.transaction.existingMultisigPendingTransaction')));
+            }
+          }
+        }
+      }
+      if ((_chainInfo$substrateI2 = chainInfo.substrateInfo) !== null && _chainInfo$substrateI2 !== void 0 && _chainInfo$substrateI2.supportProxy && !validationResponse.wrappingStatus && !isNonNativeTokenPayFee) {
+        const {
+          substrateProxyAccounts
+        } = await this.state.substrateProxyAccountService.getSubstrateProxyAccountGroup({
+          address,
+          chain,
+          type: validationResponse.extrinsicType,
+          excludedSubstrateProxyAccounts: validationResponse.data.selectedSubstrateProxyAccounts
+        });
+        if (substrateProxyAccounts.length) {
+          validationResponse.wrappingStatus = SubstrateTransactionWrappingStatus.WRAPPABLE;
+        }
+      }
     }
 
     // Check account signing transaction
-    checkSigningAccountForTransaction(validationResponse, chainInfoMap, signer);
+    checkSigningAccountForTransaction(validationResponse, chainInfoMap, address);
     const nativeTokenAvailable = await this.state.balanceService.getBalanceByType(address, chain, nativeTokenInfo.slug, transactionInput.balanceType, extrinsicType);
 
     // Check available balance against transaction fee
-    checkBalanceWithTransactionFee(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable, substrateProxyAccountNativeTokenAvailable);
+    checkBalanceWithTransactionFee(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable);
 
     // Warnings Ton address if bounceable and not active
     // if (transaction && isTonTransaction(transaction) && tonApi) {
@@ -234,6 +263,14 @@ export default class TransactionService {
 
     // Add Transaction
     transactions[transaction.id] = transaction;
+
+    // Store previous wrapped tx id for multisig tx to remove it when create new wrapped tx
+    if (transaction.wrappingStatus === SubstrateTransactionWrappingStatus.WRAP_RESULT) {
+      const data = transaction.data;
+      if (data.transactionId) {
+        this.previousWrappedTxId[data.transactionId] = transaction.id;
+      }
+    }
     this.transactionSubject.next({
       ...transactions
     });
@@ -262,6 +299,135 @@ export default class TransactionService {
       warnings: []
     };
   }
+
+  /**
+   * Wrapped transaction flow:
+   *
+   * Create base transaction (WRAPPABLE)
+   *   - skip fee validation
+   *   - NOT submitted to chain
+   *   - acts as the logical / UI-facing transaction
+   *   ↓
+   * Inject event emitter into base transaction
+   *   - base transaction listens to wrapped transaction events
+   *   - used to resolve the original transaction promise
+   *   ↓
+   * User selects signer in UI
+   *   - proxy account or multisig signatory
+   *   ↓
+   * Prepare wrapped transaction
+   *   - resolve actual signer
+   *   - build wrapped extrinsic (proxy / multisig)
+   *   - attach validators & event forwarders
+   *   ↓
+   * Mark base transaction as WRAP_SOURCE
+   *   ↓
+   * Create & submit wrapped transaction (WRAP_RESULT)
+   *   ↓
+   * Forward wrapped transaction events → base transaction
+   *   ↓
+   * Cleanup temporary data
+   *
+   */
+  async handleWrappedTransaction(transaction) {
+    const transactionData = transaction.data;
+
+    // Origin tx id:
+    // - transactionData.transactionId: wrapped from existing tx
+    // - transaction.id: direct wrapped tx ( when transaction was signed by proxied address )
+    const originTransactionId = transactionData.transactionId || transaction.id || '';
+
+    // Remove previous wrapped transaction (select signer flow)
+    if (this.previousWrappedTxId[originTransactionId]) {
+      this.removeTransaction(this.previousWrappedTxId[originTransactionId]);
+    }
+
+    /**
+     * ─────────────────────────────
+     * Validation phase
+     * ─────────────────────────────
+     */
+    const validatedTransaction = await this.validateTransaction(transaction);
+    const ignoreWarnings = validatedTransaction.ignoreWarnings || [];
+    const hasBlockingErrors = validatedTransaction.errors.length > 0;
+    const hasBlockingWarnings = validatedTransaction.warnings.length > 0 && validatedTransaction.warnings.some(warning => !ignoreWarnings.includes(warning.warningType));
+    if (hasBlockingErrors || hasBlockingWarnings) {
+      // Cleanup runtime-only fields before returning
+      // @ts-ignore
+      'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+      'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+      'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+      // Remove emitter before returning response
+      'emitterTransaction' in validatedTransaction && delete validatedTransaction.emitterTransaction;
+      return validatedTransaction;
+    }
+
+    // Validation passed → warnings already acknowledged
+    validatedTransaction.warnings = [];
+
+    /**
+     * ─────────────────────────────
+     * Submit wrapped transaction
+     * ─────────────────────────────
+     */
+
+    // Mark original transaction as wrapped
+    if (transactionData.transactionId) {
+      this.updateTransaction(transactionData.transactionId, {
+        wrappingStatus: SubstrateTransactionWrappingStatus.WRAP_SOURCE,
+        estimateFee: validatedTransaction.estimateFee,
+        errors: []
+      });
+    }
+    const emitter = await this.addTransaction(validatedTransaction);
+
+    /**
+     * Async side-effect:
+     * - wait for signed / success / error / timeout
+     * - mutate validatedTransaction accordingly
+     */
+    if (emitter) {
+      new Promise(resolve => {
+        const resolveWithResult = data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        };
+        if (transaction.resolveOnDone) {
+          emitter.on('success', resolveWithResult);
+        } else {
+          emitter.on('signed', resolveWithResult);
+        }
+        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();
+          }
+        });
+      }).finally(() => {
+        // Cleanup runtime-only fields
+        // @ts-ignore
+        'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+        'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+        'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+
+        // Remove base multisig transaction after approval
+        if (transactionData.multisigMetadata && transactionData.transactionId) {
+          this.removeTransaction(transactionData.transactionId);
+        }
+      });
+    }
+
+    // Remove emitter before returning response
+    'emitterTransaction' in validatedTransaction && delete validatedTransaction.emitterTransaction;
+    return validatedTransaction;
+  }
   async handleTransaction(transaction) {
     const validatedTransaction = await this.validateTransaction(transaction);
     const ignoreWarnings = validatedTransaction.ignoreWarnings || [];
@@ -277,7 +443,6 @@ export default class TransactionService {
     validatedTransaction.warnings = [];
     const emitter = await this.addTransaction(validatedTransaction);
     await new Promise((resolve, reject) => {
-      // TODO
       if (transaction.resolveOnDone) {
         emitter.on('success', data => {
           validatedTransaction.id = data.id;
@@ -329,7 +494,7 @@ export default class TransactionService {
     // Fill transaction default info
     const transactionUpdated = this.fillTransactionDefaultInfo(validatedTransaction);
 
-    // Add Transaction
+    // Add transaction
     transactionsSubject[transactionUpdated.id] = {
       ...transactionUpdated,
       emitterTransaction: emitter
@@ -493,6 +658,13 @@ export default class TransactionService {
       eventsHandler,
       step
     } = transaction;
+
+    // Inject emitter into transaction for wrapped tx flow
+    if (transaction.wrappingStatus === SubstrateTransactionWrappingStatus.WRAPPABLE) {
+      this.updateTransaction(transaction.id, {
+        emitterTransaction: emitter
+      });
+    }
     emitter.on('signed', data => {
       this.onSigned(data);
     });
@@ -712,6 +884,9 @@ export default class TransactionService {
         ...this.transactions
       });
     }
+    if (this.previousWrappedTxId[id]) {
+      delete this.previousWrappedTxId[id];
+    }
   }
   updateTransaction(id, data) {
     const transaction = this.transactions[id];
@@ -1124,6 +1299,22 @@ export default class TransactionService {
           };
           break;
         }
+      case ExtrinsicType.MULTISIG_APPROVE_TX:
+        // todo
+        historyItem.additionalInfo = parseTransactionData(transaction.data);
+        break;
+      case ExtrinsicType.MULTISIG_EXECUTE_TX:
+        // todo
+        historyItem.additionalInfo = parseTransactionData(transaction.data);
+        break;
+      case ExtrinsicType.MULTISIG_CANCEL_TX:
+        // todo
+        historyItem.additionalInfo = parseTransactionData(transaction.data);
+        break;
+      case ExtrinsicType.MULTISIG_INIT_TX:
+        // todo
+        historyItem.additionalInfo = parseTransactionData(transaction.data);
+        break;
       case ExtrinsicType.ADD_SUBSTRATE_PROXY_ACCOUNT:
         {
           const data = parseTransactionData(transaction.data);
@@ -1173,6 +1364,10 @@ export default class TransactionService {
           }
           break;
         }
+      case ExtrinsicType.SUBSTRATE_PROXY_INIT_TX:
+        // todo
+        historyItem.additionalInfo = parseTransactionData(transaction.data);
+        break;
       case ExtrinsicType.UNKNOWN:
         break;
     }
@@ -1316,20 +1511,22 @@ export default class TransactionService {
       blockHash: blockHash || '',
       blockTime
     }).catch(console.error);
-    const info = isHex(extrinsicHash) ? extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
-    this.state.notificationService.notify({
-      type: NotificationType.SUCCESS,
-      title: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionCompleted'),
-      message: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoCompleted', {
-        replace: {
-          info
-        }
-      }),
-      action: {
-        url: this.getTransactionLink(id)
-      },
-      notifyViaBrowser: true
-    });
+    if (transaction.wrappingStatus !== SubstrateTransactionWrappingStatus.WRAP_SOURCE) {
+      const info = isHex(extrinsicHash) ? extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
+      this.state.notificationService.notify({
+        type: NotificationType.SUCCESS,
+        title: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionCompleted'),
+        message: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoCompleted', {
+          replace: {
+            info
+          }
+        }),
+        action: {
+          url: this.getTransactionLink(id)
+        },
+        notifyViaBrowser: true
+      });
+    }
     this.state.eventService.emit('transaction.done', transaction);
   }
   onFailed({
@@ -1355,20 +1552,22 @@ export default class TransactionService {
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
-      const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
-      this.state.notificationService.notify({
-        type: NotificationType.ERROR,
-        title: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionFailed'),
-        message: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoFailed', {
-          replace: {
-            info
-          }
-        }),
-        action: {
-          url: this.getTransactionLink(id)
-        },
-        notifyViaBrowser: true
-      });
+      if (transaction.wrappingStatus !== SubstrateTransactionWrappingStatus.WRAP_SOURCE) {
+        const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
+        this.state.notificationService.notify({
+          type: NotificationType.ERROR,
+          title: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionFailed'),
+          message: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoFailed', {
+            replace: {
+              info
+            }
+          }),
+          action: {
+            url: this.getTransactionLink(id)
+          },
+          notifyViaBrowser: true
+        });
+      }
     }
     this.state.eventService.emit('transaction.failed', transaction);
   }
@@ -1393,20 +1592,22 @@ export default class TransactionService {
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
-      const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
-      this.state.notificationService.notify({
-        type: NotificationType.ERROR,
-        title: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionTimedOut'),
-        message: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoTimedOut', {
-          replace: {
-            info
-          }
-        }),
-        action: {
-          url: this.getTransactionLink(id)
-        },
-        notifyViaBrowser: true
-      });
+      if (transaction.wrappingStatus !== SubstrateTransactionWrappingStatus.WRAP_SOURCE) {
+        const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
+        this.state.notificationService.notify({
+          type: NotificationType.ERROR,
+          title: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionTimedOut'),
+          message: t('bg.TRANSACTION_SERVICE.services.service.transaction.transactionInfoTimedOut', {
+            replace: {
+              info
+            }
+          }),
+          action: {
+            url: this.getTransactionLink(id)
+          },
+          notifyViaBrowser: true
+        });
+      }
     }
     this.state.eventService.emit('transaction.timeout', transaction);
   }
@@ -1780,17 +1981,18 @@ export default class TransactionService {
     });
     return emitter;
   }
-  async signAndSendSubstrateTransaction({
+  signAndSendSubstrateTransaction({
     address,
     chain,
+    data,
     feeCustom,
     id,
     signAfterCreate,
-    signerSubstrateProxyAddress,
     step,
     tokenPayFeeSlug,
     transaction,
-    url
+    url,
+    wrappingStatus
   }) {
     var _this$state$chainServ;
     const tip = (feeCustom === null || feeCustom === void 0 ? void 0 : feeCustom.tip) || '0';
@@ -1803,13 +2005,13 @@ export default class TransactionService {
       extrinsicHash: id,
       processId: step === null || step === void 0 ? void 0 : step.processId
     };
-    let extrinsic = transaction;
-    let signer = address;
-    if (signerSubstrateProxyAddress && signerSubstrateProxyAddress !== address) {
-      const substrateApi = this.state.chainService.getSubstrateApi(chain);
-      await substrateApi.isReady;
-      signer = signerSubstrateProxyAddress;
-      extrinsic = substrateApi.api.tx.proxy.proxy(address, null, transaction);
+    const extrinsic = transaction;
+    const signer = address;
+    let transactionId = id;
+    if (wrappingStatus === SubstrateTransactionWrappingStatus.WRAP_RESULT) {
+      // we will use the original transaction's ID for this request,
+      // because we only want the popup to appear once and keep the old one.
+      transactionId = data.transactionId || id;
     }
 
     // const registry = extrinsic.registry;
@@ -1821,7 +2023,7 @@ export default class TransactionService {
           const {
             signature,
             signedTransaction
-          } = await this.state.requestService.signInternalTransaction(id, signer, url || EXTENSION_REQUEST_URL, payload, signAfterCreate);
+          } = await this.state.requestService.signInternalTransaction(transactionId, signer, url || EXTENSION_REQUEST_URL, payload, signAfterCreate, wrappingStatus);
           return {
             id: new Date().getTime(),
             signature,
@@ -2091,7 +2293,6 @@ export default class TransactionService {
       emitter.emit('extrinsicHash', eventData);
     });
     event.on('success', transactionStatus => {
-      console.log(transactionStatus);
       eventData.blockHash = transactionStatus.block_hash || undefined;
       eventData.blockNumber = transactionStatus.block_height || undefined;
       eventData.blockTime = transactionStatus.block_time ? transactionStatus.block_time * 1000 : undefined;

package/services/transaction-service/types.d.ts

@@ -8,7 +8,7 @@ import EventEmitter from 'eventemitter3';
 import { TransactionConfig } from 'web3-core';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 import { EventRecord } from '@polkadot/types/interfaces';
-export interface SWTransactionBase extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings' | 'signerSubstrateProxyAddress'>>, TransactionFee, SWTransactionEmitter {
+export interface SWTransactionBase extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings'>>, TransactionFee, SWTransactionEmitter {
     id: string;
     url?: string;
     isInternal: boolean;
@@ -30,6 +30,31 @@ export interface SWTransactionBase extends ValidateTransactionResponse, Partial<
     errorOnTimeOut?: boolean;
     signAfterCreate?: (id: string) => void;
     step?: BriefProcessStep;
+    wrappingStatus?: SubstrateTransactionWrappingStatus;
+}
+/**
+ * Describes how a transaction is related to wrapping (multisig / proxy).
+ */
+export declare enum SubstrateTransactionWrappingStatus {
+    /**
+     * This transaction can be wrapped.
+     * - It is a base transaction
+     * - Not wrapped yet
+     * - User may choose a signer (multisig / proxy)
+     */
+    WRAPPABLE = "WRAPPABLE",
+    /**
+     * This transaction is the source of a wrap.
+     * - It has been wrapped by another transaction
+     * - This transaction itself should NOT be signed anymore
+     */
+    WRAP_SOURCE = "WRAP_SOURCE",
+    /**
+     * This transaction is the result of wrapping another transaction.
+     * - It wraps a WRAP_SOURCE transaction
+     * - This is the transaction that will be signed and submitted
+     */
+    WRAP_RESULT = "WRAP_RESULT"
 }
 export interface SWTransaction extends SWTransactionBase {
     transaction: SubmittableExtrinsic | TransactionConfig | TonTransactionConfig | Psbt;
@@ -50,7 +75,7 @@ export interface SWTransactionEmitter {
     emitterTransaction?: TransactionEmitter;
 }
 declare type SwInputBase = Pick<SWTransactionBase, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransactionBase, 'additionalValidator' | 'eventsHandler'>>;
-export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransactionBase, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut' | 'xcmFeeDryRun' | 'signerSubstrateProxyAddress'>>, TransactionFee {
+export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransactionBase, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut' | 'xcmFeeDryRun' | 'wrappingStatus'>>, TransactionFee {
     id?: string;
     transaction?: SWTransactionBase['transaction'] | null;
     warnings?: SWTransactionBase['warnings'];
@@ -69,7 +94,7 @@ export interface SWPermitTransactionInput extends Omit<SWTransactionInput, 'tran
 export interface SWDutchTransactionInput extends Omit<SWTransactionInput, 'transaction'> {
     transaction?: SWDutchTransaction['transaction'] | null;
 }
-export declare type SWTransactionResponse = SwInputBase & Pick<SWTransactionBase, 'warnings' | 'errors'> & Partial<Pick<SWTransactionBase, 'id' | 'extrinsicHash' | 'status' | 'estimateFee' | 'xcmFeeDryRun'>> & TransactionFee & {
+export declare type SWTransactionResponse = SwInputBase & Pick<SWTransactionBase, 'warnings' | 'errors'> & Partial<Pick<SWTransactionBase, 'id' | 'extrinsicHash' | 'status' | 'estimateFee' | 'xcmFeeDryRun' | 'wrappingStatus'>> & TransactionFee & {
     processId?: string;
 };
 export declare type BitcoinTransactionData = {

package/services/transaction-service/types.js

@@ -1 +1,12 @@
-export {};
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Describes how a transaction is related to wrapping (multisig / proxy).
+ */
+export let SubstrateTransactionWrappingStatus;
+(function (SubstrateTransactionWrappingStatus) {
+  SubstrateTransactionWrappingStatus["WRAPPABLE"] = "WRAPPABLE";
+  SubstrateTransactionWrappingStatus["WRAP_SOURCE"] = "WRAP_SOURCE";
+  SubstrateTransactionWrappingStatus["WRAP_RESULT"] = "WRAP_RESULT";
+})(SubstrateTransactionWrappingStatus || (SubstrateTransactionWrappingStatus = {}));

package/types/account/info/keyring.d.ts

@@ -85,6 +85,18 @@ export interface AccountDeriveData {
     /** Derivation path */
     derivationPath?: string;
 }
+/**
+ * @interface AccountMultisigData
+ * @prop {boolean} [isMultisig] - Is multisig account
+ * */
+export interface AccountMultisigData {
+    /** Is multisig account */
+    isMultisig?: boolean;
+    /** signer addresses */
+    signers?: string[];
+    /** multisig threshold */
+    threshold?: number;
+}
 /**
  * Represents the comprehensive metadata associated with an account, combining various aspects of account data.
  * This interface extends from multiple specific metadata interfaces to provide a unified view of an account's metadata.
@@ -98,7 +110,7 @@ export interface AccountDeriveData {
  * @extends AccountInjectData - Covers data related to injected accounts, including the source of the injection.
  * @extends AccountDeriveData - Holds information about derived accounts, including the parent address and derivation path (suri).
  */
-export interface AccountMetadataData extends AccountExternalData, AccountLedgerData, AccountInjectData, AccountDeriveData {
+export interface AccountMetadataData extends AccountExternalData, AccountLedgerData, AccountInjectData, AccountDeriveData, AccountMultisigData {
 }
 export declare enum AccountSignMode {
     PASSWORD = "password",
@@ -107,6 +119,7 @@ export declare enum AccountSignMode {
     GENERIC_LEDGER = "generic-ledger",
     ECDSA_SUBSTRATE_LEDGER = "ecdsa-substrate-ledger",
     READ_ONLY = "readonly",
+    MULTISIG = "multisig",
     ALL_ACCOUNT = "all",
     INJECTED = "injected",
     UNKNOWN = "unknown"