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

package/services/multisig-service/utils.d.ts

@@ -0,0 +1,95 @@
+import { MultisigTxType } from '@subwallet/extension-base/services/multisig-service/index';
+import { ApiPromise } from '@polkadot/api';
+import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
+import { Block } from '@polkadot/types/interfaces';
+import { AnyJson } from '@polkadot/types/types';
+import { HexString } from '@polkadot/util/types';
+export declare const DEFAULT_BLOCK_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
+export declare const DEFAULT_MAX_WEIGHT: {
+    refTime: string;
+    proofSize: string;
+};
+/**
+ * Request interface for getting call data from a block
+ */
+interface GetCallDataRequest {
+    /** Hash of the call data */
+    callHash: HexString;
+    /** Index of the extrinsic in the block */
+    extrinsicIndex: number;
+    /** Block containing the extrinsic */
+    block: Block;
+}
+/**
+ * Request interface for decoding call data
+ */
+interface DecodeCallDataRequest {
+    /** Sub API instance */
+    api: ApiPromise;
+    /** Optional encoded call data to decode */
+    callData?: HexString;
+}
+/**
+ * Response interface for decoded call data
+ */
+export interface DecodeCallDataResponse {
+    /** Method name of the call */
+    method: string;
+    /** Section/pallet name of the call */
+    section: string;
+    /** Decoded arguments of the call */
+    args: AnyJson;
+}
+/**
+ * Extracts call data from a block's extrinsic
+ * Finds the inner call within multisig extrinsic and verifies it matches the call hash
+ * @param block - Block containing the extrinsic
+ * @param callHash - Expected hash of the call data
+ * @param extrinsicIndex - Index of the extrinsic in the block
+ * @returns Hex-encoded call data if found and verified, undefined otherwise
+ */
+export declare function getCallData({ block, callHash, extrinsicIndex }: GetCallDataRequest): HexString | undefined;
+/**
+ * Decodes call data into a human-readable format
+ * @param api - Polkadot API instance
+ * @param callData - Hex-encoded call data to decode
+ * @returns Decoded call data with method, section, and args, or undefined if callData is not provided
+ */
+export declare function decodeCallData({ api, callData }: DecodeCallDataRequest): DecodeCallDataResponse | undefined;
+/**
+ * Determines the type of multisig extrinsic based on decoded call data
+ * Maps pallet methods to extrinsic types (Transfer, Staking, Lending, etc.)
+ * @param decodedCallData - Decoded call data containing section and method
+ * @returns The type of multisig extrinsic, or UNKNOWN if not recognized
+ */
+export declare function getMultisigTxType(decodedCallData: DecodeCallDataResponse | undefined): MultisigTxType;
+/**
+ * Generates a unique key for a pending multisig extrinsic
+ * Used as the key in the PendingMultisigTxMap
+ * @param chain - Chain identifier
+ * @param multisigAddress - Multisig address
+ * @param signerAddress - Address of the signer
+ * @param extrinsicHash - Hash of the extrinsic
+ * @returns Unique key string for the extrinsic
+ */
+export declare function genPendingMultisigTxKey(chain: string, multisigAddress: string, signerAddress: string, extrinsicHash: string): string;
+/**
+ * Calculate deposit amount: depositAmount = depositBase + threshold * depositFactor
+ * In case threshold equal to 1, return undefined
+ * @param depositBase - Base deposit amount as a string
+ * @param threshold - Multisig threshold
+ * @param depositFactor - Deposit factor per additional signer as a string
+ * @returns Calculated deposit amount as a string
+ */
+export declare function calcDepositAmount(depositBase: string, threshold: number, depositFactor: string): string;
+/**
+ * Creates an init multisig extrinsic using the asMulti method
+ * @param api - Polkadot API instance
+ * @param threshold - Multisig threshold
+ * @param signers - Array of signer addresses
+ * @param signer - Address of the current signer
+ * @param extrinsic - Original extrinsic to be wrapped in multisig
+ * @returns SubmittableExtrinsic representing the multisig transaction
+ */
+export declare function createInitMultisigExtrinsic(api: ApiPromise, threshold: number, signers: string[], signer: string, extrinsic: SubmittableExtrinsic): SubmittableExtrinsic;
+export {};

package/services/multisig-service/utils.js

@@ -0,0 +1,227 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { MULTISIG_TX_TYPE_MAP, MultisigTxType } from '@subwallet/extension-base/services/multisig-service/index';
+import { isSameAddress } from '@subwallet/extension-base/utils';
+import { blake2AsHex, sortAddresses } from '@polkadot/util-crypto';
+export const DEFAULT_BLOCK_HASH = '0x0000000000000000000000000000000000000000000000000000000000000000';
+export const DEFAULT_MAX_WEIGHT = {
+  refTime: '0',
+  proofSize: '0'
+};
+
+/**
+ * Request interface for getting call data from a block
+ */
+
+/**
+ * Request interface for decoding call data
+ */
+
+/**
+ * Response interface for decoded call data
+ */
+
+/**
+ * Extracts call data from a block's extrinsic
+ * Finds the inner call within multisig extrinsic and verifies it matches the call hash
+ * @param block - Block containing the extrinsic
+ * @param callHash - Expected hash of the call data
+ * @param extrinsicIndex - Index of the extrinsic in the block
+ * @returns Hex-encoded call data if found and verified, undefined otherwise
+ */
+export function getCallData({
+  block,
+  callHash,
+  extrinsicIndex
+}) {
+  const extrinsic = block.extrinsics[extrinsicIndex];
+  if (!extrinsic) {
+    return undefined;
+  }
+  const innerCall = findInnerExtrinsicCall(extrinsic);
+  if (!innerCall) {
+    return undefined;
+  }
+  const callData = innerCall === null || innerCall === void 0 ? void 0 : innerCall.toHex();
+  if (!callData || !(blake2AsHex(callData) === callHash)) {
+    return undefined;
+  }
+  return callData;
+}
+
+/**
+ * Type guard to check if a codec is a Call type
+ * @param codec - Codec object to check
+ * @returns True if the codec is a Call, false otherwise
+ */
+function isCall(codec) {
+  return 'args' in codec && 'method' in codec && 'section' in codec;
+}
+
+/**
+ * Finds the inner call within a multisig extrinsic
+ * Handles nested calls in multisig.asMulti and batchAll operations
+ * @param extrinsic - Extrinsic to search for inner call
+ * @returns The inner Call if found, null otherwise
+ */
+function findInnerExtrinsicCall(extrinsic) {
+  const findAsMulti = method => {
+    const MULTISIG_EXTRINSIC_CALL_INDEX = 3;
+    const WRAP_EXTRINSIC_CALL_INDEX = 2;
+    if (!method) {
+      return null;
+    }
+    const {
+      method: callMethod,
+      section
+    } = method.toHuman();
+    if (callMethod === 'asMulti' && section === 'multisig') {
+      const arg = method.args[MULTISIG_EXTRINSIC_CALL_INDEX];
+      return isCall(arg) ? arg : null;
+    }
+    if (callMethod === 'batchAll' && method.args.length > 0) {
+      const firstArg = method.args[0];
+      for (const item of firstArg) {
+        if (isCall(item)) {
+          const result = findAsMulti(item);
+          if (result) {
+            return result;
+          }
+        }
+      }
+    }
+    if (method.args && method.args.length > WRAP_EXTRINSIC_CALL_INDEX) {
+      const wrappedArg = method.args[WRAP_EXTRINSIC_CALL_INDEX];
+      if (isCall(wrappedArg)) {
+        return findAsMulti(wrappedArg);
+      }
+    }
+    return null;
+  };
+  return findAsMulti(extrinsic.method);
+}
+
+/**
+ * Decodes call data into a human-readable format
+ * @param api - Polkadot API instance
+ * @param callData - Hex-encoded call data to decode
+ * @returns Decoded call data with method, section, and args, or undefined if callData is not provided
+ */
+export function decodeCallData({
+  api,
+  callData
+}) {
+  if (callData) {
+    return api.createType('Call', callData).toHuman();
+  }
+  return undefined;
+}
+
+/**
+ * Determines the type of multisig extrinsic based on decoded call data
+ * Maps pallet methods to extrinsic types (Transfer, Staking, Lending, etc.)
+ * @param decodedCallData - Decoded call data containing section and method
+ * @returns The type of multisig extrinsic, or UNKNOWN if not recognized
+ */
+export function getMultisigTxType(decodedCallData) {
+  if (!decodedCallData) {
+    return MultisigTxType.UNKNOWN;
+  }
+  const sectionMethod = `${decodedCallData.section}.${decodedCallData.method}`;
+  if (MULTISIG_TX_TYPE_MAP.transfer.includes(sectionMethod)) {
+    return MultisigTxType.TRANSFER;
+  }
+  if (MULTISIG_TX_TYPE_MAP.transfer_nft.includes(sectionMethod)) {
+    return MultisigTxType.TRANSFER_NFT;
+  }
+  if (MULTISIG_TX_TYPE_MAP.staking.includes(sectionMethod)) {
+    return MultisigTxType.STAKING;
+  }
+  if (MULTISIG_TX_TYPE_MAP.redeem.includes(sectionMethod)) {
+    return MultisigTxType.REDEEM;
+  }
+  if (MULTISIG_TX_TYPE_MAP.unstake.includes(sectionMethod)) {
+    return MultisigTxType.UNSTAKE;
+  }
+  if (MULTISIG_TX_TYPE_MAP.withdraw.includes(sectionMethod)) {
+    return MultisigTxType.WITHDRAW;
+  }
+  if (MULTISIG_TX_TYPE_MAP.cancelUnstake.includes(sectionMethod)) {
+    return MultisigTxType.CANCEL_UNSTAKE;
+  }
+  if (MULTISIG_TX_TYPE_MAP.claim.includes(sectionMethod)) {
+    return MultisigTxType.CLAIM_REWARD;
+  }
+  if (MULTISIG_TX_TYPE_MAP.nominate.includes(sectionMethod)) {
+    return MultisigTxType.NOMINATE;
+  }
+  if (MULTISIG_TX_TYPE_MAP.lending.includes(sectionMethod)) {
+    return MultisigTxType.LENDING;
+  }
+  if (MULTISIG_TX_TYPE_MAP.govVote.includes(sectionMethod)) {
+    return MultisigTxType.GOV_VOTE;
+  }
+  if (MULTISIG_TX_TYPE_MAP.govUnlockVote.includes(sectionMethod)) {
+    return MultisigTxType.GOV_UNLOCK_VOTE;
+  }
+  if (MULTISIG_TX_TYPE_MAP.govRemoveVote.includes(sectionMethod)) {
+    return MultisigTxType.GOV_REMOVE_VOTE;
+  }
+  if (MULTISIG_TX_TYPE_MAP.swap.includes(sectionMethod)) {
+    return MultisigTxType.SWAP;
+  }
+  if (MULTISIG_TX_TYPE_MAP.setTokenPayFee.includes(sectionMethod)) {
+    return MultisigTxType.SET_TOKEN_PAY_FEE;
+  }
+  if (MULTISIG_TX_TYPE_MAP.addProxy.includes(sectionMethod)) {
+    return MultisigTxType.ADD_PROXY;
+  }
+  if (MULTISIG_TX_TYPE_MAP.removeProxy.includes(sectionMethod)) {
+    return MultisigTxType.REMOVE_PROXY;
+  }
+  return MultisigTxType.UNKNOWN;
+}
+
+/**
+ * Generates a unique key for a pending multisig extrinsic
+ * Used as the key in the PendingMultisigTxMap
+ * @param chain - Chain identifier
+ * @param multisigAddress - Multisig address
+ * @param signerAddress - Address of the signer
+ * @param extrinsicHash - Hash of the extrinsic
+ * @returns Unique key string for the extrinsic
+ */
+export function genPendingMultisigTxKey(chain, multisigAddress, signerAddress, extrinsicHash) {
+  return `${chain}___${multisigAddress}___${signerAddress}______${extrinsicHash}`;
+}
+
+/**
+ * Calculate deposit amount: depositAmount = depositBase + threshold * depositFactor
+ * In case threshold equal to 1, return undefined
+ * @param depositBase - Base deposit amount as a string
+ * @param threshold - Multisig threshold
+ * @param depositFactor - Deposit factor per additional signer as a string
+ * @returns Calculated deposit amount as a string
+ */
+export function calcDepositAmount(depositBase, threshold, depositFactor) {
+  if (threshold === 1) {
+    return '0';
+  }
+  return (BigInt(depositBase) + BigInt(threshold) * BigInt(depositFactor)).toString();
+}
+
+/**
+ * Creates an init multisig extrinsic using the asMulti method
+ * @param api - Polkadot API instance
+ * @param threshold - Multisig threshold
+ * @param signers - Array of signer addresses
+ * @param signer - Address of the current signer
+ * @param extrinsic - Original extrinsic to be wrapped in multisig
+ * @returns SubmittableExtrinsic representing the multisig transaction
+ */
+export function createInitMultisigExtrinsic(api, threshold, signers, signer, extrinsic) {
+  const otherSignatories = signers.filter(s => !isSameAddress(s, signer));
+  return api.tx.multisig.asMulti(threshold, sortAddresses(otherSignatories), null, extrinsic, DEFAULT_MAX_WEIGHT // default max weight for init multisig tx
+  );
+}

package/services/request-service/handler/SubstrateRequestHandler.d.ts

@@ -14,5 +14,6 @@ export default class SubstrateRequestHandler {
     get numSubstrateRequests(): number;
     sign(url: string, request: RequestSign, _id?: string): Promise<ResponseSigning>;
     signTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON, onSign?: (id: string) => void): Promise<ResponseSigning>;
+    signWrappedTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON, onSign?: (id: string) => void): Promise<ResponseSigning>;
     resetWallet(): void;
 }

package/services/request-service/handler/SubstrateRequestHandler.js

@@ -1,7 +1,9 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import RequestExtrinsicSign from '@subwallet/extension-base/background/RequestExtrinsicSign';
+import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { isInternalRequest } from '@subwallet/extension-base/utils/request';
 import { BehaviorSubject } from 'rxjs';
@@ -94,6 +96,29 @@ export default class SubstrateRequestHandler {
       onSign === null || onSign === void 0 ? void 0 : onSign(id);
     });
   }
+
+  // used for wrapped tx where we don't want to show popup for internal requests
+  // transaction is multisig or proxy transaction
+  async signWrappedTransaction(id, address, url, payload, onSign) {
+    const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+    if (isAlwaysRequired && !onSign) {
+      this.#requestService.keyringService.lock();
+    }
+    if (!this.#substrateRequests[id]) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST));
+    }
+    return new Promise((resolve, reject) => {
+      this.#substrateRequests[id] = {
+        ...this.signComplete(id, resolve, reject),
+        address,
+        id,
+        request: new RequestExtrinsicSign(payload),
+        url: url
+      };
+      this.signSubject.next(this.allSubstrateRequests);
+      onSign === null || onSign === void 0 ? void 0 : onSign(id);
+    });
+  }
   resetWallet() {
     for (const request of Object.values(this.#substrateRequests)) {
       request.reject(new Error('Reset wallet'));

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

@@ -4,6 +4,7 @@ import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
+import { SubstrateTransactionWrappingStatus } from '@subwallet/extension-base/services/transaction-service/types';
 import { WalletConnectNotSupportRequest, WalletConnectSessionRequest } from '@subwallet/extension-base/services/wallet-connect-service/types';
 import { MetadataDef } from '@subwallet/extension-inject/types';
 import { BehaviorSubject } from 'rxjs';
@@ -54,7 +55,7 @@ export default class RequestService {
     get confirmationsQueueSubjectTon(): BehaviorSubject<ConfirmationsQueueTon>;
     get confirmationsQueueSubjectCardano(): BehaviorSubject<ConfirmationsQueueCardano>;
     getSignRequest(id: string): import("./types").SignRequest | undefined;
-    signInternalTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON, onSign?: (id: string) => void): Promise<ResponseSigning>;
+    signInternalTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON, onSign?: (id: string) => void, isWrappedTx?: SubstrateTransactionWrappingStatus): Promise<ResponseSigning>;
     addConfirmation<CT extends ConfirmationType>(id: string, url: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): Promise<ConfirmationDefinitions[CT][1]>;
     addConfirmationTon<CT extends ConfirmationTypeTon>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsTon[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsTon[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsTon[CT][1]>;
     addConfirmationCardano<CT extends ConfirmationTypeCardano>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsCardano[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsCardano[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsCardano[CT][1]>;

package/services/request-service/index.js

@@ -3,6 +3,7 @@
 
 import BitcoinRequestHandler from '@subwallet/extension-base/services/request-service/handler/BitcoinRequestHandler';
 import CardanoRequestHandler from '@subwallet/extension-base/services/request-service/handler/CardanoRequestHandler';
+import { SubstrateTransactionWrappingStatus } from '@subwallet/extension-base/services/transaction-service/types';
 import TonRequestHandler from "./handler/TonRequestHandler.js";
 import { AuthRequestHandler, ConnectWCRequestHandler, EvmRequestHandler, MetadataRequestHandler, NotSupportWCRequestHandler, PopupHandler, SubstrateRequestHandler } from "./handler/index.js";
 export default class RequestService {
@@ -166,7 +167,10 @@ export default class RequestService {
   getSignRequest(id) {
     return this.#substrateRequestHandler.getSignRequest(id);
   }
-  async signInternalTransaction(id, address, url, payload, onSign) {
+  async signInternalTransaction(id, address, url, payload, onSign, isWrappedTx) {
+    if (isWrappedTx === SubstrateTransactionWrappingStatus.WRAP_RESULT) {
+      return this.#substrateRequestHandler.signWrappedTransaction(id, address, url, payload, onSign);
+    }
     return this.#substrateRequestHandler.signTransaction(id, address, url, payload, onSign);
   }
   addConfirmation(id, url, type, payload, options = {}, validator) {

package/services/storage-service/DatabaseService.d.ts

@@ -13,7 +13,7 @@ import { HistoryQuery } from '@subwallet/extension-base/services/storage-service
 import YieldPoolStore from '@subwallet/extension-base/services/storage-service/db-stores/YieldPoolStore';
 import YieldPositionStore from '@subwallet/extension-base/services/storage-service/db-stores/YieldPositionStore';
 import { BalanceItem, ProcessTransactionData, YieldPoolInfo, YieldPoolType, YieldPositionInfo } from '@subwallet/extension-base/types';
-import { GetNotificationParams, RequestSwitchStatusParams } from '@subwallet/extension-base/types/notification';
+import { GetNotificationParams, MarkAllReadParams, RequestSwitchStatusParams } from '@subwallet/extension-base/types/notification';
 import { Subscription } from 'dexie';
 import { DexieExportJsonStructure } from 'dexie-export-import';
 import { GovVotingInfo } from '../open-gov/interface';
@@ -131,10 +131,11 @@ export default class DatabaseService {
     updateNotification(notification: _NotificationInfo): Promise<unknown>;
     getNotificationsByParams(params: GetNotificationParams): Promise<_NotificationInfo[]>;
     cleanUpOldNotifications(overdueTime: number): Promise<number>;
+    cleanUpNotificationByIds(ids: string[]): Promise<number>;
     subscribeUnreadNotificationsCountMap(): import("dexie").Observable<Record<string, number>>;
     getUnreadNotificationsCountMap(): Promise<Record<string, number>>;
     upsertNotifications(notifications: _NotificationInfo[]): Promise<unknown>;
-    markAllRead(proxyId: string): import("dexie").PromiseExtended<number>;
+    markAllRead(params: MarkAllReadParams): import("dexie").PromiseExtended<number>;
     switchReadStatus(params: RequestSwitchStatusParams): import("dexie").PromiseExtended<number>;
     removeAccountNotifications(proxyId: string): import("dexie").PromiseExtended<number>;
     updateNotificationProxyId(proxyIds: string[], newProxyId: string, newName: string): void;

package/services/storage-service/DatabaseService.js

@@ -578,6 +578,9 @@ export default class DatabaseService {
   cleanUpOldNotifications(overdueTime) {
     return this.stores.inappNotification.cleanUpOldNotifications(overdueTime);
   }
+  cleanUpNotificationByIds(ids) {
+    return this.stores.inappNotification.cleanUpNotificationsByIds(ids);
+  }
   subscribeUnreadNotificationsCountMap() {
     return this.stores.inappNotification.subscribeUnreadNotificationsCount();
   }
@@ -587,8 +590,8 @@ export default class DatabaseService {
   upsertNotifications(notifications) {
     return this.stores.inappNotification.bulkUpsert(notifications);
   }
-  markAllRead(proxyId) {
-    return this.stores.inappNotification.markAllRead(proxyId);
+  markAllRead(params) {
+    return this.stores.inappNotification.markAllRead(params);
   }
   switchReadStatus(params) {
     return this.stores.inappNotification.switchReadStatus(params);

package/services/storage-service/db-stores/InappNotification.d.ts

@@ -1,15 +1,16 @@
 import { _NotificationInfo } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
 import BaseStore from '@subwallet/extension-base/services/storage-service/db-stores/BaseStore';
-import { GetNotificationParams, RequestSwitchStatusParams } from '@subwallet/extension-base/types/notification';
+import { GetNotificationParams, MarkAllReadParams, RequestSwitchStatusParams } from '@subwallet/extension-base/types/notification';
 export default class InappNotificationStore extends BaseStore<_NotificationInfo> {
     getNotificationInfo(id: string): Promise<_NotificationInfo | undefined>;
     getAll(): Promise<_NotificationInfo[]>;
     getNotificationsByParams(params: GetNotificationParams): Promise<_NotificationInfo[]>;
     updateNotificationProxyId(proxyIds: string[], newProxyId: string, newName: string): void;
     cleanUpOldNotifications(overdueTime: number): Promise<number>;
+    cleanUpNotificationsByIds(ids: string[]): Promise<number>;
     subscribeUnreadNotificationsCount(): import("dexie").Observable<Record<string, number>>;
     getUnreadNotificationsCountMap(): Promise<Record<string, number>>;
-    markAllRead(proxyId: string): import("dexie").PromiseExtended<number>;
+    markAllRead(params: MarkAllReadParams): import("dexie").PromiseExtended<number>;
     switchReadStatus(params: RequestSwitchStatusParams): import("dexie").PromiseExtended<number>;
     removeAccountNotifications(proxyId: string): import("dexie").PromiseExtended<number>;
 }

package/services/storage-service/db-stores/InappNotification.js

@@ -5,6 +5,7 @@ import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { NotificationTab } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
 import { getIsTabRead } from '@subwallet/extension-base/services/inapp-notification-service/utils';
 import BaseStore from '@subwallet/extension-base/services/storage-service/db-stores/BaseStore';
+import { isSameAddress } from '@subwallet/extension-base/utils';
 import { liveQuery } from 'dexie';
 export default class InappNotificationStore extends BaseStore {
   async getNotificationInfo(id) {
@@ -15,6 +16,7 @@ export default class InappNotificationStore extends BaseStore {
   }
   async getNotificationsByParams(params) {
     const {
+      metadata,
       notificationTab,
       proxyId
     } = params;
@@ -26,6 +28,15 @@ export default class InappNotificationStore extends BaseStore {
     const filteredTable = this.table.filter(item => {
       const matchesProxyId = item.proxyId === proxyId;
       const matchesReadStatus = item.isRead === getIsTabRead(notificationTab);
+      if (metadata !== null && metadata !== void 0 && metadata.multisigAddress && metadata !== null && metadata !== void 0 && metadata.chain && notificationTab === NotificationTab.MULTISIG) {
+        // @Todo This condition is service only for multisig subscribe service to get all filter by multisig address
+        // then clear it when tx is completed
+        // So, if use this condition to service other feature, need to re-check carefully
+        const multisigMetadata = item.metadata;
+        const multisigAddressOfNotification = multisigMetadata === null || multisigMetadata === void 0 ? void 0 : multisigMetadata.multisigAddress;
+        const chain = multisigMetadata === null || multisigMetadata === void 0 ? void 0 : multisigMetadata.chain;
+        return !!multisigAddressOfNotification && isSameAddress(multisigAddressOfNotification, metadata.multisigAddress) && chain === metadata.chain;
+      }
       if (isTabAll) {
         return matchesProxyId;
       }
@@ -46,6 +57,9 @@ export default class InappNotificationStore extends BaseStore {
     const currentTimestamp = Date.now();
     return this.table.filter(item => item.time <= currentTimestamp - overdueTime).delete();
   }
+  async cleanUpNotificationsByIds(ids) {
+    return this.table.where('id').anyOf(ids).delete();
+  }
   subscribeUnreadNotificationsCount() {
     return liveQuery(async () => {
       return await this.getUnreadNotificationsCountMap();
@@ -58,9 +72,13 @@ export default class InappNotificationStore extends BaseStore {
       return countMap;
     }, {});
   }
-  markAllRead(proxyId) {
+  markAllRead(params) {
+    const {
+      proxyId,
+      excludeNotificationIds = []
+    } = params;
     if (proxyId === ALL_ACCOUNT_KEY) {
-      return this.table.toCollection().modify({
+      return this.table.toCollection().filter(notification => !excludeNotificationIds.includes(notification.id)).modify({
         isRead: true
       });
     }

package/services/substrate-proxy-service/index.d.ts

@@ -2,12 +2,15 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { TransactionData } from '@subwallet/extension-base/types';
 import { AddSubstrateProxyAccountParams, RemoveSubstrateProxyAccountParams, RequestGetSubstrateProxyAccountGroup, SubstrateProxyAccountGroup } from '@subwallet/extension-base/types/substrateProxyAccount';
+import { ApiPromise } from '@polkadot/api';
+import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
+export declare function createInitSubstrateProxyExtrinsic(api: ApiPromise, proxiedAddress: string, extrinsic: SubmittableExtrinsic): SubmittableExtrinsic;
 export default class SubstrateProxyAccountService {
     protected readonly state: KoniState;
     constructor(state: KoniState);
     private getSubstrateApi;
     getSubstrateProxyAccountGroup(request: RequestGetSubstrateProxyAccountGroup): Promise<SubstrateProxyAccountGroup>;
     addSubstrateProxyAccounts(data: AddSubstrateProxyAccountParams): Promise<TransactionData>;
-    validateAddSubstrateProxyAccount(params: AddSubstrateProxyAccountParams, signerSubstrateProxyAddress?: string): Promise<TransactionError[]>;
+    validateAddSubstrateProxyAccount(params: AddSubstrateProxyAccountParams): Promise<TransactionError[]>;
     removeSubstrateProxyAccounts(data: RemoveSubstrateProxyAccountParams): Promise<TransactionData>;
 }

package/services/substrate-proxy-service/index.js

@@ -2,10 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { BasicTxErrorType } from '@subwallet/extension-base/types';
+import { AccountChainType, BasicTxErrorType } from '@subwallet/extension-base/types';
 import { reformatAddress } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
 import { txTypeToSubstrateProxyMap } from "./constant.js";
+export function createInitSubstrateProxyExtrinsic(api, proxiedAddress, extrinsic) {
+  return api.tx.proxy.proxy(proxiedAddress, null, extrinsic);
+}
 export default class SubstrateProxyAccountService {
   constructor(state) {
     this.state = state;
@@ -32,6 +35,7 @@ export default class SubstrateProxyAccountService {
     const baseDeposit = ((_substrateApi$api$con = substrateApi.api.consts.proxy.proxyDepositBase) === null || _substrateApi$api$con === void 0 ? void 0 : _substrateApi$api$con.toString()) || '0';
     const factorDeposit = ((_substrateApi$api$con2 = substrateApi.api.consts.proxy.proxyDepositFactor) === null || _substrateApi$api$con2 === void 0 ? void 0 : _substrateApi$api$con2.toString()) || '0';
     const deposit = new BigN(baseDeposit).plus(factorDeposit);
+    const allAccounts = this.state.keyringService.context.accounts;
     const [_substrateProxyAccounts, currentSubstrateProxyDeposit] = result.toPrimitive();
 
     // Mapping on-chain data to our defined type
@@ -46,11 +50,21 @@ export default class SubstrateProxyAccountService {
     });
     if (type) {
       const allowedSet = new Set([...(txTypeToSubstrateProxyMap[type] || []), 'Any']);
-      substrateProxyAccounts = substrateProxyAccounts.filter(p => allowedSet.has(p.substrateProxyType));
+      substrateProxyAccounts = substrateProxyAccounts.filter(p => {
+        if (!p.proxyId) {
+          return false;
+        }
+        const accountProxy = allAccounts[p.proxyId];
+        const substrateAccount = accountProxy === null || accountProxy === void 0 ? void 0 : accountProxy.accounts.find(acc => acc.chainType === AccountChainType.SUBSTRATE);
+        if (!substrateAccount || !substrateAccount.transactionActions.includes(type)) {
+          return false;
+        }
+        return allowedSet.has(p.substrateProxyType);
+      });
     }
     if (excludedSubstrateProxyAccounts && excludedSubstrateProxyAccounts.length > 0) {
       substrateProxyAccounts = substrateProxyAccounts.filter(p => {
-        return !excludedSubstrateProxyAccounts.some(excluded => excluded.address === p.substrateProxyAddress && excluded.substrateProxyType === p.substrateProxyType);
+        return !excludedSubstrateProxyAccounts.some(excluded => excluded.substrateProxyAddress === p.substrateProxyAddress && excluded.substrateProxyType === p.substrateProxyType);
       });
     }
     const estimateSubstrateProxyDeposit = new BigN(currentSubstrateProxyDeposit).plus(factorDeposit);
@@ -79,7 +93,7 @@ export default class SubstrateProxyAccountService {
   }
 
   // Validate adding proxy account
-  async validateAddSubstrateProxyAccount(params, signerSubstrateProxyAddress) {
+  async validateAddSubstrateProxyAccount(params) {
     var _substrateApi$api$con3, _substrateApi$api$con4, _substrateApi$api$con5, _substrateApi$api$con6;
     const {
       address,
@@ -88,6 +102,9 @@ export default class SubstrateProxyAccountService {
     } = params;
     const substrateApi = this.getSubstrateApi(chain);
     await substrateApi.isReady;
+    if (!substrateApi.api.tx.proxy || !substrateApi.api.tx.proxy.addProxy) {
+      return [new TransactionError(BasicTxErrorType.UNSUPPORTED)];
+    }
     const addProxyTx = substrateApi.api.tx.proxy.addProxy;
     const proxyTypeArg = addProxyTx.meta.args.find(arg => arg.name.toString() === 'proxyType');
     if (proxyTypeArg) {
@@ -98,9 +115,6 @@ export default class SubstrateProxyAccountService {
         return [new TransactionError(BasicTxErrorType.UNSUPPORTED, 'This proxy type is not supported on the chosen network. Select another one and try again')];
       }
     }
-    if (!substrateApi.api.tx.proxy || !substrateApi.api.tx.proxy.addProxy) {
-      return [new TransactionError(BasicTxErrorType.UNSUPPORTED)];
-    }
 
     // Validate max proxies accounts limit
     const maxSubstrateProxies = ((_substrateApi$api$con3 = substrateApi.api.consts.proxy.maxProxies) === null || _substrateApi$api$con3 === void 0 ? void 0 : (_substrateApi$api$con4 = _substrateApi$api$con3.toNumber) === null || _substrateApi$api$con4 === void 0 ? void 0 : _substrateApi$api$con4.call(_substrateApi$api$con3)) || 0;
@@ -118,7 +132,7 @@ export default class SubstrateProxyAccountService {
     const baseDeposit = ((_substrateApi$api$con5 = substrateApi.api.consts.proxy.proxyDepositBase) === null || _substrateApi$api$con5 === void 0 ? void 0 : _substrateApi$api$con5.toString()) || '0';
     const factorDeposit = ((_substrateApi$api$con6 = substrateApi.api.consts.proxy.proxyDepositFactor) === null || _substrateApi$api$con6 === void 0 ? void 0 : _substrateApi$api$con6.toString()) || '0';
     const requiredDeposit = proxyList.length === 0 ? new BigN(baseDeposit).plus(factorDeposit) : new BigN(factorDeposit);
-    const totalRequired = new BigN(requiredDeposit).plus(!signerSubstrateProxyAddress ? estimatedFee : 0);
+    const totalRequired = new BigN(requiredDeposit).plus(estimatedFee);
     if (bnTransferableBalance.lt(totalRequired)) {
       return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE)];
     }

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

@@ -69,6 +69,14 @@ const typeName = type => {
       return 'Unlock votes';
     case ExtrinsicType.CHANGE_EARNING_VALIDATOR:
       return 'Change validator';
+    case ExtrinsicType.MULTISIG_APPROVE_TX:
+      return 'Approve multisig extrinsic';
+    case ExtrinsicType.MULTISIG_EXECUTE_TX:
+      return 'Execute multisig extrinsic';
+    case ExtrinsicType.MULTISIG_CANCEL_TX:
+      return 'Cancel multisig extrinsic';
+    case ExtrinsicType.MULTISIG_INIT_TX:
+      return 'Initiate multisig extrinsic';
     case ExtrinsicType.UNKNOWN:
     default:
       return 'unknown';