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

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);
 

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

@@ -8,7 +8,7 @@ import EventEmitter from 'eventemitter3';
 import { TransactionConfig } from 'web3-core';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
 import { EventRecord } from '@polkadot/types/interfaces';
-export interface SWTransactionBase extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings'>>, TransactionFee, SWTransactionEmitter {
+export interface SWTransactionBase extends ValidateTransactionResponse, Partial<Pick<BaseRequestSign, 'ignoreWarnings' | 'signerSubstrateProxyAddress'>>, TransactionFee, SWTransactionEmitter {
     id: string;
     url?: string;
     isInternal: boolean;
@@ -50,7 +50,7 @@ export interface SWTransactionEmitter {
     emitterTransaction?: TransactionEmitter;
 }
 declare type SwInputBase = Pick<SWTransactionBase, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransactionBase, 'additionalValidator' | 'eventsHandler'>>;
-export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransactionBase, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut' | 'xcmFeeDryRun'>>, TransactionFee {
+export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransactionBase, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut' | 'xcmFeeDryRun' | 'signerSubstrateProxyAddress'>>, TransactionFee {
     id?: string;
     transaction?: SWTransactionBase['transaction'] | null;
     warnings?: SWTransactionBase['warnings'];

package/services/transaction-service/utils.js

@@ -25,6 +25,9 @@ function getBlockExplorerAccountRoute(explorerLink) {
   if (explorerLink.includes('devnet-explorer.mosaicchain.io')) {
     return 'accounts';
   }
+  if (explorerLink.includes('mainnet-gw2.mosaicchain.io')) {
+    return 'accounts';
+  }
   if (explorerLink.includes('statescan.io')) {
     return '#/accounts';
   }
@@ -53,7 +56,7 @@ function getBlockExplorerAccountRoute(explorerLink) {
     return 'account';
   }
   if (explorerLink.includes('node.xode.net')) {
-    return 'account';
+    return 'polkadot/account';
   }
   if (explorerLink.includes('tonviewer.com')) {
     return '';
@@ -82,7 +85,10 @@ function getBlockExplorerTxRoute(chainInfo) {
   if (['edgeware', 'commune'].includes(chainInfo.slug)) {
     return 'extrinsics';
   }
-  if (['mosaicTest', 'polkadex'].includes(chainInfo.slug)) {
+  if (['xode'].includes(chainInfo.slug)) {
+    return 'polkadot/extrinsics';
+  }
+  if (['mosaicTest', 'polkadex', 'mosaic'].includes(chainInfo.slug)) {
     return 'transactions';
   }
   const explorerLink = _getBlockExplorerFromChain(chainInfo);
@@ -126,9 +132,6 @@ export function getExplorerLink(chainInfo, value, type) {
     if (chainInfo.slug === 'tangle') {
       return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${value}${route}/${value}`;
     }
-    if (chainInfo.slug === 'xode') {
-      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}polkadot-chain-transaction?search=${value}`;
-    }
     if (['truth_network', 'aventus'].includes(chainInfo.slug)) {
       // getTransactionId(value)
       //   .then((transactionId) => {

package/types/balance/transfer.d.ts

@@ -18,6 +18,7 @@ export interface ResponseSubscribeTransfer {
     feePercentageSpecialCase?: number;
     error?: string;
     isEvmRpcError?: boolean;
+    maxTransferableWithoutFee: string;
 }
 export interface RequestSubmitTransferWithId extends RequestSubmitTransfer {
     id?: string;

package/types/index.d.ts

@@ -24,3 +24,4 @@ export * from './transaction';
 export * from './yield';
 export * from './setting';
 export * from './bitcoin';
+export * from './substrateProxyAccount';

package/types/index.js

@@ -17,4 +17,5 @@ export * from "./transaction/index.js";
 export * from "./yield/index.js";
 export * from "./setting.js";
 export * from "./bitcoin.js";
+export * from "./substrateProxyAccount/index.js";
 export {};

package/types/substrateProxyAccount/actions/index.d.ts

@@ -0,0 +1,17 @@
+import { BaseRequestSign, InternalRequestSign } from '../../transaction';
+import { SubstrateProxyAccountItem, SubstrateProxyType } from '..';
+export interface AddSubstrateProxyAccountParams extends BaseRequestSign {
+    address: string;
+    chain: string;
+    substrateProxyAddress: string;
+    substrateProxyType: SubstrateProxyType;
+    substrateProxyDeposit: string;
+}
+export declare type RequestAddSubstrateProxyAccount = InternalRequestSign<AddSubstrateProxyAccountParams>;
+export interface RemoveSubstrateProxyAccountParams extends BaseRequestSign {
+    address: string;
+    chain: string;
+    selectedSubstrateProxyAccounts: SubstrateProxyAccountItem[];
+    isRemoveAll?: boolean;
+}
+export declare type RequestRemoveSubstrateProxyAccount = InternalRequestSign<RemoveSubstrateProxyAccountParams>;

package/types/substrateProxyAccount/actions/index.js

@@ -0,0 +1 @@
+export {};

package/types/substrateProxyAccount/index.d.ts

@@ -0,0 +1,23 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+export interface ExcludedSubstrateProxyAccounts {
+    address: string;
+    substrateProxyType: SubstrateProxyType;
+}
+export interface RequestGetSubstrateProxyAccountGroup {
+    chain: string;
+    address: string;
+    type?: ExtrinsicType;
+    excludedSubstrateProxyAccounts?: ExcludedSubstrateProxyAccounts[];
+}
+export declare type SubstrateProxyType = 'Any' | 'NonTransfer' | 'Governance' | 'Staking';
+export interface SubstrateProxyAccountItem {
+    substrateProxyAddress: string;
+    substrateProxyType: SubstrateProxyType;
+    delay: number;
+    proxyId?: string;
+}
+export interface SubstrateProxyAccountGroup {
+    substrateProxyAccounts: SubstrateProxyAccountItem[];
+    substrateProxyDeposit: string;
+}
+export * from './actions';

package/types/substrateProxyAccount/index.js

@@ -0,0 +1,8 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// All possible proxy types in Substrate in this article: https://wiki.polkadot.com/learn/learn-proxies/#proxy-types
+// Only support these 4 types for now
+
+export * from "./actions/index.js";
+export {};

package/types/transaction/request.d.ts

@@ -2,6 +2,7 @@ import { TransactionFee } from '../fee';
 import { TransactionWarningType } from './warning';
 export declare type BaseRequestSign = {
     ignoreWarnings?: TransactionWarningType[];
+    signerSubstrateProxyAddress?: string;
 };
 export declare type InternalRequestSign<T> = T & BaseRequestSign;
 export interface RequestBaseTransfer {

package/types/yield/actions/join/submit.d.ts

@@ -86,7 +86,7 @@ export interface BondingSubmitParams extends BaseRequestSign {
     };
 }
 export declare type RequestBondingSubmit = InternalRequestSign<BondingSubmitParams>;
-export declare type SubmitChangeValidatorStaking = SubmitBittensorChangeValidatorStaking | SubmitJoinNativeStaking;
+export declare type SubmitChangeValidatorStaking = InternalRequestSign<SubmitBittensorChangeValidatorStaking | SubmitJoinNativeStaking>;
 export interface SubmitBittensorChangeValidatorStaking extends SubmitJoinNativeStaking {
     originValidator: string;
     maxAmount: string;

package/utils/account/transform.js

@@ -157,14 +157,15 @@ const EARN_VMANTA_ACTIONS = [ExtrinsicType.MINT_VMANTA, ExtrinsicType.REDEEM_VMA
 const EVM_ACTIONS = [ExtrinsicType.TOKEN_SPENDING_APPROVAL, ExtrinsicType.EVM_EXECUTE];
 const CLAIM_AVAIL_BRIDGE = [ExtrinsicType.CLAIM_BRIDGE];
 const OPEN_GOV_ACTIONS = [ExtrinsicType.GOV_VOTE, ExtrinsicType.GOV_UNVOTE, ExtrinsicType.GOV_UNLOCK_VOTE];
+const SUBSTRATE_PROXY_ACTION = [ExtrinsicType.ADD_SUBSTRATE_PROXY_ACCOUNT, ExtrinsicType.REMOVE_SUBSTRATE_PROXY_ACCOUNT];
 const OTHER_ACTIONS = [ExtrinsicType.TRANSFER_XCM, ExtrinsicType.SEND_NFT, ExtrinsicType.SWAP, ExtrinsicType.CROWDLOAN];
 export const getAccountTransactionActions = (signMode, networkType, type, _meta, _specialNetwork) => {
   if ([AccountSignMode.PASSWORD, AccountSignMode.INJECTED].includes(signMode)) {
     switch (networkType) {
       case AccountChainType.SUBSTRATE:
-        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...OTHER_ACTIONS];
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ...OTHER_ACTIONS];
       case AccountChainType.ETHEREUM:
-        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...OTHER_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...EVM_ACTIONS];
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...OTHER_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...SUBSTRATE_PROXY_ACTION, ...EVM_ACTIONS];
       case AccountChainType.TON:
         return [...BASE_TRANSFER_ACTIONS];
       case AccountChainType.CARDANO:
@@ -175,7 +176,7 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
   } else if (signMode === AccountSignMode.QR) {
     switch (networkType) {
       case AccountChainType.SUBSTRATE:
-        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...OTHER_ACTIONS];
+        return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS, ...EARN_QDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OPEN_GOV_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ...OTHER_ACTIONS];
       case AccountChainType.ETHEREUM:
         return [...(isProductionMode ? [] : [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_STDOT_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ...OTHER_ACTIONS, ...EVM_ACTIONS])];
       case AccountChainType.TON:
@@ -190,7 +191,7 @@ export const getAccountTransactionActions = (signMode, networkType, type, _meta,
       case AccountChainType.SUBSTRATE:
         return [...BASE_TRANSFER_ACTIONS, ...NATIVE_STAKE_ACTIONS, ...POOL_STAKE_ACTIONS, ...EARN_VDOT_ACTIONS, ...EARN_VMANTA_ACTIONS, ...EARN_LDOT_ACTIONS, ...EARN_SDOT_ACTIONS,
         // ...EARN_QDOT_ACTIONS,
-        ...OPEN_GOV_ACTIONS, ...OTHER_ACTIONS];
+        ...OPEN_GOV_ACTIONS, ...SUBSTRATE_PROXY_ACTION, ...OTHER_ACTIONS];
       case AccountChainType.ETHEREUM:
         return [...BASE_TRANSFER_ACTIONS, ...EARN_STDOT_ACTIONS, ...EVM_ACTIONS, ...CLAIM_AVAIL_BRIDGE, ExtrinsicType.STAKING_WITHDRAW,
         // For liquid staking

package/utils/fee/transfer.js

@@ -319,7 +319,8 @@ export const calculateTransferMaxTransferable = async (id, request, freeBalance,
     feeType: feeChainType,
     id: id,
     error,
-    isEvmRpcError: isEvmRpcError
+    isEvmRpcError: isEvmRpcError,
+    maxTransferableWithoutFee: freeBalance.value
   };
 };
 export const calculateXcmMaxTransferable = async (id, request, freeBalance, fee) => {
@@ -510,7 +511,8 @@ export const calculateXcmMaxTransferable = async (id, request, freeBalance, fee)
     feeOptions: feeOptions,
     feeType: feeChainType,
     id: id,
-    error
+    error,
+    maxTransferableWithoutFee: freeBalance.value
   };
 };
 export const isEvmEIP1559FeeDetail = fee => {