@subwallet/extension-base 1.3.76-0 → 1.3.78-0

package/services/earning-service/handlers/special.js

@@ -3,11 +3,12 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { ALL_ACCOUNT_KEY, XCM_FEE_RATIO, XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
+import { ALL_ACCOUNT_KEY, XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { YIELD_POOL_STAT_REFRESH_INTERVAL } from '@subwallet/extension-base/koni/api/yield/helper/utils';
-import { createXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { createXcmExtrinsicV2, dryRunXcmExtrinsicV2, getMinXcmTransferableAmount } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { estimateXcmFee } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
-import { _getAssetDecimals, _getAssetExistentialDeposit, _getAssetName, _getAssetSymbol, _getChainNativeTokenSlug, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetExistentialDeposit, _getAssetSymbol, _getChainName, _getChainNativeTokenSlug } from '@subwallet/extension-base/services/chain-service/utils';
+import { MIN_XCM_LIQUID_STAKING_DOT } from '@subwallet/extension-base/services/earning-service/constants';
 import { BasicTxErrorType, YieldStepType, YieldValidationStatus } from '@subwallet/extension-base/types';
 import { createPromiseHandler, formatNumber } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
@@ -207,51 +208,51 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       address,
       amount
     } = params;
-    const bnAmount = new BN(amount);
+    const bnStakeAmount = new BigN(amount);
     const inputTokenSlug = this.inputAsset; // assume that the pool only has 1 input token, will update later
     const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
     const inputTokenBalance = await this.state.balanceService.getTransferableBalance(address, inputTokenInfo.originChain, inputTokenSlug);
-    const bnInputTokenBalance = new BN(inputTokenBalance.value);
-    if (!bnInputTokenBalance.gte(bnAmount)) {
+    const bnInputTokenBalance = new BigN(inputTokenBalance.value);
+    if (amount && !bnInputTokenBalance.gte(bnStakeAmount)) {
       if (this.altInputAsset) {
         const altInputTokenSlug = this.altInputAsset;
         const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
         const altInputTokenBalance = await this.state.balanceService.getTransferableBalance(address, altInputTokenInfo.originChain, altInputTokenSlug);
-        const bnAltInputTokenBalance = new BN(altInputTokenBalance.value || '0');
-        if (bnAltInputTokenBalance.gt(BN_ZERO)) {
+        const bnAltInputTokenBalance = new BigN(altInputTokenBalance.value || '0');
+        if (bnAltInputTokenBalance.gt(BigN(0))) {
           const altChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
           const symbol = altInputTokenInfo.symbol;
           const networkName = altChainInfo.name;
-
-          // TODO: calculate fee for destination chain
-          const xcmFeeInfo = await estimateXcmFee({
+          const xcmRequest = {
             fromChainInfo: altChainInfo,
             fromTokenInfo: altInputTokenInfo,
             toChainInfo: this.chainInfo,
             recipient: address,
             sender: address,
-            value: bnAmount.toString()
-          });
+            value: bnStakeAmount.toString()
+          };
+          const [xcmFeeInfo, _minXcmTransferableAmount] = await Promise.all([estimateXcmFee(xcmRequest), getMinXcmTransferableAmount(xcmRequest)]);
           if (!xcmFeeInfo) {
             throw new Error('Error estimating XCM fee');
           }
-          const xcmFee = BigN(xcmFeeInfo.origin.fee).multipliedBy(XCM_MIN_AMOUNT_RATIO).toFixed(0, 1);
+          const xcmOriginFee = BigN(xcmFeeInfo.origin.fee).toFixed(0, 1);
+          const xcmDestinationFee = BigN(xcmFeeInfo.destination.fee).toFixed(0, 1);
           const fee = {
             slug: altInputTokenSlug,
-            amount: xcmFee
+            amount: xcmOriginFee
           };
-          let bnTransferAmount = bnAmount.sub(bnInputTokenBalance);
-          if (_isNativeToken(altInputTokenInfo)) {
-            const bnXcmFee = new BN(fee.amount || 0); // xcm fee is paid in native token but swap token is not always native token
-
-            bnTransferAmount = bnTransferAmount.add(bnXcmFee);
+          let sendingValue = bnStakeAmount.minus(bnInputTokenBalance).plus(xcmDestinationFee).toString();
+          const minXcmTransferableAmount = _minXcmTransferableAmount || MIN_XCM_LIQUID_STAKING_DOT;
+          if (new BigN(minXcmTransferableAmount).gt(sendingValue)) {
+            sendingValue = minXcmTransferableAmount;
           }
+          const metadata = {
+            sendingValue,
+            originTokenInfo: altInputTokenInfo,
+            destinationTokenInfo: inputTokenInfo
+          };
           const step = {
-            metadata: {
-              sendingValue: bnTransferAmount.toString(),
-              originTokenInfo: altInputTokenInfo,
-              destinationTokenInfo: inputTokenInfo
-            },
+            metadata: metadata,
             name: `Transfer ${symbol} from ${networkName}`,
             type: YieldStepType.XCM
           };
@@ -294,31 +295,35 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     return Promise.resolve([new TransactionError(BasicTxErrorType.UNSUPPORTED)]);
   }
   async validateXcmStep(params, path, bnInputTokenBalance) {
+    // todo: BN -> BigN or BigInt
     const processValidation = {
       ok: true,
       status: YieldValidationStatus.OK
     };
-    const bnAmount = new BN(params.amount);
-    const altInputTokenSlug = this.altInputAsset || '';
-    const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
-    const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
-    const altInputTokenBalance = await this.state.balanceService.getTransferableBalance(params.address, altInputTokenInfo.originChain, altInputTokenSlug);
-    const missingAmount = bnAmount.sub(bnInputTokenBalance); // TODO: what if input token is not LOCAL ??
-    const xcmFeeValidate = new BN(path.totalFee[1].amount || '0').mul(new BN(XCM_FEE_RATIO));
-    const bnAltInputTokenBalance = new BN(altInputTokenBalance.value || '0');
-    if (!bnAltInputTokenBalance.sub(missingAmount).sub(xcmFeeValidate).gt(BN_ZERO)) {
+    const metadata = path.steps[1].metadata;
+    const {
+      destinationTokenInfo,
+      originTokenInfo,
+      sendingValue
+    } = metadata;
+    const originChainInfo = this.state.getChainInfo(originTokenInfo.originChain);
+    const originTokenBalance = await this.state.balanceService.getTransferableBalance(params.address, originTokenInfo.originChain, originTokenInfo.slug);
+    const bnOriginTokenBalance = new BN(originTokenBalance.value || '0');
+    const bnAdjustOriginFee = new BN(path.totalFee[1].amount || '0').mul(new BN(XCM_MIN_AMOUNT_RATIO));
+    const bnSendingValue = new BN(sendingValue);
+    if (!bnOriginTokenBalance.sub(bnSendingValue).sub(bnAdjustOriginFee).gt(BN_ZERO)) {
       processValidation.failedStep = path.steps[1];
       processValidation.ok = false;
       processValidation.status = YieldValidationStatus.NOT_ENOUGH_BALANCE;
-      const bnMaxXCM = new BN(altInputTokenBalance.value).sub(xcmFeeValidate);
-      const inputTokenDecimal = _getAssetDecimals(inputTokenInfo);
-      const maxBn = bnInputTokenBalance.add(bnAltInputTokenBalance.sub(xcmFeeValidate));
-      const maxValue = formatNumber(maxBn.toString(), inputTokenInfo.decimals || 0);
-      const maxXCMValue = formatNumber(bnMaxXCM.toString(), inputTokenDecimal);
-      const symbol = _getAssetSymbol(altInputTokenInfo);
+      const bnMaxXCM = new BN(originTokenBalance.value).sub(bnAdjustOriginFee);
+      const destinationTokenDecimal = _getAssetDecimals(destinationTokenInfo);
+      const maxBn = bnInputTokenBalance.add(bnOriginTokenBalance.sub(bnAdjustOriginFee));
+      const maxValue = formatNumber(maxBn.toString(), destinationTokenInfo.decimals || 0);
+      const maxXCMValue = formatNumber(bnMaxXCM.toString(), destinationTokenDecimal);
+      const symbol = _getAssetSymbol(originTokenInfo);
       const inputNetworkName = this.chainInfo.name;
-      const altNetworkName = _getAssetName(altInputTokenInfo);
-      const currentValue = formatNumber(bnInputTokenBalance.toString(), inputTokenDecimal);
+      const altNetworkName = _getChainName(originChainInfo);
+      const currentValue = formatNumber(bnInputTokenBalance.toString(), destinationTokenDecimal);
       processValidation.message = t('bg.EARNING.services.service.earning.specialHandler.maximumInputExceeded', {
         replace: {
           symbol,
@@ -331,6 +336,24 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       });
       return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_BALANCE, processValidation.message, processValidation)];
     }
+    const id = getId();
+    const feeInfo = await this.state.feeService.subscribeChainFee(id, originChainInfo.slug, 'substrate');
+    const substrateApi = this.state.getSubstrateApi(originChainInfo.slug);
+    const xcmRequest = {
+      destinationTokenInfo: destinationTokenInfo,
+      originTokenInfo: originTokenInfo,
+      recipient: params.address,
+      sendingValue,
+      substrateApi,
+      sender: params.address,
+      originChain: originChainInfo,
+      destinationChain: this.chainInfo,
+      feeInfo
+    };
+    const isDryRunSuccess = await dryRunXcmExtrinsicV2(xcmRequest);
+    if (!isDryRunSuccess) {
+      return [new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, 'Unable to perform transaction. Select another token or destination chain and try again')];
+    }
     return [];
   }
   async validateJoinStep(id, params, path, bnInputTokenBalance, isXcmOk) {
@@ -350,7 +373,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const feeTokenInfo = this.state.getAssetBySlug(feeTokenSlug);
     const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
     const defaultFeeTokenSlug = this.feeAssets[0];
-    const bnAmount = new BN(params.amount);
+    const bnStakeAmount = new BN(params.amount);
     if (this.feeAssets.length === 1 && feeTokenSlug === defaultFeeTokenSlug) {
       var _path$totalFee$id;
       const bnFeeAmount = new BN(((_path$totalFee$id = path.totalFee[id]) === null || _path$totalFee$id === void 0 ? void 0 : _path$totalFee$id.amount) || '0');
@@ -364,13 +387,13 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
         return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_FEE, processValidation.message, processValidation)];
       }
     }
-    if (!bnAmount.gte(new BN(poolInfo.statistic.earningThreshold.join || '0'))) {
+    if (!bnStakeAmount.gte(new BN(poolInfo.statistic.earningThreshold.join || '0'))) {
       processValidation.failedStep = path.steps[id];
       processValidation.ok = false;
       processValidation.status = YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL;
       return [new TransactionError(YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL, processValidation.message, processValidation)];
     }
-    if (!isXcmOk && bnAmount.gt(bnInputTokenBalance)) {
+    if (!isXcmOk && bnStakeAmount.gt(bnInputTokenBalance)) {
       processValidation.failedStep = path.steps[id];
       processValidation.ok = false;
       processValidation.status = YieldValidationStatus.NOT_ENOUGH_BALANCE;
@@ -394,8 +417,8 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const balanceService = this.state.balanceService;
     const inputTokenBalance = await balanceService.getTransferableBalance(params.address, inputTokenInfo.originChain, inputTokenSlug);
     const bnInputTokenBalance = new BN(inputTokenBalance.value || '0');
-    const bnAmount = new BN(params.amount);
-    if (bnAmount.lte(BN_ZERO)) {
+    const bnStakeAmount = new BN(params.amount);
+    if (bnStakeAmount.lte(BN_ZERO)) {
       return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
     let isXcmOk = false;
@@ -429,31 +452,25 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
   async handleTokenApproveStep(data, path) {
     return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
   }
-  async handleXcmStep(data, path, xcmFee) {
+  async handleXcmStep(data, path) {
+    const metadata = path.steps[1].metadata;
+    const xcmStepFee = path.totalFee[1].amount;
+    const address = data.address;
     const {
-      address,
-      amount
-    } = data;
-    const destinationTokenSlug = this.inputAsset;
-    const altInputTokenSlug = this.altInputAsset || '';
-    const altInputTokenInfo = this.state.getAssetBySlug(altInputTokenSlug);
-    const originChainInfo = this.state.getChainInfo(altInputTokenInfo.originChain);
+      destinationTokenInfo,
+      originTokenInfo,
+      sendingValue
+    } = metadata;
+    const originChainInfo = this.state.getChainInfo(originTokenInfo.originChain);
     const originTokenSlug = _getChainNativeTokenSlug(originChainInfo);
-    const originTokenInfo = this.state.getAssetBySlug(originTokenSlug);
-    const destinationTokenInfo = this.state.getAssetBySlug(destinationTokenSlug);
     const substrateApi = this.state.getSubstrateApi(originChainInfo.slug);
-    const inputTokenBalance = await this.state.balanceService.getTransferableBalance(address, destinationTokenInfo.originChain, destinationTokenSlug);
-    const bnInputTokenBalance = new BN(inputTokenBalance.value);
-    const bnXcmFee = new BN(xcmFee);
-    const bnAmount = new BN(amount);
-    const bnTotalAmount = bnAmount.sub(bnInputTokenBalance).add(bnXcmFee);
     const id = getId();
     const feeInfo = await this.state.feeService.subscribeChainFee(id, originChainInfo.slug, 'substrate');
     const xcmRequest = {
       destinationTokenInfo,
       originTokenInfo,
       recipient: address,
-      sendingValue: bnTotalAmount.toString(),
+      sendingValue,
       substrateApi,
       sender: address,
       originChain: originChainInfo,
@@ -469,7 +486,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       destinationNetworkKey: destinationTokenInfo.originChain,
       from: address,
       to: address,
-      value: bnTotalAmount.toString(),
+      value: sendingValue,
       tokenSlug: originTokenSlug,
       showExtraWarning: true
     };
@@ -478,8 +495,9 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       extrinsicType: ExtrinsicType.TRANSFER_XCM,
       extrinsic,
       txData: xcmData,
-      transferNativeAmount: bnTotalAmount.toString(),
-      chainType: ChainType.SUBSTRATE
+      transferNativeAmount: sendingValue,
+      chainType: ChainType.SUBSTRATE,
+      xcmStepFee
     };
   }
   handleYieldJoin(data, path, currentStep) {
@@ -491,8 +509,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
         return this.handleTokenApproveStep(data, path);
       case YieldStepType.XCM:
         {
-          const xcmFee = path.totalFee[currentStep].amount || '0';
-          return this.handleXcmStep(data, path, xcmFee);
+          return this.handleXcmStep(data, path);
         }
       default:
         return this.handleSubmitStep(data, path);

package/services/earning-service/service.js

@@ -6,10 +6,10 @@ import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { CRON_REFRESH_CHAIN_STAKING_METADATA, CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL, CRON_REFRESH_EARNING_TARGETS, CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { _getChainSubstrateTokenSymbol, _isChainEnabled } from '@subwallet/extension-base/services/chain-service/utils';
-import { _STAKING_CHAIN_GROUP, STAKING_IDENTITY_API_SLUG } from '@subwallet/extension-base/services/earning-service/constants';
+import { _STAKING_CHAIN_GROUP, STAKING_IDENTITY_API_SLUG, SUNSETTED_YIELD_POOL_SLUGS } from '@subwallet/extension-base/services/earning-service/constants';
 import BaseLiquidStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/liquid-staking/base';
 import MythosNativeStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/mythos';
-import { BasicTxErrorType, YieldPoolType } from '@subwallet/extension-base/types';
+import { BasicTxErrorType, EarningStatus, YieldPoolType } from '@subwallet/extension-base/types';
 import { addLazy, createPromiseHandler, filterAddressByChainInfo, removeLazy } from '@subwallet/extension-base/utils';
 import { fetchStaticCache } from '@subwallet/extension-base/utils/fetchStaticCache';
 import { BehaviorSubject, combineLatest } from 'rxjs';
@@ -432,6 +432,14 @@ export default class EarningService {
       }
       const updatedItem = structuredClone(item);
       updatedItem.metadata.availableMethod = handler.availableMethod;
+
+      // Disable staking for sunsetted pools
+      if (SUNSETTED_YIELD_POOL_SLUGS.includes(item.slug)) {
+        updatedItem.metadata.availableMethod = {
+          ...updatedItem.metadata.availableMethod,
+          join: false
+        };
+      }
       this.updateYieldPoolInfo(updatedItem);
     });
     return onlineData;
@@ -524,7 +532,11 @@ export default class EarningService {
     const yieldPositionInfo = this.yieldPositionSubject.getValue();
     existedYieldPosition.forEach(item => {
       if (!this.inactivePoolSlug.has(item.slug)) {
-        yieldPositionInfo[this._getYieldPositionKey(item.slug, item.address)] = item;
+        const normalizedItem = SUNSETTED_YIELD_POOL_SLUGS.includes(item.slug) ? {
+          ...item,
+          status: EarningStatus.NOT_EARNING
+        } : item;
+        yieldPositionInfo[this._getYieldPositionKey(item.slug, item.address)] = normalizedItem;
       }
     });
     this.yieldPositionSubject.next(yieldPositionInfo);
@@ -547,7 +559,11 @@ export default class EarningService {
     return `${slug}---${address}`;
   }
   updateYieldPosition(data) {
-    this.yieldPositionPersistQueue.push(data);
+    const normalizedData = SUNSETTED_YIELD_POOL_SLUGS.includes(data.slug) ? {
+      ...data,
+      status: EarningStatus.NOT_EARNING
+    } : data;
+    this.yieldPositionPersistQueue.push(normalizedData);
     addLazy('persistYieldPositionInfo', () => {
       const yieldPositionInfo = this.yieldPositionSubject.getValue();
       const queue = [...this.yieldPositionPersistQueue];
@@ -855,6 +871,7 @@ export default class EarningService {
     } = params;
     const handler = this.getPoolHandler(slug);
     if (handler) {
+      console.log('all step', await handler.generateOptimalPath(params));
       return handler.generateOptimalPath(params);
     } else {
       throw new TransactionError(BasicTxErrorType.INTERNAL_ERROR);

package/services/inapp-notification-service/interfaces.d.ts

@@ -118,6 +118,7 @@ export interface ShowNotificationPayload {
     earningWithdraw: boolean;
     availBridgeClaim: boolean;
     polygonBridgeClaim: boolean;
+    pendingMultisigApprovals: boolean;
 }
 export interface NotificationSetup {
     isEnabled: boolean;

package/services/multisig-service/index.js

@@ -206,7 +206,7 @@ export class MultisigService {
    */
   handleEvents(events, eventTypes) {
     let needReload = false;
-    if (eventTypes.includes('account.add') || eventTypes.includes('account.remove')) {
+    if (eventTypes.includes('account.add') || eventTypes.includes('account.remove') || eventTypes.includes('account.updateCurrent')) {
       needReload = true;
     }
     if (eventTypes.includes('chain.updateState') || eventTypes.includes('transaction.done')) {

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

@@ -9,6 +9,7 @@ export default class SubstrateRequestHandler {
     constructor(requestService: RequestService);
     getSignRequest(id: string): SignRequest | undefined;
     get allSubstrateRequests(): SigningRequest[];
+    updateSignRequest(id: string, request: RequestSign, signerAddress?: string): void;
     private updateIconSign;
     private signComplete;
     get numSubstrateRequests(): number;

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

@@ -34,6 +34,18 @@ export default class SubstrateRequestHandler {
       isInternal: isInternalRequest(url)
     }));
   }
+  updateSignRequest(id, request, signerAddress) {
+    const current = this.getSignRequest(id);
+    if (!current) {
+      throw new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Sign request not found');
+    }
+    this.#substrateRequests[id] = {
+      ...current,
+      request,
+      signerAddress: signerAddress || current.signerAddress
+    };
+    this.updateIconSign();
+  }
   updateIconSign(shouldClose) {
     this.signSubject.next(this.allSubstrateRequests);
     this.#requestService.updateIconV2(shouldClose);

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

@@ -55,6 +55,7 @@ export default class RequestService {
     get confirmationsQueueSubjectTon(): BehaviorSubject<ConfirmationsQueueTon>;
     get confirmationsQueueSubjectCardano(): BehaviorSubject<ConfirmationsQueueCardano>;
     getSignRequest(id: string): import("./types").SignRequest | undefined;
+    updateSignRequest(id: string, request: RequestSign, signerAddress?: string): void;
     signInternalTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON, onSign?: (id: string) => void, isWrappedTx?: SubstrateTransactionWrappingStatus): Promise<ResponseSigning>;
     addConfirmation<CT extends ConfirmationType>(id: string, url: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): Promise<ConfirmationDefinitions[CT][1]>;
     addConfirmationTon<CT extends ConfirmationTypeTon>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsTon[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsTon[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsTon[CT][1]>;

package/services/request-service/index.js

@@ -167,6 +167,9 @@ export default class RequestService {
   getSignRequest(id) {
     return this.#substrateRequestHandler.getSignRequest(id);
   }
+  updateSignRequest(id, request, signerAddress) {
+    this.#substrateRequestHandler.updateSignRequest(id, request, signerAddress);
+  }
   async signInternalTransaction(id, address, url, payload, onSign, isWrappedTx) {
     if (isWrappedTx === SubstrateTransactionWrappingStatus.WRAP_RESULT) {
       return this.#substrateRequestHandler.signWrappedTransaction(id, address, url, payload, onSign);

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

@@ -2,6 +2,7 @@ import { AccountAuthType, RequestSign, Resolver, ResponseSigning } from '@subwal
 import { MetadataDef } from '@subwallet/extension-inject/types';
 export interface SignRequest extends Resolver<ResponseSigning> {
     address: string;
+    signerAddress?: string;
     id: string;
     request: RequestSign;
     url: string;

package/services/setting-service/constants.js

@@ -23,7 +23,8 @@ export const DEFAULT_NOTIFICATION_SETUP = {
     earningClaim: true,
     earningWithdraw: true,
     availBridgeClaim: true,
-    polygonBridgeClaim: true
+    polygonBridgeClaim: true,
+    pendingMultisigApprovals: true
     // isHideWithdraw: false, // todo: just for test, remove later
     // isHideMarketing: false,
     // isHideAnnouncement: false

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

@@ -82,7 +82,7 @@ export default class InappNotificationStore extends BaseStore {
         isRead: true
       });
     }
-    return this.table.where('proxyId').equalsIgnoreCase(proxyId).modify({
+    return this.table.where('proxyId').equalsIgnoreCase(proxyId).filter(notification => !excludeNotificationIds.includes(notification.id)).modify({
       isRead: true
     });
   }

package/services/swap-service/handler/bittensor-handler.d.ts

@@ -0,0 +1,21 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BalanceService } from '../../balance-service';
+import { ChainService } from '../../chain-service';
+import FeeService from '../../fee-service/service';
+import { SwapBaseInterface } from './base-handler';
+export declare class BittensorSwapHandler implements SwapBaseInterface {
+    private swapBaseHandler;
+    providerSlug: SwapProviderId;
+    isReady: boolean;
+    constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService, isTestnet: boolean);
+    get chainService(): ChainService;
+    get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
+    getSubmitStep(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    private getHotkeysByNetuidDesc;
+    private buildSwapCalls;
+}

package/services/swap-service/handler/bittensor-handler.js

@@ -0,0 +1,189 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { _reformatAddressWithChain, toBNString } from '@subwallet/extension-base/utils';
+import BigNumber from 'bignumber.js';
+import { _getAssetDecimals, _isNativeTokenBySlug } from "../../chain-service/utils/index.js";
+import { SwapBaseHandler } from "./base-handler.js";
+export class BittensorSwapHandler {
+  isReady = false;
+  constructor(chainService, balanceService, feeService, isTestnet) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: isTestnet ? 'Bittensor Testnet' : 'Bittensor',
+      providerSlug: isTestnet ? SwapProviderId.BITTENSOR_TESTNET : SwapProviderId.BITTENSOR
+    });
+    this.providerSlug = isTestnet ? SwapProviderId.BITTENSOR_TESTNET : SwapProviderId.BITTENSOR;
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  generateOptimalProcessV2(params) {
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getSubmitStep.bind(this)]);
+  }
+  async getSubmitStep(params) {
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const submitStep = {
+      name: 'Swap',
+      type: SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: _reformatAddressWithChain(params.request.address, originChain),
+        receiver: _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain),
+        version: 2
+      }
+    };
+    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+  }
+  async validateSwapProcessV2(params) {
+    // todo: recheck address and recipient format in params
+    const {
+      process,
+      selectedQuote
+    } = params; // todo: review flow, currentStep param.
+
+    // todo: validate path with optimalProcess
+    // todo: review error message in case many step swap
+    if (BigNumber(selectedQuote.fromAmount).lte(0)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+    if (swapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case CommonStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async handleSubmitStep(params) {
+    var _fromAsset$metadata, _toAsset$metadata;
+    const {
+      address,
+      quote
+    } = params;
+    const pair = quote.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const toAsset = this.chainService.getAssetBySlug(pair.to);
+    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const fromNetuid = _isNativeTokenBySlug(fromAsset.slug) ? 0 : (_fromAsset$metadata = fromAsset.metadata) === null || _fromAsset$metadata === void 0 ? void 0 : _fromAsset$metadata.netuid;
+    const toNetuid = _isNativeTokenBySlug(toAsset.slug) ? 0 : (_toAsset$metadata = toAsset.metadata) === null || _toAsset$metadata === void 0 ? void 0 : _toAsset$metadata.netuid;
+    if (fromNetuid == null || toNetuid == null || fromNetuid === toNetuid) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+    }
+    const txData = {
+      address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      process: params.process
+    };
+    const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
+    const substrateApi = await chainApi.isReady;
+    const _stakeInfo = await substrateApi.api.call.stakeInfoRuntimeApi.getStakeInfoForColdkey(address);
+    const stakeInfo = _stakeInfo.toPrimitive();
+
+    // TAO/ALPHA ratio
+    const priceRatio = new BigNumber(toBNString(quote.rate, _getAssetDecimals(fromAsset)));
+    const limitPrice = priceRatio.multipliedBy(new BigNumber(1).minus(params.slippage)).integerValue(BigNumber.ROUND_DOWN).toFixed();
+    const calls = this.buildSwapCalls({
+      stakeInfo,
+      fromNetuid,
+      toNetuid,
+      amount: new BigNumber(quote.fromAmount),
+      limitPrice
+    }, substrateApi.api);
+    let extrinsic;
+    if (calls.length === 1) {
+      extrinsic = calls[0];
+    } else {
+      extrinsic = substrateApi.api.tx.utility.batchAll(calls);
+    }
+    return {
+      txChain: fromAsset.originChain,
+      extrinsic,
+      txData,
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType: ChainType.SUBSTRATE
+      // using staked balance so we do not need transferNativeAmount
+    };
+  }
+
+  // Sort hotkeys by stake descending
+  getHotkeysByNetuidDesc(stakeInfo, fromNetuid) {
+    return stakeInfo.filter(i => i.netuid === fromNetuid && new BigNumber(i.stake).gt(0)).sort((a, b) => new BigNumber(b.stake).minus(a.stake).toNumber());
+  }
+  buildSwapCalls(params, api) {
+    const {
+      amount,
+      fromNetuid,
+      limitPrice,
+      stakeInfo,
+      toNetuid
+    } = params;
+    const hotkeys = this.getHotkeysByNetuidDesc(stakeInfo, fromNetuid);
+    let remaining = amount;
+    const calls = [];
+    for (const item of hotkeys) {
+      if (remaining.lte(0)) {
+        break;
+      }
+      const stake = new BigNumber(item.stake);
+      if (stake.lte(0)) {
+        continue;
+      }
+      const swapAmount = BigNumber.minimum(stake, remaining);
+      calls.push(api.tx.subtensorModule.swapStakeLimit(item.hotkey, fromNetuid, toNetuid, swapAmount.toFixed(), limitPrice, false));
+      remaining = remaining.minus(swapAmount);
+    }
+    return calls;
+  }
+}