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

package/services/multisig-service/index.js

@@ -0,0 +1,620 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { NotificationDescriptionMap, NotificationTitleMap } from '@subwallet/extension-base/services/inapp-notification-service/consts';
+import { NotificationActionType, NotificationTab } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
+import { decodeCallData, DEFAULT_BLOCK_HASH, genPendingMultisigTxKey, getCallData, getMultisigTxType } from '@subwallet/extension-base/services/multisig-service/utils';
+import { _reformatAddressWithChain, addLazy, createPromiseHandler, isSameAddress, reformatAddress } from '@subwallet/extension-base/utils';
+import { createLogger } from '@subwallet/extension-base/utils/logger';
+import { BehaviorSubject } from 'rxjs';
+/**
+ * Query key for multisig multisigs subscription
+ */
+const MULTISIG_QUERY_KEY = 'query_multisig_multisigs';
+
+/**
+ * Interface representing multisig extrinsic data from the Substrate pallet
+ */
+
+const multisigServiceLogger = createLogger('MultisigService');
+
+/**
+ * Interface representing a pending multisig extrinsic with the current signer context
+ */
+
+/**
+ * Interface representing raw pending multisig extrinsic data from the chain
+ */
+
+/**
+ * Map of pending multisig extrinsics
+ * Key is created using genPendingMultisigTxKey function
+ */
+
+/**
+ * Request interface for getting pending extrinsics
+ */
+
+export let MultisigTxType;
+
+/**
+ * Mapping of extrinsic categories to their corresponding pallet methods
+ * Used to categorize multisig extrinsics by their call method
+ */
+(function (MultisigTxType) {
+  MultisigTxType["TRANSFER"] = "Transfer";
+  MultisigTxType["TRANSFER_NFT"] = "TransferNFT";
+  MultisigTxType["STAKING"] = "Staking";
+  MultisigTxType["REDEEM"] = "Redeem";
+  MultisigTxType["UNSTAKE"] = "Unstake";
+  MultisigTxType["WITHDRAW"] = "Withdraw";
+  MultisigTxType["CANCEL_UNSTAKE"] = "CancelUnstake";
+  MultisigTxType["CLAIM_REWARD"] = "ClaimReward";
+  MultisigTxType["NOMINATE"] = "Nominate";
+  MultisigTxType["LENDING"] = "Lending";
+  MultisigTxType["SWAP"] = "Swap";
+  MultisigTxType["SET_TOKEN_PAY_FEE"] = "SetTokenPayFee";
+  MultisigTxType["GOV_VOTE"] = "govVote";
+  MultisigTxType["GOV_REMOVE_VOTE"] = "govRemoveVote";
+  MultisigTxType["GOV_UNLOCK_VOTE"] = "govUnlockVote";
+  MultisigTxType["ADD_PROXY"] = "AddProxy";
+  MultisigTxType["REMOVE_PROXY"] = "RemoveProxy";
+  MultisigTxType["UNKNOWN"] = "Unknown";
+})(MultisigTxType || (MultisigTxType = {}));
+export const MULTISIG_TX_TYPE_MAP = {
+  transfer: ['balances.transferAll', 'balances.transferKeepAlive', 'balances.transfer', 'foreignAssets.transfer', 'foreignAssets.transferKeepAlive', 'currencies.transfer', 'tokens.transferAll', 'tokens.transfer', 'assets.transfer', 'assetManager.transfer', 'subtensorModule.transferStake'],
+  transfer_nft: ['nft.transfer', 'nfts.transfer', 'unique.transfer', 'uniques.transfer'],
+  staking: ['homa.mint', 'vtokenMinting.mint', 'liquidStaking.stake', 'parachainStaking.joinDelegators', 'parachainStaking.delegatorStakeMore', 'dappsStaking.bondAndStake', 'parachainStaking.nominate', 'parachainStaking.bondExtra', 'collatorStaking.lock', 'collatorStaking.stake', 'parachainStaking.delegate', 'parachainStaking.delegateWithAutoCompound', 'parachainStaking.delegatorBondMore', 'staking.bond', 'pooledStaking.requestDelegate', 'subtensorModule.addStakeLimit', 'nominationPools.bondExtra', 'nominationPools.join'],
+  redeem: ['aggregatedDex.swapWithExactSupply', 'stablePool.swap', 'ammRoute.swapExactTokensForTokens'],
+  unstake: ['homa.requestRedeem', 'vtokenMinting.redeem', 'liquidStaking.unstake', 'parachainStaking.delegatorStakeLess', 'parachainStaking.leaveDelegators', 'dappsStaking.unbondAndUnstake', 'parachainStaking.scheduleNominatorUnbond', 'parachainStaking.scheduleRevokeNomination', 'collatorStaking.unstakeFrom && collatorStaking.unlock', 'parachainStaking.scheduleDelegatorBondLess', 'parachainStaking.scheduleRevokeDelegation', 'staking.unbond', 'pooledStaking.requestUndelegate', 'subtensorModule.removeStakeLimit', 'nominationPools.unbond'],
+  withdraw: ['homa.claimRedemption', 'parachainStaking.unlockUnstaked', 'dappsStaking.withdrawUnbonded', 'parachainStaking.executeNominationRequest', 'collatorStaking.release', 'parachainStaking.executeDelegationRequest', 'staking.withdrawUnbonded', 'nominationPools.withdrawUnbonded'],
+  cancelUnstake: ['parachainStaking.cancelLeaveCandidates', 'parachainStaking.cancelNominationRequest', 'parachainStaking.cancelDelegationRequest', 'staking.rebond'],
+  claim: ['parachainStaking.incrementDelegatorRewards', 'parachainStaking.claimRewards', 'dappsStaking.claimStaker', 'collatorStaking.claimRewards', 'pooledStaking.claimManualRewards', 'nominationPools.claimPayout'],
+  nominate: ['staking.nominate', 'subtensorModule.moveStake'],
+  lending: ['loans.mint', 'loans.redeem', 'loans.redeemAll'],
+  // consider remove
+  swap: ['assetConversion.swapExactTokensForTokens'],
+  setTokenPayFee: ['multiTransactionPayment.setCurrency'],
+  govVote: ['convictionVoting.vote'],
+  govRemoveVote: ['convictionVoting.removeVote'],
+  govUnlockVote: ['convictionVoting.unlock'],
+  addProxy: ['proxy.addProxy'],
+  removeProxy: ['proxy.removeProxy', 'proxy.removeProxies']
+};
+
+/**
+ * Service for managing multisig extrinsics
+ * Handles subscription to pending multisig extrinsics across supported chains
+ * and provides methods to query and monitor multisig extrinsic status
+ */
+export class MultisigService {
+  status = ServiceStatus.NOT_INITIALIZED;
+  startPromiseHandler = createPromiseHandler();
+  stopPromiseHandler = createPromiseHandler();
+
+  /** BehaviorSubject that holds the current map of pending multisig extrinsics */
+  pendingMultisigTxSubject = new BehaviorSubject({});
+  /** Function to unsubscribe from all active subscriptions */
+
+  /** Promise to check if the subscription logic is currently running */
+
+  /** Set to track notified transaction keys to avoid duplicate notifications */
+  notifiedTxKeys = new Set();
+
+  /**
+   * Creates an instance of MultisigService
+   * @param eventService - Service for handling application events
+   * @param chainService - Service for managing chain connections
+   * @param keyringService - Service for managing accounts and keyring
+   * @param inappNotificationService - Service for creating in-app notifications (optional)
+   */
+  constructor(eventService, chainService, keyringService, inappNotificationService) {
+    this.eventService = eventService;
+    this.chainService = chainService;
+    this.keyringService = keyringService;
+    this.inappNotificationService = inappNotificationService;
+    this.status = ServiceStatus.NOT_INITIALIZED;
+  }
+
+  /**
+   * Starts the multisig service
+   * Subscribes to pending multisig extrinsics for all multisig accounts
+   * @returns Promise that resolves when the service has started, or rejects on error
+   */
+  async start() {
+    try {
+      if (this.status === ServiceStatus.STOPPING) {
+        await this.waitForStopped();
+      }
+      if (this.status === ServiceStatus.STARTED || this.status === ServiceStatus.STARTING) {
+        return await this.waitForStarted();
+      }
+      this.status = ServiceStatus.STARTING;
+      await this.runSubscribePendingMultisigTxs();
+      this.stopPromiseHandler = createPromiseHandler();
+      this.status = ServiceStatus.STARTED;
+      this.eventService.emit('multisig-service.ready', true);
+      this.startPromiseHandler.resolve();
+    } catch (error) {
+      this.status = ServiceStatus.NOT_INITIALIZED;
+      this.startPromiseHandler.reject(error);
+      throw error;
+    }
+  }
+
+  /**
+   * Stops the multisig service
+   * Unsubscribes from all active subscriptions
+   * @returns Promise that resolves when the service has stopped, or rejects on error
+   */
+  async stop() {
+    try {
+      if (this.status === ServiceStatus.STARTING) {
+        await this.waitForStarted();
+      }
+      if (this.status === ServiceStatus.STOPPED || this.status === ServiceStatus.STOPPING) {
+        return await this.waitForStopped();
+      }
+      this.status = ServiceStatus.STOPPING;
+      this.runUnsubscribePendingMultisigTxs();
+      this.startPromiseHandler = createPromiseHandler();
+      this.status = ServiceStatus.STOPPED;
+      this.stopPromiseHandler.resolve();
+    } catch (error) {
+      this.stopPromiseHandler.reject(error);
+      throw error;
+    }
+  }
+
+  /**
+   * Initializes the multisig service
+   * Waits for chain and account services to be ready, then sets up event listeners
+   * @returns Promise that resolves when initialization is complete
+   */
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    await this.eventService.waitChainReady;
+    await this.eventService.waitAccountReady;
+    this.status = ServiceStatus.INITIALIZED;
+    this.eventService.onLazy(this.handleEvents.bind(this));
+  }
+
+  /**
+   * Waits for the service to start
+   * @returns Promise that resolves when the service has started
+   */
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+
+  /**
+   * Waits for the service to stop
+   * @returns Promise that resolves when the service has stopped
+   */
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+
+  /**
+   * Handles application events and reloads multisig extrinsics when needed
+   * Reloads when accounts are added/removed or when supported chain state is updated
+   * @param events - Array of event items
+   * @param eventTypes - Array of event types that occurred
+   */
+  handleEvents(events, eventTypes) {
+    let needReload = false;
+    if (eventTypes.includes('account.add') || eventTypes.includes('account.remove')) {
+      needReload = true;
+    }
+    if (eventTypes.includes('chain.updateState') || eventTypes.includes('transaction.done')) {
+      for (const event of events) {
+        if (event.type === 'chain.updateState') {
+          var _chainInfo$substrateI;
+          const chainSlug = event.data[0];
+          const chainInfo = this.chainService.getChainInfoByKey(chainSlug);
+
+          // Only reload if the updated chain is in the supported chains list
+          if ((_chainInfo$substrateI = chainInfo.substrateInfo) !== null && _chainInfo$substrateI !== void 0 && _chainInfo$substrateI.supportMultisig) {
+            needReload = true;
+            break;
+          }
+        } else if (event.type === 'transaction.done') {
+          const txResult = event.data[0];
+          if (txResult.wrappingStatus === 'WRAP_RESULT') {
+            needReload = true;
+            break;
+          }
+        }
+      }
+    }
+    if (needReload) {
+      addLazy('reloadPendingMultisigTxsByEvents', () => {
+        if (this.status === ServiceStatus.STARTED) {
+          this.runSubscribePendingMultisigTxs().catch(e => multisigServiceLogger.error('Error in handleEvents reload', e));
+        }
+      }, 2000, undefined, true);
+    }
+  }
+
+  /**
+   * Subscribes to multisig changes for all multisig addresses across supported chains
+   * Clears old subscriptions before creating new ones to avoid duplicates
+   * @returns Promise that resolves when subscription setup is complete
+   */
+  async runSubscribePendingMultisigTxs() {
+    if (this.status === ServiceStatus.STOPPING || this.status === ServiceStatus.STOPPED) {
+      return;
+    }
+    if (this.subscribePromise) {
+      return this.subscribePromise;
+    }
+    this.subscribePromise = (async () => {
+      await Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]);
+      this.runUnsubscribePendingMultisigTxs();
+      const multisigAccounts = this.keyringService.context.getMultisigAccounts();
+      if (!multisigAccounts.length) {
+        return;
+      }
+      let cancel = false;
+      const unsubList = [];
+      const activeChainInfoMap = this.chainService.getActiveChainInfoMap();
+      const supportedActiveChains = Object.values(activeChainInfoMap).reduce((rs, chainInfo) => {
+        var _chainInfo$substrateI2;
+        if ((_chainInfo$substrateI2 = chainInfo.substrateInfo) !== null && _chainInfo$substrateI2 !== void 0 && _chainInfo$substrateI2.supportMultisig) {
+          rs.push(chainInfo.slug);
+        }
+        return rs;
+      }, []);
+      for (const chain of supportedActiveChains) {
+        const chainInfo = this.chainService.getChainInfoByKey(chain);
+        for (const account of multisigAccounts) {
+          const multisigAddress = account.id;
+          const signers = account.accounts[0].signers;
+          const reformatMultisigAddress = _reformatAddressWithChain(multisigAddress, chainInfo);
+          const reformatSigners = signers.map(s => _reformatAddressWithChain(s, chainInfo));
+          const threshold = account.accounts[0].threshold;
+          const unsub = this.subscribePendingMultisigTxs(chain, reformatMultisigAddress, reformatSigners, threshold, rs => {
+            multisigServiceLogger.debug(`pending multisig txs of address ${reformatMultisigAddress}`, rs);
+            !cancel && this.updatePendingMultisigTxSubjectByChain(reformatMultisigAddress, chain, rs);
+          });
+          unsubList.push(unsub);
+        }
+      }
+      this.unsubscribes = () => {
+        cancel = true;
+        unsubList.forEach(unsub => {
+          unsub === null || unsub === void 0 ? void 0 : unsub();
+        });
+      };
+    })();
+    try {
+      await this.subscribePromise;
+    } finally {
+      this.subscribePromise = undefined;
+    }
+  }
+
+  /**
+   * Subscribes to pending multisig extrinsics for a specific multisig address on a chain
+   * Fetches initial data and sets up a subscription for updates
+   * @param chain - Chain identifier
+   * @param multisigAddress - Multisig address to monitor
+   * @param signers - List of signer addresses for the multisig
+   * @param threshold - Number of approval required
+   * @param callback - Callback function called with updated pending extrinsics
+   * @returns Function to unsubscribe from the subscription
+   */
+  async subscribePendingMultisigTxsPromise(chain, multisigAddress, signers, threshold, callback) {
+    const substrateApi = await this.chainService.getSubstrateApi(chain).isReady;
+    if (!substrateApi.api.query.multisig.multisigs) {
+      multisigServiceLogger.warn('This chain is not has multisig pallet', chain);
+      return () => undefined;
+    }
+    const keyQuery = MULTISIG_QUERY_KEY;
+    const rawKeys = await substrateApi.api.query.multisig.multisigs.keys(multisigAddress);
+    const rawKeysArgs = rawKeys.map(rawKey => rawKey.args);
+    const params = [{
+      section: 'query',
+      module: keyQuery.split('_')[1],
+      method: keyQuery.split('_')[2],
+      args: rawKeysArgs
+    }];
+    const subscription = substrateApi.subscribeDataWithMulti(params, async rs => {
+      try {
+        const items = [];
+        const pendingMultisigEntries = rs[keyQuery];
+        const blockCache = {};
+        await Promise.all(pendingMultisigEntries.map(async (_pendingMultisigInfo, index) => {
+          const pendingMultisigInfo = _pendingMultisigInfo;
+          if (!pendingMultisigInfo) {
+            return;
+          }
+          const blockHeight = pendingMultisigInfo.when.height;
+          const extrinsicIndex = pendingMultisigInfo.when.index;
+          const callHash = rawKeysArgs[index][1].toHex();
+
+          // Cache block-level data to avoid many RPC calls
+          let blockInfo = blockCache[blockHeight];
+          if (!blockInfo) {
+            const blockHash = await substrateApi.api.rpc.chain.getBlockHash(blockHeight);
+            const signedBlock = await substrateApi.api.rpc.chain.getBlock(blockHash);
+            const apiAt = await substrateApi.api.at(blockHash);
+            const timestamp = (await apiAt.query.timestamp.now()).toNumber();
+            blockInfo = {
+              blockHash,
+              signedBlock,
+              timestamp
+            };
+            blockCache[blockHeight] = blockInfo;
+          }
+          const extrinsicHash = blockInfo.signedBlock.block.extrinsics[extrinsicIndex].hash.toHex();
+          const callData = blockInfo.blockHash.toHex() === DEFAULT_BLOCK_HASH ? undefined : getCallData({
+            callHash,
+            extrinsicIndex,
+            block: blockInfo.signedBlock.block
+          });
+          const decodedCallData = decodeCallData({
+            api: substrateApi.api,
+            callData
+          });
+          items.push({
+            chain,
+            multisigAddress,
+            callHash,
+            callData,
+            decodedCallData,
+            blockHeight,
+            extrinsicIndex,
+            extrinsicHash,
+            threshold,
+            signerAddresses: signers,
+            depositAmount: pendingMultisigInfo.deposit,
+            depositor: pendingMultisigInfo.depositor,
+            approvals: pendingMultisigInfo.approvals,
+            timestamp: blockInfo.timestamp,
+            multisigTxType: getMultisigTxType(decodedCallData)
+          });
+        }));
+        callback(items);
+      } catch (error) {
+        multisigServiceLogger.error(`Multisig Service subscription error ${chain}/${multisigAddress}`, error);
+        addLazy(`resubscribeMultisig_${chain}_${multisigAddress}`, () => {
+          if (this.status === ServiceStatus.STARTED) {
+            this.runSubscribePendingMultisigTxs().catch(e => multisigServiceLogger.error('Error during resubscribeMultisig', e));
+          }
+        }, 1000, 4000, true);
+      }
+    });
+    return () => subscription.unsubscribe();
+  }
+
+  /**
+   * Wrapper function to subscribe to pending multisig extrinsics
+   * Returns an unsubscribe function that handles promise resolution
+   * @param chain - Chain identifier
+   * @param multisigAddress - Multisig address to monitor
+   * @param signers - List of signer addresses for the multisig
+   * @param threshold - Number of approval required
+   * @param callback - Callback function called with updated pending extrinsics
+   * @returns Function to unsubscribe from the subscription
+   */
+  subscribePendingMultisigTxs(chain, multisigAddress, signers, threshold, callback) {
+    const unsubPromise = this.subscribePendingMultisigTxsPromise(chain, multisigAddress, signers, threshold, callback);
+    return () => {
+      unsubPromise.then(unsub => {
+        unsub === null || unsub === void 0 ? void 0 : unsub();
+      }).catch(e => multisigServiceLogger.error('Error during unsubscribe in subscribePendingMultisigTxs', e));
+    };
+  }
+
+  /**
+   * Unsubscribes from all active multisig extrinsic subscriptions
+   */
+  runUnsubscribePendingMultisigTxs() {
+    this.unsubscribes && this.unsubscribes();
+    this.unsubscribes = undefined;
+  }
+
+  /**
+   * Updates the multisig extrinsic map for a specific chain and multisig address
+   * Removes old extrinsics and adds new ones, then notifies all subscribers
+   * Creates notifications for new pending transactions that require approval
+   * @param multisigAddress - Multisig address
+   * @param chain - Chain identifier
+   * @param rawPendingTxs - Array of raw pending multisig extrinsics to update
+   */
+  updatePendingMultisigTxSubjectByChain(multisigAddress, chain, rawPendingTxs) {
+    const allAddresses = this.keyringService.context.getAllAddresses();
+    const currentMap = this.getPendingMultisigTxMap();
+    const excludedPrefix = `${chain}___${multisigAddress}___`;
+    const filteredMap = {};
+
+    // 1. Clean old extrinsics of multisigAddress and chain
+    for (const [key, value] of Object.entries(currentMap)) {
+      if (key.startsWith(excludedPrefix)) {
+        this.notifiedTxKeys.delete(key);
+      } else {
+        filteredMap[key] = value;
+      }
+    }
+    const newTxMap = {};
+    const newNotifiedTxs = [];
+
+    // 2. Create new extrinsics of multisigAddress and chain
+    for (const rawTx of rawPendingTxs) {
+      const extrinsicHash = rawTx.extrinsicHash;
+      const signerAddresses = rawTx.signerAddresses;
+      if (!extrinsicHash || !signerAddresses || signerAddresses.length === 0) {
+        multisigServiceLogger.warn('Skipping multisig extrinsic due to missing required fields: extrinsicHash or signerAddresses');
+        continue;
+      }
+      for (const signerAddress of signerAddresses) {
+        // Do not create pending tx for account not in wallet
+        if (!allAddresses.includes(reformatAddress(signerAddress))) {
+          continue;
+        }
+        const reformatSignerAddress = _reformatAddressWithChain(signerAddress, this.chainService.getChainInfoByKey(chain));
+        const key = genPendingMultisigTxKey(chain, multisigAddress, reformatSignerAddress, extrinsicHash);
+        const pendingTx = {
+          ...rawTx,
+          currentSigner: reformatSignerAddress,
+          id: key
+        };
+        newTxMap[key] = pendingTx;
+
+        // Track new transactions that need notification
+        // Only notify if this is a new transaction (not already notified)
+        if (!this.notifiedTxKeys.has(key) && !currentMap[key]) {
+          // skip notified for account has already approved
+          if (pendingTx.approvals.includes(signerAddress)) {
+            continue;
+          }
+          newNotifiedTxs.push(pendingTx);
+          this.notifiedTxKeys.add(key);
+        }
+      }
+    }
+
+    // 3. Replace the extrinsics of multisigAddress and chain
+    // Find approved transactions to clear notifications
+    this.clearMultisigApprovalNotifications(newTxMap, multisigAddress, chain).catch(e => multisigServiceLogger.error('Failed to clear multisig approval notifications:', e));
+    this.pendingMultisigTxSubject.next({
+      ...filteredMap,
+      ...newTxMap
+    });
+
+    // 4. Create notifications for new pending transactions
+    if (newNotifiedTxs.length > 0) {
+      this.createMultisigApprovalNotifications(newNotifiedTxs).catch(error => {
+        multisigServiceLogger.error('Failed to create multisig approval notifications:', error);
+      });
+    }
+  }
+
+  /**
+   * Clears notifications for approved pending multisig transactions
+   * @private
+   * @param newTxMap - Map of current pending multisig transactions
+   * @param multisigAddress - Multisig address
+   * @param chain - ChainSlug of the multisig transactions
+   */
+  async clearMultisigApprovalNotifications(newTxMap, multisigAddress, chain) {
+    const currentNotifications = await this.inappNotificationService.fetchNotificationsByParams({
+      notificationTab: NotificationTab.MULTISIG,
+      proxyId: ALL_ACCOUNT_KEY,
+      metadata: {
+        multisigAddress,
+        chain
+      }
+    });
+    const unapprovedPendingTxs = Object.values(newTxMap).reduce((set, tx) => {
+      if (!tx.approvals.find(address => isSameAddress(tx.currentSigner, address))) {
+        set.add(tx.id);
+      }
+      return set;
+    }, new Set());
+    const notificationsIdsToDelete = currentNotifications.reduce((ids, notification) => {
+      const metadata = notification.metadata.multisigKey;
+      if (!unapprovedPendingTxs.has(metadata)) {
+        ids.push(notification.id);
+      }
+      return ids;
+    }, []);
+    if (notificationsIdsToDelete.length > 0) {
+      await this.inappNotificationService.cleanUpNotificationByIds(notificationsIdsToDelete);
+    }
+  }
+
+  /**
+   * Creates notifications for pending multisig transactions that require approval
+   * @param pendingTxs - Array of pending multisig transactions that need approval
+   */
+  async createMultisigApprovalNotifications(pendingTxs) {
+    const notifications = pendingTxs.map(tx => {
+      const actionType = NotificationActionType.MULTISIG_APPROVAL;
+      const timestamp = Date.now();
+      const multisigKey = genPendingMultisigTxKey(tx.chain, tx.multisigAddress, tx.currentSigner, tx.extrinsicHash);
+      const notificationId = `${actionType}___${multisigKey}___${timestamp}`;
+      return {
+        id: notificationId,
+        address: reformatAddress(tx.currentSigner),
+        // save notification to default address because it's managed by account
+        title: NotificationTitleMap[actionType],
+        description: NotificationDescriptionMap[actionType](),
+        time: timestamp,
+        extrinsicType: ExtrinsicType.MULTISIG_APPROVE_TX,
+        isRead: false,
+        actionType,
+        metadata: {
+          multisigKey,
+          chain: tx.chain,
+          multisigAddress: tx.multisigAddress,
+          extrinsicHash: tx.extrinsicHash,
+          callHash: tx.callHash,
+          blockHeight: tx.blockHeight,
+          extrinsicIndex: tx.extrinsicIndex,
+          currentSigner: tx.currentSigner,
+          approvals: tx.approvals,
+          multisigTxType: tx.multisigTxType
+        }
+      };
+    });
+    multisigServiceLogger.debug('notifications', notifications);
+
+    // Group notifications by address to batch write
+    const notificationsByAddress = {};
+    for (const notification of notifications) {
+      const address = notification.address;
+      if (!notificationsByAddress[address]) {
+        notificationsByAddress[address] = [];
+      }
+      notificationsByAddress[address] = [...notificationsByAddress[address], notification];
+    }
+
+    // Write notifications for each address
+    for (const [address, addressNotifications] of Object.entries(notificationsByAddress)) {
+      if (!address || !addressNotifications || !addressNotifications.length) {
+        continue;
+      }
+      await this.inappNotificationService.validateAndWriteNotificationsToDB(addressNotifications, address);
+    }
+  }
+
+  /**
+   * Subscribes to changes in the pending multisig extrinsic map
+   * @returns BehaviorSubject that emits updates when the extrinsic map changes
+   */
+  subscribePendingMultisigTxMap() {
+    return this.pendingMultisigTxSubject;
+  }
+
+  /**
+   * Gets a snapshot of the current pending multisig extrinsic map
+   * @returns Copy of the current pending multisig extrinsic map
+   */
+  getPendingMultisigTxMap() {
+    return {
+      ...this.pendingMultisigTxSubject.getValue()
+    };
+  }
+
+  /**
+   * Gets pending extrinsics for a specific multisig address
+   * @param request - Request object containing the multisig address
+   * @returns Array of pending multisig extrinsics matching the criteria
+   */
+  getPendingTxsForMultisigAddress(request) {
+    const {
+      chain,
+      multisigAddress
+    } = request;
+    const currentMap = this.getPendingMultisigTxMap();
+    if (chain) {
+      return Object.values(currentMap).filter(tx => isSameAddress(tx.multisigAddress, multisigAddress) && tx.chain === chain);
+    }
+    return Object.values(currentMap).filter(tx => isSameAddress(tx.multisigAddress, multisigAddress));
+  }
+}