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

package/services/chain-service/constants.d.ts

@@ -81,8 +81,8 @@ export declare const _TRANSFER_CHAIN_GROUP: {
     centrifuge: string[];
     disable_transfer: string[];
     truth: string[];
-    bittensor: string[];
 };
+export declare const USE_MULTILOCATION_INDEX: string[];
 export declare const _MANTA_ZK_CHAIN_GROUP: string[];
 export declare const _ZK_ASSET_PREFIX = "zk";
 export declare const _DEFAULT_MANTA_ZK_CHAIN = "calamari";

package/services/chain-service/constants.js

@@ -36,7 +36,7 @@ export const _BALANCE_CHAIN_GROUP = {
   genshiro: ['genshiro_testnet', 'genshiro'],
   equilibrium_parachain: ['equilibrium_parachain'],
   bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'hydradx_rococo', 'pendulum', 'amplitude', 'continuum_network', 'truth_network', 'jamton', 'hydradx_hollarnet'],
-  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network', 'rococo_assethub', 'liberlandTest', 'liberland', 'dentnet', 'pangolin', 'crust', 'phala', 'shibuya', 'dbcchain', 'westend_assethub', 'chainflip_assethub', 'origintrail', 'xode', 'paseo_assethub'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network', 'rococo_assethub', 'liberlandTest', 'liberland', 'dentnet', 'pangolin', 'crust', 'phala', 'shibuya', 'dbcchain', 'westend_assethub', 'chainflip_assethub', 'origintrail', 'xode', 'paseo_assethub', 'energy_web_x'],
   kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
   // perhaps there are some runtime updates
   centrifuge: ['centrifuge'],
@@ -289,16 +289,16 @@ export const _TRANSFER_CHAIN_GROUP = {
   kintsugi: ['kintsugi', 'kintsugi_test', 'interlay', 'mangatax_para'],
   genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
   bitcountry: ['pioneer', 'bitcountry'],
-  statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel', 'liberland', 'liberlandTest', 'dentnet', 'dbcchain', 'westend_assethub', 'chainflip_assethub', 'origintrail', 'xode', 'paseo_assethub'],
+  statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel', 'liberland', 'liberlandTest', 'dentnet', 'dbcchain', 'westend_assethub', 'chainflip_assethub', 'origintrail', 'xode', 'paseo_assethub', 'energy_web_x'],
   riochain: ['riochain'],
   sora_substrate: ['sora_substrate'],
   avail: ['kate', 'goldberg_testnet'],
   pendulum: ['pendulum', 'amplitude', 'amplitude_test', 'hydradx_main', 'bifrost', 'bifrost_dot', 'jamton', 'hydradx_hollarnet'],
   centrifuge: ['centrifuge'],
   disable_transfer: ['crab', 'pangolin'],
-  truth: ['truth_network'],
-  bittensor: ['bittensor']
+  truth: ['truth_network']
 };
+export const USE_MULTILOCATION_INDEX = ['energy_web_x'];
 export const _MANTA_ZK_CHAIN_GROUP = ['calamari'];
 export const _ZK_ASSET_PREFIX = 'zk';
 export const _DEFAULT_MANTA_ZK_CHAIN = 'calamari';

package/services/chain-service/index.js

@@ -1421,6 +1421,7 @@ export class ChainService {
         relaySlug: null,
         hasNativeNft: false,
         supportStaking: params.chainSpec.paraId === null,
+        supportProxy: false,
         supportSmartContract: null
       };
     } else if (params.chainSpec.evmChainId !== null) {

package/services/chain-service/utils/patch.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
-export declare const ChainListVersion = "0.2.122";
+export declare const ChainListVersion = "0.2.123";
 export interface PatchInfo {
     patchVersion: string;
     appliedVersion: string;

package/services/chain-service/utils/patch.js

@@ -5,7 +5,7 @@ const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = process.env.PATCH_CHAIN_LIST_URL || (PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev');
 const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-export const ChainListVersion = '0.2.122'; // update this when build chain-list
+export const ChainListVersion = '0.2.123'; // update this when build chain-list
 
 // todo: move this interface to chainlist
 

package/services/earning-service/handlers/native-staking/para-chain.js

@@ -12,6 +12,17 @@ import { balanceFormatter, formatNumber, parseRawNumber, reformatAddress } from
 import BigN from 'bignumber.js';
 import { BN, BN_ZERO } from '@polkadot/util';
 import BaseParaNativeStakingPoolHandler from "./base-para.js";
+async function queryDelegationScheduledRequestsFallback(api, delegator, collator) {
+  const query = api.query.parachainStaking.delegationScheduledRequests;
+  const key = await query.keys();
+  if (key[0].args.length === 1) {
+    return await query(collator);
+  } else if (key[0].args.length === 2) {
+    return await query(collator, delegator);
+  } else {
+    throw new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'More args than 2 and 1');
+  }
+}
 function calculateMantaNominatorReturn(decimal, commission, totalActiveCollators, bnAnnualInflation, blocksPreviousRound, bnCollatorExpectedBlocksPerRound, bnCollatorTotalStaked, isCountCommission) {
   const MIN_DELEGATION = new BigN(MANTA_MIN_DELEGATION);
   const factor = new BigN(10).pow(decimal);
@@ -141,7 +152,10 @@ export default class ParaNativeStakingPoolHandler extends BaseParaNativeStakingP
     const roundInfo = _roundInfo.toPrimitive();
     const currentRound = roundInfo.current;
     await Promise.all(delegatorState.delegations.map(async delegation => {
-      const [_delegationScheduledRequests, [identity], _collatorInfo, _currentBlock, _currentTimestamp] = await Promise.all([substrateApi.api.query.parachainStaking.delegationScheduledRequests(delegation.owner), parseIdentity(substrateIdentityApi, delegation.owner), substrateApi.api.query.parachainStaking.candidateInfo(delegation.owner), substrateApi.api.query.system.number(), substrateApi.api.query.timestamp.now()]);
+      const [_delegationScheduledRequests, [identity], _collatorInfo, _currentBlock, _currentTimestamp] = await Promise.all([queryDelegationScheduledRequestsFallback(substrateApi.api, address,
+      // delegator
+      delegation.owner // collator
+      ), parseIdentity(substrateIdentityApi, delegation.owner), substrateApi.api.query.parachainStaking.candidateInfo(delegation.owner), substrateApi.api.query.system.number(), substrateApi.api.query.timestamp.now()]);
       const currentBlock = _currentBlock.toPrimitive();
       const currentTimestamp = _currentTimestamp.toPrimitive();
       const collatorInfo = _collatorInfo.toPrimitive();
@@ -153,7 +167,8 @@ export default class ParaNativeStakingPoolHandler extends BaseParaNativeStakingP
       // parse unstaking info
       if (delegationScheduledRequests) {
         for (const scheduledRequest of delegationScheduledRequests) {
-          if (reformatAddress(scheduledRequest.delegator, 0) === reformatAddress(address, 0)) {
+          const requestDelegator = scheduledRequest.delegator ? scheduledRequest.delegator : address;
+          if (reformatAddress(requestDelegator, 0) === reformatAddress(address, 0)) {
             // add network prefix
             const isClaimable = scheduledRequest.whenExecutable - parseInt(currentRound) <= 0;
             const remainingEra = scheduledRequest.whenExecutable - parseInt(currentRound);

package/services/migration-service/scripts/MigrateTransactionHistoryBySymbol20251223.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateTransactionHistoryBySymbol20251223 extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/MigrateTransactionHistoryBySymbol20251223.js

@@ -0,0 +1,46 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateTransactionHistoryBySymbol20251223 extends BaseMigrationJob {
+  async run() {
+    const state = this.state;
+    try {
+      const changeSlugsMap = {
+        'gnosis-NATIVE-xDAI': 'gnosis-NATIVE-XDAI',
+        'stable-ERC20-USD₮0-0x779Ded0c9e1022225f8E0630b35a9b54bE713736': 'stable-ERC20-USDT0-0x779Ded0c9e1022225f8E0630b35a9b54bE713736',
+        'polygon-ERC20-USD₮0-0xc2132D05D31c914a87C6611C10748AEb04B58e8F': 'polygon-ERC20-USDT0-0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
+        'ethereum-ERC20-TON-0x582d872A1B094FC48F5DE31D3B73F2D9bE47def1': 'ethereum-ERC20-TONCOIN-0x582d872A1B094FC48F5DE31D3B73F2D9bE47def1',
+        'moonbeam-ERC20-USDC.axl-0xCa01a1D0993565291051daFF390892518ACfAD3A': 'moonbeam-ERC20-axlUSDC-0xCa01a1D0993565291051daFF390892518ACfAD3A'
+      };
+      const allTxs = [];
+      await Promise.all(Object.entries(changeSlugsMap).map(async ([oldSlug, newSlug], i) => {
+        const oldSlugSplit = oldSlug.split('-');
+        const oldChainSlug = oldSlugSplit[0];
+        const oldSymbolSlug = oldSlugSplit[2];
+        const newSlugSplit = newSlug.split('-');
+        const newSymbolSlug = newSlugSplit[2];
+        const filterTransactions = await state.dbService.stores.transaction.table.where({
+          chain: oldChainSlug
+        }).and(tx => {
+          var _tx$amount;
+          return ((_tx$amount = tx.amount) === null || _tx$amount === void 0 ? void 0 : _tx$amount.symbol) === oldSymbolSlug;
+        }).toArray();
+        if (filterTransactions.length > 0) {
+          for (const transaction of filterTransactions) {
+            if (transaction.amount && transaction.amount.symbol === oldSymbolSlug) {
+              transaction.amount.symbol = newSymbolSlug;
+            }
+            if (transaction.fee && transaction.fee.symbol === oldSymbolSlug) {
+              transaction.fee.symbol = newSymbolSlug;
+            }
+          }
+        }
+        allTxs.push(...filterTransactions);
+      }));
+      await state.dbService.stores.transaction.table.bulkPut(allTxs);
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+}

package/services/migration-service/scripts/databases/MigrateAssetSetting20251223.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateAssetSetting20251223 extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/databases/MigrateAssetSetting20251223.js

@@ -0,0 +1,33 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateAssetSetting20251223 extends BaseMigrationJob {
+  async run() {
+    try {
+      const changeSlugsMap = {
+        'gnosis-NATIVE-xDAI': 'gnosis-NATIVE-XDAI',
+        'stable-ERC20-USD₮0-0x779Ded0c9e1022225f8E0630b35a9b54bE713736': 'stable-ERC20-USDT0-0x779Ded0c9e1022225f8E0630b35a9b54bE713736',
+        'polygon-ERC20-USD₮0-0xc2132D05D31c914a87C6611C10748AEb04B58e8F': 'polygon-ERC20-USDT0-0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
+        'ethereum-ERC20-TON-0x582d872A1B094FC48F5DE31D3B73F2D9bE47def1': 'ethereum-ERC20-TONCOIN-0x582d872A1B094FC48F5DE31D3B73F2D9bE47def1',
+        'moonbeam-ERC20-USDC.axl-0xCa01a1D0993565291051daFF390892518ACfAD3A': 'moonbeam-ERC20-axlUSDC-0xCa01a1D0993565291051daFF390892518ACfAD3A'
+      };
+      const assetSetting = await this.state.chainService.getAssetSettings();
+      const migratedAssetSetting = {};
+      for (const [oldSlug, newSlug] of Object.entries(changeSlugsMap)) {
+        if (Object.keys(assetSetting).includes(oldSlug)) {
+          const isVisible = assetSetting[oldSlug].visible;
+          migratedAssetSetting[newSlug] = {
+            visible: isVisible
+          };
+        }
+      }
+      this.state.chainService.setAssetSettings({
+        ...assetSetting,
+        ...migratedAssetSetting
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}

package/services/migration-service/scripts/index.js

@@ -1,13 +1,12 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import MigrateAssetSetting20251107 from '@subwallet/extension-base/services/migration-service/scripts/databases/MigrateAssetSetting20251107';
-import MigrateChainPatrol from '@subwallet/extension-base/services/migration-service/scripts/MigrateChainPatrol';
-import MigrateTransactionHistoryBySymbol20251107 from '@subwallet/extension-base/services/migration-service/scripts/MigrateTransactionHistoryBySymbol20251107';
 import ClearMetadataDatabase from "./databases/ClearMetadataDatabase.js";
 import ClearMetadataForMythos from "./databases/ClearMetadataForMythos.js";
 import MigrateAssetSetting from "./databases/MigrateAssetSetting.js";
 import MigrateAssetSetting20251027 from "./databases/MigrateAssetSetting20251027.js";
+import MigrateAssetSetting20251107 from "./databases/MigrateAssetSetting20251107.js";
+import MigrateAssetSetting20251223 from "./databases/MigrateAssetSetting20251223.js";
 import MigrateEarningVersion from "./databases/MigrateEarningVersion.js";
 import ReloadMetadata from "./databases/ReloadMetadata.js";
 import MigrateLedgerAccount from "./keyring/MigrateLedgerAccount.js";
@@ -26,6 +25,7 @@ import DeleteEarningData20251105 from "./DeleteEarningData20251105.js";
 import DisableZeroBalanceTokens from "./DisableZeroBalanceTokens.js";
 import EnableVaraChain from "./EnableVaraChain.js";
 import MigrateAuthUrls from "./MigrateAuthUrls.js";
+import MigrateChainPatrol from "./MigrateChainPatrol.js";
 import MigrateImportedToken from "./MigrateImportedToken.js";
 import MigrateNetworkSettings from "./MigrateNetworkSettings.js";
 import MigrateNewUnifiedAccount from "./MigrateNewUnifiedAccount.js";
@@ -34,6 +34,8 @@ import MigrateTransactionHistory from "./MigrateTransactionHistory.js";
 import MigrateTransactionHistoryBridge from "./MigrateTransactionHistoryBridge.js";
 import MigrateTransactionHistoryBySymbol from "./MigrateTransactionHistoryBySymbol.js";
 import MigrateTransactionHistoryBySymbol20251027 from "./MigrateTransactionHistoryBySymbol20251027.js";
+import MigrateTransactionHistoryBySymbol20251107 from "./MigrateTransactionHistoryBySymbol20251107.js";
+import MigrateTransactionHistoryBySymbol20251223 from "./MigrateTransactionHistoryBySymbol20251223.js";
 import MigrateWalletReference from "./MigrateWalletReference.js";
 import OptimizeEnableToken from "./OptimizeEnableToken.js";
 export const EVERYTIME = '__everytime__';
@@ -81,5 +83,7 @@ export default {
   '1.3.64-02': MigrateTransactionHistoryBySymbol20251027,
   '1.3.65-01': DeleteEarningData20251105,
   '1.3.66-01': MigrateAssetSetting20251107,
-  '1.3.66-02': MigrateTransactionHistoryBySymbol20251107
+  '1.3.66-02': MigrateTransactionHistoryBySymbol20251107,
+  '1.3.72-01': MigrateAssetSetting20251223,
+  '1.3.72-02': MigrateTransactionHistoryBySymbol20251223
 };

package/services/open-gov/interface.d.ts

@@ -1,10 +1,11 @@
+import { BaseRequestSign } from '@subwallet/extension-base/types';
 export declare enum GovVoteType {
     AYE = "aye",
     NAY = "nay",
     SPLIT = "split",
     ABSTAIN = "abstain"
 }
-interface BaseVoteRequest {
+interface BaseVoteRequest extends BaseRequestSign {
     chain: string;
     address: string;
     referendumIndex: string;
@@ -27,7 +28,7 @@ export interface SplitAbstainVoteRequest extends BaseVoteRequest {
     nayAmount: string;
 }
 export declare type GovVoteRequest = StandardVoteRequest | SplitVoteRequest | SplitAbstainVoteRequest;
-export interface RemoveVoteRequest {
+export interface RemoveVoteRequest extends BaseRequestSign {
     address: string;
     chain: string;
     trackId: number;
@@ -131,7 +132,7 @@ export interface GovDelegationDetail {
     target: string;
     conviction: Conviction;
 }
-export interface UnlockVoteRequest {
+export interface UnlockVoteRequest extends BaseRequestSign {
     address: string;
     chain: string;
     trackIds?: number[];

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

@@ -0,0 +1,3 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { SubstrateProxyType } from '@subwallet/extension-base/types/substrateProxyAccount';
+export declare const txTypeToSubstrateProxyMap: Partial<Record<ExtrinsicType, SubstrateProxyType[]>>;

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

@@ -0,0 +1,19 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+const SUBSTRATE_PROXY_ACCOUNT_EXTRINSIC_GROUPS = {
+  STAKING: [ExtrinsicType.STAKING_BOND, ExtrinsicType.STAKING_UNBOND, ExtrinsicType.STAKING_WITHDRAW, ExtrinsicType.STAKING_JOIN_POOL, ExtrinsicType.STAKING_LEAVE_POOL, ExtrinsicType.CHANGE_EARNING_VALIDATOR, ExtrinsicType.STAKING_CANCEL_UNSTAKE, ExtrinsicType.STAKING_CLAIM_REWARD],
+  GOV: [ExtrinsicType.GOV_VOTE, ExtrinsicType.GOV_UNVOTE, ExtrinsicType.GOV_UNLOCK_VOTE],
+  PROXY: [
+  // only type any can add proxy
+  ExtrinsicType.REMOVE_SUBSTRATE_PROXY_ACCOUNT]
+};
+
+// Map extrinsic type to possible substrate proxy types that can be used
+// The governance proxy type will be support later
+export const txTypeToSubstrateProxyMap = {
+  ...Object.fromEntries(SUBSTRATE_PROXY_ACCOUNT_EXTRINSIC_GROUPS.STAKING.map(t => [t, ['Staking', 'NonTransfer']])),
+  ...Object.fromEntries(SUBSTRATE_PROXY_ACCOUNT_EXTRINSIC_GROUPS.GOV.map(t => [t, ['Governance', 'NonTransfer']])),
+  ...Object.fromEntries(SUBSTRATE_PROXY_ACCOUNT_EXTRINSIC_GROUPS.PROXY.map(t => [t, ['NonTransfer']]))
+};

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

@@ -0,0 +1,13 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+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';
+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[]>;
+    removeSubstrateProxyAccounts(data: RemoveSubstrateProxyAccountParams): Promise<TransactionData>;
+}

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

@@ -0,0 +1,159 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType } from '@subwallet/extension-base/types';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
+import { txTypeToSubstrateProxyMap } from "./constant.js";
+export default class SubstrateProxyAccountService {
+  constructor(state) {
+    this.state = state;
+  }
+  getSubstrateApi(chain) {
+    return this.state.getSubstrateApi(chain);
+  }
+
+  // Get proxied accounts for a main account
+  // Get when view details or perform transaction
+  async getSubstrateProxyAccountGroup(request) {
+    var _substrateApi$api$con, _substrateApi$api$con2;
+    const {
+      address,
+      chain,
+      excludedSubstrateProxyAccounts,
+      type
+    } = request;
+    const substrateApi = this.getSubstrateApi(chain);
+    await substrateApi.isReady;
+
+    // Get proxied accounts from on-chain data
+    const result = await substrateApi.api.query.proxy.proxies(address);
+    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 [_substrateProxyAccounts, currentSubstrateProxyDeposit] = result.toPrimitive();
+
+    // Mapping on-chain data to our defined type
+    let substrateProxyAccounts = (_substrateProxyAccounts || []).map(account => {
+      const proxyId = this.state.keyringService.context.belongUnifiedAccount(account.delegate) || reformatAddress(account.delegate);
+      return {
+        substrateProxyAddress: account.delegate,
+        substrateProxyType: account.proxyType,
+        delay: account.delay,
+        proxyId
+      };
+    });
+    if (type) {
+      const allowedSet = new Set([...(txTypeToSubstrateProxyMap[type] || []), 'Any']);
+      substrateProxyAccounts = substrateProxyAccounts.filter(p => 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);
+      });
+    }
+    const estimateSubstrateProxyDeposit = new BigN(currentSubstrateProxyDeposit).plus(factorDeposit);
+    return {
+      substrateProxyAccounts,
+      substrateProxyDeposit: new BigN(currentSubstrateProxyDeposit).gt(0) ? estimateSubstrateProxyDeposit.toFixed() : deposit.toFixed()
+    };
+  }
+
+  // Linking proxy account with main account
+  async addSubstrateProxyAccounts(data) {
+    const {
+      address,
+      chain,
+      substrateProxyAddress,
+      substrateProxyType
+    } = data;
+    if (address === substrateProxyAddress) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const substrateApi = this.getSubstrateApi(chain);
+    await substrateApi.isReady;
+
+    // Currently we not support delay time
+    return substrateApi.api.tx.proxy.addProxy(substrateProxyAddress, substrateProxyType, 0);
+  }
+
+  // Validate adding proxy account
+  async validateAddSubstrateProxyAccount(params, signerSubstrateProxyAddress) {
+    var _substrateApi$api$con3, _substrateApi$api$con4, _substrateApi$api$con5, _substrateApi$api$con6;
+    const {
+      address,
+      chain,
+      substrateProxyType
+    } = params;
+    const substrateApi = this.getSubstrateApi(chain);
+    await substrateApi.isReady;
+    const addProxyTx = substrateApi.api.tx.proxy.addProxy;
+    const proxyTypeArg = addProxyTx.meta.args.find(arg => arg.name.toString() === 'proxyType');
+    if (proxyTypeArg) {
+      const typeName = proxyTypeArg.type.toString();
+      const proxyTypeEnum = substrateApi.api.registry.createType(typeName);
+      const variants = proxyTypeEnum.defKeys;
+      if (!variants.includes(substrateProxyType)) {
+        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;
+    const currentProxiesRaw = await substrateApi.api.query.proxy.proxies(address);
+    const [proxyList] = currentProxiesRaw.toPrimitive();
+    if (proxyList.length >= maxSubstrateProxies) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, `Maximum number of proxies reached: ${maxSubstrateProxies}`)];
+    }
+
+    // Ensure enough balance for deposit + fee
+    const transferableBalance = await this.state.balanceService.getTransferableBalance(address, chain);
+    const bnTransferableBalance = new BigN(transferableBalance.value);
+    const feeInfo = await substrateApi.api.tx.proxy.addProxy(params.substrateProxyAddress, params.substrateProxyType, 0).paymentInfo(address);
+    const estimatedFee = new BigN(feeInfo.partialFee.toString());
+    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);
+    if (bnTransferableBalance.lt(totalRequired)) {
+      return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE)];
+    }
+    return [];
+  }
+
+  // Removing linked proxy accounts from main account
+  async removeSubstrateProxyAccounts(data) {
+    const {
+      chain,
+      isRemoveAll,
+      selectedSubstrateProxyAccounts
+    } = data;
+    const substrateApi = this.getSubstrateApi(chain);
+    await substrateApi.isReady;
+    const api = substrateApi.api;
+    if (isRemoveAll) {
+      return api.tx.proxy.removeProxies();
+    }
+    if (!selectedSubstrateProxyAccounts.length) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    if (selectedSubstrateProxyAccounts.length === 1) {
+      const {
+        delay,
+        substrateProxyAddress,
+        substrateProxyType
+      } = selectedSubstrateProxyAccounts[0];
+      return api.tx.proxy.removeProxy(substrateProxyAddress, substrateProxyType, delay);
+    }
+    const removeProxies = selectedSubstrateProxyAccounts.map(({
+      delay,
+      substrateProxyAddress,
+      substrateProxyType
+    }) => api.tx.proxy.removeProxy(substrateProxyAddress, substrateProxyType, delay));
+    return api.tx.utility.batchAll(removeProxies);
+  }
+}

package/services/transaction-service/index.js

@@ -15,7 +15,7 @@ import { getBaseTransactionInfo, getTransactionId, isBitcoinTransaction, isCarda
 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, pairToAccount, reformatAddress } from '@subwallet/extension-base/utils';
+import { anyNumberToBN, isSameAddress, 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';
@@ -120,18 +120,26 @@ 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);
+      validationResponse.estimateFee = await estimateFeeForTransaction(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee, signerSubstrateProxyAddress);
     }
     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);
+    }
 
     // Check account signing transaction
-
-    checkSigningAccountForTransaction(validationResponse, chainInfoMap);
+    checkSigningAccountForTransaction(validationResponse, chainInfoMap, signer);
     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);
+    checkBalanceWithTransactionFee(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable, substrateProxyAccountNativeTokenAvailable);
 
     // Warnings Ton address if bounceable and not active
     // if (transaction && isTonTransaction(transaction) && tonApi) {
@@ -746,8 +754,10 @@ export default class TransactionService {
       // Will be added in next step
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
       startBlock: startBlock || 0,
-      processId: (_transaction$step3 = transaction.step) === null || _transaction$step3 === void 0 ? void 0 : _transaction$step3.processId
+      processId: (_transaction$step3 = transaction.step) === null || _transaction$step3 === void 0 ? void 0 : _transaction$step3.processId,
+      substrateProxyAddresses: []
     };
+    const substrateProxyHistories = [];
     const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
     const baseNativeAmount = {
       value: '0',
@@ -1114,6 +1124,55 @@ export default class TransactionService {
           };
           break;
         }
+      case ExtrinsicType.ADD_SUBSTRATE_PROXY_ACCOUNT:
+        {
+          const data = parseTransactionData(transaction.data);
+          const substrateProxyAddress = data.substrateProxyAddress;
+          historyItem.substrateProxyAddresses = [substrateProxyAddress];
+          substrateProxyHistories.push({
+            ...historyItem,
+            substrateProxyAddresses: [substrateProxyAddress]
+          });
+          try {
+            const substrateProxyAccount = keyring.getPair(substrateProxyAddress);
+            if (substrateProxyAccount) {
+              substrateProxyHistories.push({
+                ...historyItem,
+                address: substrateProxyAccount.address,
+                direction: TransactionDirection.RECEIVED,
+                substrateProxyAddresses: [substrateProxyAddress]
+              });
+            }
+          } catch (e) {
+            // skip
+          }
+          break;
+        }
+      case ExtrinsicType.REMOVE_SUBSTRATE_PROXY_ACCOUNT:
+        {
+          const data = parseTransactionData(transaction.data);
+          for (const substrateProxyItem of data.selectedSubstrateProxyAccounts || []) {
+            const substrateProxyAddress = substrateProxyItem.substrateProxyAddress;
+            substrateProxyHistories.push({
+              ...historyItem,
+              substrateProxyAddresses: [substrateProxyAddress]
+            });
+            try {
+              const substrateProxyAccount = keyring.getPair(substrateProxyAddress);
+              if (substrateProxyAccount) {
+                substrateProxyHistories.push({
+                  ...historyItem,
+                  address: substrateProxyAccount.address,
+                  direction: TransactionDirection.RECEIVED,
+                  substrateProxyAddresses: [substrateProxyAddress]
+                });
+              }
+            } catch (e) {
+              // skip
+            }
+          }
+          break;
+        }
       case ExtrinsicType.UNKNOWN:
         break;
     }
@@ -1141,7 +1200,7 @@ export default class TransactionService {
     } catch (e) {
       console.warn(e);
     }
-    return [historyItem];
+    return [historyItem, ...substrateProxyHistories];
   }
   onSigned({
     id
@@ -1721,12 +1780,13 @@ export default class TransactionService {
     });
     return emitter;
   }
-  signAndSendSubstrateTransaction({
+  async signAndSendSubstrateTransaction({
     address,
     chain,
     feeCustom,
     id,
     signAfterCreate,
+    signerSubstrateProxyAddress,
     step,
     tokenPayFeeSlug,
     transaction,
@@ -1743,7 +1803,15 @@ export default class TransactionService {
       extrinsicHash: id,
       processId: step === null || step === void 0 ? void 0 : step.processId
     };
-    const extrinsic = transaction;
+    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 registry = extrinsic.registry;
     // const signedExtensions = registry.signedExtensions;
 
@@ -1753,7 +1821,7 @@ export default class TransactionService {
           const {
             signature,
             signedTransaction
-          } = await this.state.requestService.signInternalTransaction(id, address, url || EXTENSION_REQUEST_URL, payload, signAfterCreate);
+          } = await this.state.requestService.signInternalTransaction(id, signer, url || EXTENSION_REQUEST_URL, payload, signAfterCreate);
           return {
             id: new Date().getTime(),
             signature,
@@ -1775,7 +1843,7 @@ export default class TransactionService {
     //   }
     // }
 
-    extrinsic.signAsync(address, signerOption).then(async rs => {
+    extrinsic.signAsync(signer, signerOption).then(async rs => {
       // Emit signed event
       emitter.emit('signed', eventData);