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

package/services/keyring-service/context/account-context.js

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { AccountMigrationHandler } from '@subwallet/extension-base/services/keyring-service/context/handlers/Migration';
+import { AccountMultisigHandler } from '@subwallet/extension-base/services/keyring-service/context/handlers/Multisig';
+import { reformatAddress } from '@subwallet/extension-base/utils';
 import { AccountDeriveHandler, AccountInjectHandler, AccountJsonHandler, AccountLedgerHandler, AccountMnemonicHandler, AccountModifyHandler, AccountSecretHandler } from "./handlers/index.js";
 import { AccountState } from "./state.js";
 export class AccountContext {
@@ -17,6 +19,7 @@ export class AccountContext {
     this.modifyHandler = new AccountModifyHandler(this.parentService, this.state);
     this.secretHandler = new AccountSecretHandler(this.parentService, this.state);
     this.migrationHandler = new AccountMigrationHandler(this.parentService, this.state);
+    this.multisigHandler = new AccountMultisigHandler(this.parentService, this.state);
   }
 
   // TODO: Merge to value
@@ -139,6 +142,15 @@ export class AccountContext {
     return this.secretHandler.accountsCreateExternalV2(request);
   }
 
+  /* Multisig */
+  async accountsCreateMultisig(request) {
+    return this.multisigHandler.accountsCreateMultisig(request);
+  }
+  getSignableAccountInfos(request) {
+    const chainInfo = this.koniState.chainService.getChainInfoByKey(request.chain);
+    return this.multisigHandler.getSignableAccountInfos(request, chainInfo);
+  }
+
   /* Import ethereum account with the private key  */
   privateKeyValidateV2(request) {
     return this.secretHandler.privateKeyValidateV2(request);
@@ -254,6 +266,38 @@ export class AccountContext {
 
   /* Migration */
 
+  /* Multisig */
+
+  getMultisigAccounts() {
+    return this.state.getMultisigAccounts();
+  }
+  getMultisigAccountByAddress(address) {
+    if (!address) {
+      return undefined;
+    }
+    const allMultisigAccounts = this.getMultisigAccounts();
+    return allMultisigAccounts.find(acc => acc.accounts[0].address === reformatAddress(address));
+  }
+  getMultisigAccountInfoByAddress(address) {
+    const accountProxy = this.getMultisigAccountByAddress(address);
+    if (!accountProxy) {
+      return undefined;
+    }
+    const threshold = accountProxy.accounts[0].threshold;
+    const signers = accountProxy.accounts[0].signers;
+    const multisigAddress = accountProxy.accounts[0].address;
+    return {
+      threshold,
+      signers,
+      multisigAddress
+    };
+  }
+  getMultisigAddresses() {
+    return this.state.getMultisigAddresses();
+  }
+
+  /* Multisig */
+
   /* Others */
 
   removeNoneHardwareGenesisHash() {

package/services/keyring-service/context/handlers/Multisig.d.ts

@@ -0,0 +1,18 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { AccountMultisigError, RequestAccountCreateMultisig } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountBaseHandler } from '@subwallet/extension-base/services/keyring-service/context/handlers/Base';
+import { RequestGetSignableAccountInfos, ResponseGetSignableAccountInfos } from '@subwallet/extension-base/types/multisig';
+/**
+ * @class AccountMultisigHandler
+ * @extends AccountBaseHandler
+ * @description Handler for multisig account
+ * */
+export declare class AccountMultisigHandler extends AccountBaseHandler {
+    private validateSigners;
+    accountsCreateMultisig(request: RequestAccountCreateMultisig): Promise<AccountMultisigError[]>;
+    /**
+     * Get 1-level signatories
+     * Ignore multisig accounts that are also signatories
+     */
+    getSignableAccountInfos(request: RequestGetSignableAccountInfos, chainInfo: _ChainInfo): ResponseGetSignableAccountInfos;
+}

package/services/keyring-service/context/handlers/Multisig.js

@@ -0,0 +1,180 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { AccountMultisigErrorCode } from '@subwallet/extension-base/background/KoniTypes';
+import { AccountBaseHandler } from '@subwallet/extension-base/services/keyring-service/context/handlers/Base';
+import { AccountChainType } from '@subwallet/extension-base/types';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+import { encodeAddress, isSubstrateAddress } from '@subwallet/keyring';
+import { keyring } from '@subwallet/ui-keyring';
+import { t } from 'i18next';
+import { createKeyMulti } from '@polkadot/util-crypto';
+
+/**
+ * @class AccountMultisigHandler
+ * @extends AccountBaseHandler
+ * @description Handler for multisig account
+ * */
+export class AccountMultisigHandler extends AccountBaseHandler {
+  validateSigners(signers, threshold) {
+    const errors = [];
+    if (!signers || signers.length === 0) {
+      errors.push({
+        code: AccountMultisigErrorCode.INVALID_FILLED_ADDRESS,
+        message: t('bg.ACCOUNT.services.keyring.handler.Multisig.signersRequired')
+      });
+    }
+    if (!signers || signers.length < 2) {
+      errors.push({
+        code: AccountMultisigErrorCode.INVALID_FILLED_ADDRESS,
+        message: t('bg.ACCOUNT.services.keyring.handler.Multisig.multipleSignersRequired')
+      });
+    }
+    if (!threshold || threshold < 2 || threshold > signers.length) {
+      errors.push({
+        code: AccountMultisigErrorCode.INVALID_FILLED_THRESHOLD,
+        message: t('bg.ACCOUNT.services.keyring.handler.Multisig.invalidThreshold')
+      });
+    }
+    for (const signer of signers) {
+      if (!signer || !isSubstrateAddress(signer)) {
+        errors.push({
+          code: AccountMultisigErrorCode.INVALID_FILLED_ADDRESS,
+          message: t('bg.ACCOUNT.services.keyring.handler.Multisig.mustBeSubstrateAddress')
+        });
+        break;
+      }
+    }
+    const distinctAddress = new Set();
+    for (const signer of signers) {
+      const rAddress = reformatAddress(signer);
+      if (distinctAddress.has(rAddress)) {
+        errors.push({
+          code: AccountMultisigErrorCode.DUPLICATE_FILLED_ADDRESS,
+          message: t('bg.ACCOUNT.services.keyring.handler.Multisig.duplicateAddressFound')
+        });
+        break;
+      } else {
+        distinctAddress.add(rAddress);
+      }
+    }
+    return errors;
+  }
+  async accountsCreateMultisig(request) {
+    const {
+      name,
+      signers: _signer,
+      threshold
+    } = request;
+
+    // process signers
+    const signerError = this.validateSigners(_signer, threshold);
+    if (signerError.length > 0) {
+      return signerError;
+    }
+    const signers = _signer.map(address => reformatAddress(address));
+    const multisigKey = createKeyMulti(signers, threshold);
+    const multisigAddress = encodeAddress(multisigKey);
+    try {
+      try {
+        const exists = keyring.getPair(multisigAddress);
+        if ((exists === null || exists === void 0 ? void 0 : exists.address) === reformatAddress(multisigAddress)) {
+          var _exists$meta;
+          const existingName = ((_exists$meta = exists.meta) === null || _exists$meta === void 0 ? void 0 : _exists$meta.name) || 'Unknown';
+          return [{
+            code: AccountMultisigErrorCode.INVALID_ADDRESS,
+            message: t('bg.ACCOUNT.services.keyring.handler.Multisig.multisigAddressExists', {
+              replace: {
+                name: existingName
+              }
+            })
+          }];
+        }
+      } catch (e) {}
+      if (this.state.checkNameExists(name)) {
+        return [{
+          code: AccountMultisigErrorCode.INVALID_NAME,
+          message: t('bg.ACCOUNT.services.keyring.handler.Secret.accountNameAlreadyExists')
+        }];
+      }
+      const meta = {
+        name,
+        threshold,
+        signers,
+        isExternal: true,
+        isMultisig: true,
+        genesisHash: ''
+      };
+      const multisigPair = keyring.keyring.addFromAddress(multisigAddress, meta);
+      keyring.saveAccount(multisigPair);
+      const address = multisigPair.address;
+      const modifiedPairs = this.state.modifyPairs;
+      modifiedPairs[address] = {
+        migrated: true,
+        key: address
+      };
+      this.state.upsertModifyPairs(modifiedPairs);
+      await new Promise(resolve => {
+        this.state.saveCurrentAccountProxyId(address, () => {
+          this.state._addAddressToAuthList(address, true);
+          resolve();
+        });
+      });
+      return [];
+    } catch (e) {
+      return [{
+        code: AccountMultisigErrorCode.KEYRING_ERROR,
+        message: e.message
+      }];
+    }
+  }
+
+  /**
+   * Get 1-level signatories
+   * Ignore multisig accounts that are also signatories
+   */
+  getSignableAccountInfos(request, chainInfo) {
+    var _chainInfo$substrateI;
+    const {
+      extrinsicType,
+      multisigProxyId
+    } = request;
+    if (!((_chainInfo$substrateI = chainInfo.substrateInfo) !== null && _chainInfo$substrateI !== void 0 && _chainInfo$substrateI.supportMultisig)) {
+      return {
+        signableProxies: []
+      };
+    }
+    const allMultisigAccounts = this.state.getMultisigAccounts();
+    const allAccounts = this.state.accounts;
+    const targetMultisigAccount = allMultisigAccounts.find(acc => acc.id === multisigProxyId);
+    if (!targetMultisigAccount) {
+      return {
+        signableProxies: []
+      };
+    }
+    const signableAccountInfo = [];
+    const signers = targetMultisigAccount.accounts[0].signers;
+    const allMultisigAccountAddress = allMultisigAccounts.map(acc => acc.id);
+    for (const signer of signers) {
+      if (allMultisigAccountAddress.includes(signer)) {
+        continue;
+      }
+      const proxyId = this.state.belongUnifiedAccount(signer) || reformatAddress(signer);
+      const accountProxy = allAccounts[proxyId];
+      const substrateAccount = accountProxy === null || accountProxy === void 0 ? void 0 : accountProxy.accounts.find(acc => acc.chainType === AccountChainType.SUBSTRATE);
+      if (substrateAccount) {
+        // Check if the account can sign the extrinsic type
+        // Only support 1 level signatories
+        if (substrateAccount.transactionActions.includes(extrinsicType) && !substrateAccount.isMultisig) {
+          signableAccountInfo.push({
+            proxyId,
+            address: signer
+          });
+        }
+      }
+    }
+    return {
+      signableProxies: signableAccountInfo
+    };
+  }
+}

package/services/keyring-service/context/state.d.ts

@@ -86,6 +86,8 @@ export declare class AccountState {
     /**
      * Account ref
      * */
+    getMultisigAccounts(): AccountProxy[];
+    getMultisigAddresses(): string[];
     removeNoneHardwareGenesisHash(): void;
     updateMetadataForPair(): void;
     updateMetadataForProxy(): void;

package/services/keyring-service/context/state.js

@@ -524,6 +524,18 @@ export class AccountState {
    * Account ref
    * */
 
+  /* Multisig */
+
+  getMultisigAccounts() {
+    return Object.values(this.accounts).filter(acc => acc.accountType === AccountProxyType.MULTISIG);
+  }
+  getMultisigAddresses() {
+    const allAccounts = this.getMultisigAccounts();
+    return allAccounts.map(acc => acc.id);
+  }
+
+  /* Multisig */
+
   /* Others */
 
   removeNoneHardwareGenesisHash() {

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

@@ -0,0 +1,245 @@
+import { ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { EventService } from '@subwallet/extension-base/services/event-service';
+import { InappNotificationService } from '@subwallet/extension-base/services/inapp-notification-service';
+import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
+import { DecodeCallDataResponse } from '@subwallet/extension-base/services/multisig-service/utils';
+import { PromiseHandler } from '@subwallet/extension-base/utils';
+import { BehaviorSubject } from 'rxjs';
+import { EventItem, EventType } from '../event-service/types';
+/**
+ * Interface representing a pending multisig extrinsic with the current signer context
+ */
+export interface PendingMultisigTx extends RawPendingMultisigTx {
+    /** ID of the pending multisig extrinsic */
+    id: string;
+    /** Address of the current signer viewing this extrinsic */
+    currentSigner: string;
+}
+/**
+ * Interface representing raw pending multisig extrinsic data from the chain
+ */
+export interface RawPendingMultisigTx {
+    /** Chain identifier where the extrinsic exists */
+    chain: string;
+    /** Multisig address */
+    multisigAddress: string;
+    /** Address of the account that deposited funds */
+    depositor: string;
+    /** Hash of the call data */
+    callHash: string;
+    /** Block height where the extrinsic was created */
+    blockHeight: number;
+    /** Extrinsic index in the block */
+    extrinsicIndex: number;
+    /** Amount deposited for the multisig */
+    depositAmount: number;
+    /** List of addresses that have approved the extrinsic */
+    approvals: string[];
+    /** Number of approval required */
+    threshold: number;
+    /** List of signer addresses for the multisig */
+    signerAddresses: string[];
+    /** Hash of the extrinsic */
+    extrinsicHash: string;
+    /** Timestamp when the extrinsic was created */
+    timestamp: number;
+    /** Type of multisig extrinsic */
+    multisigTxType: MultisigTxType;
+    /** Encoded call data */
+    callData?: string;
+    /** Decoded call data with method and arguments */
+    decodedCallData?: DecodeCallDataResponse;
+}
+/**
+ * Map of pending multisig extrinsics
+ * Key is created using genPendingMultisigTxKey function
+ */
+export declare type PendingMultisigTxMap = Record<string, PendingMultisigTx>;
+/**
+ * Request interface for getting pending extrinsics
+ */
+export interface RequestGetPendingTxs {
+    /** Multisig address to query */
+    multisigAddress: string;
+    /** Optional chain identifier to filter by specific chain */
+    chain?: string;
+}
+export declare enum MultisigTxType {
+    /** Transfer extrinsic */
+    TRANSFER = "Transfer",
+    /** Transfer NFT extrinsic */
+    TRANSFER_NFT = "TransferNFT",
+    /** Staking-related extrinsic */
+    STAKING = "Staking",
+    /** Redeem extrinsic */
+    REDEEM = "Redeem",
+    /** Unstake extrinsic */
+    UNSTAKE = "Unstake",
+    /** Withdraw extrinsic */
+    WITHDRAW = "Withdraw",
+    /** Cancel unstake extrinsic */
+    CANCEL_UNSTAKE = "CancelUnstake",
+    /** Claim extrinsic */
+    CLAIM_REWARD = "ClaimReward",
+    /** Nominate extrinsic */
+    NOMINATE = "Nominate",
+    /** Lending extrinsic */
+    LENDING = "Lending",
+    /** Swap extrinsic */
+    SWAP = "Swap",
+    /** Set token pay fee extrinsic */
+    SET_TOKEN_PAY_FEE = "SetTokenPayFee",
+    /** Governance vote extrinsic */
+    GOV_VOTE = "govVote",
+    /** Governance remove vote extrinsic */
+    GOV_REMOVE_VOTE = "govRemoveVote",
+    /** Governance unlock vote extrinsic */
+    GOV_UNLOCK_VOTE = "govUnlockVote",
+    /** Proxy add extrinsic */
+    ADD_PROXY = "AddProxy",
+    /** Proxy remove extrinsic */
+    REMOVE_PROXY = "RemoveProxy",
+    /** Unknown extrinsic type */
+    UNKNOWN = "Unknown"
+}
+/**
+ * Mapping of extrinsic categories to their corresponding pallet methods
+ * Used to categorize multisig extrinsics by their call method
+ */
+export declare const MULTISIG_TX_TYPE_MAP: Record<string, string[]>;
+/**
+ * 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 declare class MultisigService implements StoppableServiceInterface {
+    private readonly eventService;
+    private readonly chainService;
+    private readonly keyringService;
+    private readonly inappNotificationService;
+    status: ServiceStatus;
+    startPromiseHandler: PromiseHandler<void>;
+    stopPromiseHandler: PromiseHandler<void>;
+    /** BehaviorSubject that holds the current map of pending multisig extrinsics */
+    private readonly pendingMultisigTxSubject;
+    /** Function to unsubscribe from all active subscriptions */
+    private unsubscribes;
+    /** Promise to check if the subscription logic is currently running */
+    private subscribePromise;
+    /** Set to track notified transaction keys to avoid duplicate notifications */
+    private readonly notifiedTxKeys;
+    /**
+     * 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: EventService, chainService: ChainService, keyringService: KeyringService, inappNotificationService: InappNotificationService);
+    /**
+     * 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
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the multisig service
+     * Unsubscribes from all active subscriptions
+     * @returns Promise that resolves when the service has stopped, or rejects on error
+     */
+    stop(): Promise<void>;
+    /**
+     * 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
+     */
+    init(): Promise<void>;
+    /**
+     * Waits for the service to start
+     * @returns Promise that resolves when the service has started
+     */
+    waitForStarted(): Promise<void>;
+    /**
+     * Waits for the service to stop
+     * @returns Promise that resolves when the service has stopped
+     */
+    waitForStopped(): Promise<void>;
+    /**
+     * 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: EventItem<EventType>[], eventTypes: EventType[]): void;
+    /**
+     * 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
+     */
+    private runSubscribePendingMultisigTxs;
+    /**
+     * 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
+     */
+    private subscribePendingMultisigTxsPromise;
+    /**
+     * 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
+     */
+    private subscribePendingMultisigTxs;
+    /**
+     * Unsubscribes from all active multisig extrinsic subscriptions
+     */
+    private runUnsubscribePendingMultisigTxs;
+    /**
+     * 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
+     */
+    private updatePendingMultisigTxSubjectByChain;
+    /**
+     * 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
+     */
+    private clearMultisigApprovalNotifications;
+    /**
+     * Creates notifications for pending multisig transactions that require approval
+     * @param pendingTxs - Array of pending multisig transactions that need approval
+     */
+    private createMultisigApprovalNotifications;
+    /**
+     * Subscribes to changes in the pending multisig extrinsic map
+     * @returns BehaviorSubject that emits updates when the extrinsic map changes
+     */
+    subscribePendingMultisigTxMap(): BehaviorSubject<PendingMultisigTxMap>;
+    /**
+     * Gets a snapshot of the current pending multisig extrinsic map
+     * @returns Copy of the current pending multisig extrinsic map
+     */
+    getPendingMultisigTxMap(): PendingMultisigTxMap;
+    /**
+     * 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: RequestGetPendingTxs): PendingMultisigTx[];
+}