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

package/cjs/services/earning-service/constants/chains.js

@@ -3,7 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._STAKING_CHAIN_GROUP = exports.TON_CHAINS = exports.ST_LIQUID_TOKEN_ABI = exports.STAKING_IDENTITY_API_SLUG = exports.RELAY_HANDLER_DIRECT_STAKING_CHAINS = exports.MaxEraRewardPointsEras = exports.MANTA_VALIDATOR_POINTS_PER_BLOCK = exports.MANTA_MIN_DELEGATION = exports.CHANNEL_ID = void 0;
+exports._STAKING_CHAIN_GROUP = exports.TON_CHAINS = exports.SUNSETTED_YIELD_POOL_SLUGS = exports.ST_LIQUID_TOKEN_ABI = exports.STAKING_IDENTITY_API_SLUG = exports.RELAY_HANDLER_DIRECT_STAKING_CHAINS = exports.MaxEraRewardPointsEras = exports.MIN_XCM_LIQUID_STAKING_DOT = exports.MANTA_VALIDATOR_POINTS_PER_BLOCK = exports.MANTA_MIN_DELEGATION = exports.CHANNEL_ID = void 0;
+var _stellaSwap = require("../handlers/liquid-staking/stella-swap");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -29,6 +30,8 @@ const _STAKING_CHAIN_GROUP = {
   tanssi: ['tanssi', 'dancelight']
 };
 exports._STAKING_CHAIN_GROUP = _STAKING_CHAIN_GROUP;
+const SUNSETTED_YIELD_POOL_SLUGS = [_stellaSwap.STELLA_SWAP_LIQUID_STAKING_SLUG, 'MANTA___native_staking___manta_network'];
+exports.SUNSETTED_YIELD_POOL_SLUGS = SUNSETTED_YIELD_POOL_SLUGS;
 const RELAY_HANDLER_DIRECT_STAKING_CHAINS = [..._STAKING_CHAIN_GROUP.relay, ..._STAKING_CHAIN_GROUP.assetHub];
 exports.RELAY_HANDLER_DIRECT_STAKING_CHAINS = RELAY_HANDLER_DIRECT_STAKING_CHAINS;
 const TON_CHAINS = ['ton', 'ton_testnet'];
@@ -49,4 +52,6 @@ const STAKING_IDENTITY_API_SLUG = {
   statemine: 'peopleKusama',
   statemint: 'polkadot_people'
 };
-exports.STAKING_IDENTITY_API_SLUG = STAKING_IDENTITY_API_SLUG;
+exports.STAKING_IDENTITY_API_SLUG = STAKING_IDENTITY_API_SLUG;
+const MIN_XCM_LIQUID_STAKING_DOT = '15000000000';
+exports.MIN_XCM_LIQUID_STAKING_DOT = MIN_XCM_LIQUID_STAKING_DOT;

package/cjs/services/earning-service/handlers/liquid-staking/stella-swap.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getStellaswapLiquidStakingContract = exports.default = void 0;
+exports.getStellaswapLiquidStakingContract = exports.default = exports.STELLA_SWAP_LIQUID_STAKING_SLUG = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _web = require("@subwallet/extension-base/koni/api/contract-handler/evm/web3");
@@ -28,6 +28,8 @@ exports.getStellaswapLiquidStakingContract = getStellaswapLiquidStakingContract;
 const APR_STATS_URL = 'https://stdot-apr.stellaswap.com/';
 const SUBWALLET_REFERRAL = '0x7e6815f45E624768548d085231f2d453f16FD7DD';
 const TOP_HOLDER = '0x4300e09284e3bB4d9044DdAB31EfAF5f3301DABa';
+const STELLA_SWAP_LIQUID_STAKING_SLUG = 'xcDOT___liquid_staking___stellaswap';
+exports.STELLA_SWAP_LIQUID_STAKING_SLUG = STELLA_SWAP_LIQUID_STAKING_SLUG;
 class StellaSwapLiquidStakingPoolHandler extends _base.default {
   inputAsset = 'moonbeam-LOCAL-xcDOT';
   altInputAsset = '';
@@ -37,8 +39,8 @@ class StellaSwapLiquidStakingPoolHandler extends _base.default {
   transactionChainType = _KoniTypes.ChainType.EVM;
   rateDecimals = 10; // Derivative asset decimals
   availableMethod = {
-    join: true,
-    defaultUnstake: true,
+    join: false,
+    defaultUnstake: false,
     fastUnstake: false,
     cancelUnstake: false,
     withdraw: true,
@@ -47,7 +49,7 @@ class StellaSwapLiquidStakingPoolHandler extends _base.default {
   };
   constructor(state, chain) {
     super(state, chain);
-    this.slug = 'xcDOT___liquid_staking___stellaswap';
+    this.slug = STELLA_SWAP_LIQUID_STAKING_SLUG;
     this.name = 'StellaSwap Liquid Staking';
     this._logo = 'stellaswap';
     this.shortName = 'StellaSwap';
@@ -170,7 +172,8 @@ class StellaSwapLiquidStakingPoolHandler extends _base.default {
             unstakeBalance: unlockBalance.toString(),
             isBondedBefore: totalBalance.gt(_util.BN_ZERO),
             derivativeToken: derivativeTokenSlug,
-            status: activeBalance.gt(_util.BN_ZERO) ? _types.EarningStatus.EARNING_REWARD : _types.EarningStatus.NOT_EARNING,
+            // StellaSwap announced all stDOT positions are auto-unstaking, so rewards are no longer earned.
+            status: _types.EarningStatus.NOT_EARNING,
             nominations: [],
             unstakings
           };

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

@@ -12,6 +12,7 @@ var _utils = require("@subwallet/extension-base/koni/api/yield/helper/utils");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _utils2 = require("@subwallet/extension-base/services/balance-service/transfer/xcm/utils");
 var _utils3 = require("@subwallet/extension-base/services/chain-service/utils");
+var _constants2 = require("@subwallet/extension-base/services/earning-service/constants");
 var _types = require("@subwallet/extension-base/types");
 var _utils4 = require("@subwallet/extension-base/utils");
 var _getId = require("@subwallet/extension-base/utils/getId");
@@ -214,51 +215,51 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       address,
       amount
     } = params;
-    const bnAmount = new _util.BN(amount);
+    const bnStakeAmount = new _bignumber.default(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 _util.BN(inputTokenBalance.value);
-    if (!bnInputTokenBalance.gte(bnAmount)) {
+    const bnInputTokenBalance = new _bignumber.default(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 _util.BN(altInputTokenBalance.value || '0');
-        if (bnAltInputTokenBalance.gt(_util.BN_ZERO)) {
+        const bnAltInputTokenBalance = new _bignumber.default(altInputTokenBalance.value || '0');
+        if (bnAltInputTokenBalance.gt((0, _bignumber.default)(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 (0, _utils2.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([(0, _utils2.estimateXcmFee)(xcmRequest), (0, _xcm.getMinXcmTransferableAmount)(xcmRequest)]);
           if (!xcmFeeInfo) {
             throw new Error('Error estimating XCM fee');
           }
-          const xcmFee = (0, _bignumber.default)(xcmFeeInfo.origin.fee).multipliedBy(_constants.XCM_MIN_AMOUNT_RATIO).toFixed(0, 1);
+          const xcmOriginFee = (0, _bignumber.default)(xcmFeeInfo.origin.fee).toFixed(0, 1);
+          const xcmDestinationFee = (0, _bignumber.default)(xcmFeeInfo.destination.fee).toFixed(0, 1);
           const fee = {
             slug: altInputTokenSlug,
-            amount: xcmFee
+            amount: xcmOriginFee
           };
-          let bnTransferAmount = bnAmount.sub(bnInputTokenBalance);
-          if ((0, _utils3._isNativeToken)(altInputTokenInfo)) {
-            const bnXcmFee = new _util.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 || _constants2.MIN_XCM_LIQUID_STAKING_DOT;
+          if (new _bignumber.default(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: _types.YieldStepType.XCM
           };
@@ -301,31 +302,35 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED)]);
   }
   async validateXcmStep(params, path, bnInputTokenBalance) {
+    // todo: BN -> BigN or BigInt
     const processValidation = {
       ok: true,
       status: _types.YieldValidationStatus.OK
     };
-    const bnAmount = new _util.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 _util.BN(path.totalFee[1].amount || '0').mul(new _util.BN(_constants.XCM_FEE_RATIO));
-    const bnAltInputTokenBalance = new _util.BN(altInputTokenBalance.value || '0');
-    if (!bnAltInputTokenBalance.sub(missingAmount).sub(xcmFeeValidate).gt(_util.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 _util.BN(originTokenBalance.value || '0');
+    const bnAdjustOriginFee = new _util.BN(path.totalFee[1].amount || '0').mul(new _util.BN(_constants.XCM_MIN_AMOUNT_RATIO));
+    const bnSendingValue = new _util.BN(sendingValue);
+    if (!bnOriginTokenBalance.sub(bnSendingValue).sub(bnAdjustOriginFee).gt(_util.BN_ZERO)) {
       processValidation.failedStep = path.steps[1];
       processValidation.ok = false;
       processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_BALANCE;
-      const bnMaxXCM = new _util.BN(altInputTokenBalance.value).sub(xcmFeeValidate);
-      const inputTokenDecimal = (0, _utils3._getAssetDecimals)(inputTokenInfo);
-      const maxBn = bnInputTokenBalance.add(bnAltInputTokenBalance.sub(xcmFeeValidate));
-      const maxValue = (0, _utils4.formatNumber)(maxBn.toString(), inputTokenInfo.decimals || 0);
-      const maxXCMValue = (0, _utils4.formatNumber)(bnMaxXCM.toString(), inputTokenDecimal);
-      const symbol = (0, _utils3._getAssetSymbol)(altInputTokenInfo);
+      const bnMaxXCM = new _util.BN(originTokenBalance.value).sub(bnAdjustOriginFee);
+      const destinationTokenDecimal = (0, _utils3._getAssetDecimals)(destinationTokenInfo);
+      const maxBn = bnInputTokenBalance.add(bnOriginTokenBalance.sub(bnAdjustOriginFee));
+      const maxValue = (0, _utils4.formatNumber)(maxBn.toString(), destinationTokenInfo.decimals || 0);
+      const maxXCMValue = (0, _utils4.formatNumber)(bnMaxXCM.toString(), destinationTokenDecimal);
+      const symbol = (0, _utils3._getAssetSymbol)(originTokenInfo);
       const inputNetworkName = this.chainInfo.name;
-      const altNetworkName = (0, _utils3._getAssetName)(altInputTokenInfo);
-      const currentValue = (0, _utils4.formatNumber)(bnInputTokenBalance.toString(), inputTokenDecimal);
+      const altNetworkName = (0, _utils3._getChainName)(originChainInfo);
+      const currentValue = (0, _utils4.formatNumber)(bnInputTokenBalance.toString(), destinationTokenDecimal);
       processValidation.message = (0, _i18next.t)('bg.EARNING.services.service.earning.specialHandler.maximumInputExceeded', {
         replace: {
           symbol,
@@ -338,6 +343,24 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       });
       return [new _TransactionError.TransactionError(_types.YieldValidationStatus.NOT_ENOUGH_BALANCE, processValidation.message, processValidation)];
     }
+    const id = (0, _getId.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 (0, _xcm.dryRunXcmExtrinsicV2)(xcmRequest);
+    if (!isDryRunSuccess) {
+      return [new _TransactionError.TransactionError(_types.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) {
@@ -357,7 +380,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const feeTokenInfo = this.state.getAssetBySlug(feeTokenSlug);
     const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
     const defaultFeeTokenSlug = this.feeAssets[0];
-    const bnAmount = new _util.BN(params.amount);
+    const bnStakeAmount = new _util.BN(params.amount);
     if (this.feeAssets.length === 1 && feeTokenSlug === defaultFeeTokenSlug) {
       var _path$totalFee$id;
       const bnFeeAmount = new _util.BN(((_path$totalFee$id = path.totalFee[id]) === null || _path$totalFee$id === void 0 ? void 0 : _path$totalFee$id.amount) || '0');
@@ -371,13 +394,13 @@ class BaseSpecialStakingPoolHandler extends _base.default {
         return [new _TransactionError.TransactionError(_types.YieldValidationStatus.NOT_ENOUGH_FEE, processValidation.message, processValidation)];
       }
     }
-    if (!bnAmount.gte(new _util.BN(poolInfo.statistic.earningThreshold.join || '0'))) {
+    if (!bnStakeAmount.gte(new _util.BN(poolInfo.statistic.earningThreshold.join || '0'))) {
       processValidation.failedStep = path.steps[id];
       processValidation.ok = false;
       processValidation.status = _types.YieldValidationStatus.NOT_ENOUGH_MIN_JOIN_POOL;
       return [new _TransactionError.TransactionError(_types.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 = _types.YieldValidationStatus.NOT_ENOUGH_BALANCE;
@@ -401,8 +424,8 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const balanceService = this.state.balanceService;
     const inputTokenBalance = await balanceService.getTransferableBalance(params.address, inputTokenInfo.originChain, inputTokenSlug);
     const bnInputTokenBalance = new _util.BN(inputTokenBalance.value || '0');
-    const bnAmount = new _util.BN(params.amount);
-    if (bnAmount.lte(_util.BN_ZERO)) {
+    const bnStakeAmount = new _util.BN(params.amount);
+    if (bnStakeAmount.lte(_util.BN_ZERO)) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
     let isXcmOk = false;
@@ -436,31 +459,25 @@ class BaseSpecialStakingPoolHandler extends _base.default {
   async handleTokenApproveStep(data, path) {
     return Promise.reject(new _TransactionError.TransactionError(_types.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 = (0, _utils3._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 _util.BN(inputTokenBalance.value);
-    const bnXcmFee = new _util.BN(xcmFee);
-    const bnAmount = new _util.BN(amount);
-    const bnTotalAmount = bnAmount.sub(bnInputTokenBalance).add(bnXcmFee);
     const id = (0, _getId.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,
@@ -476,7 +493,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       destinationNetworkKey: destinationTokenInfo.originChain,
       from: address,
       to: address,
-      value: bnTotalAmount.toString(),
+      value: sendingValue,
       tokenSlug: originTokenSlug,
       showExtraWarning: true
     };
@@ -485,8 +502,9 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
       extrinsic,
       txData: xcmData,
-      transferNativeAmount: bnTotalAmount.toString(),
-      chainType: _KoniTypes.ChainType.SUBSTRATE
+      transferNativeAmount: sendingValue,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      xcmStepFee
     };
   }
   handleYieldJoin(data, path, currentStep) {
@@ -498,8 +516,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
         return this.handleTokenApproveStep(data, path);
       case _types.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/cjs/services/earning-service/service.js

@@ -441,6 +441,14 @@ class EarningService {
       }
       const updatedItem = structuredClone(item);
       updatedItem.metadata.availableMethod = handler.availableMethod;
+
+      // Disable staking for sunsetted pools
+      if (_constants2.SUNSETTED_YIELD_POOL_SLUGS.includes(item.slug)) {
+        updatedItem.metadata.availableMethod = {
+          ...updatedItem.metadata.availableMethod,
+          join: false
+        };
+      }
       this.updateYieldPoolInfo(updatedItem);
     });
     return onlineData;
@@ -535,7 +543,11 @@ 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 = _constants2.SUNSETTED_YIELD_POOL_SLUGS.includes(item.slug) ? {
+          ...item,
+          status: _types2.EarningStatus.NOT_EARNING
+        } : item;
+        yieldPositionInfo[this._getYieldPositionKey(item.slug, item.address)] = normalizedItem;
       }
     });
     this.yieldPositionSubject.next(yieldPositionInfo);
@@ -558,7 +570,11 @@ class EarningService {
     return `${slug}---${address}`;
   }
   updateYieldPosition(data) {
-    this.yieldPositionPersistQueue.push(data);
+    const normalizedData = _constants2.SUNSETTED_YIELD_POOL_SLUGS.includes(data.slug) ? {
+      ...data,
+      status: _types2.EarningStatus.NOT_EARNING
+    } : data;
+    this.yieldPositionPersistQueue.push(normalizedData);
     (0, _utils2.addLazy)('persistYieldPositionInfo', () => {
       const yieldPositionInfo = this.yieldPositionSubject.getValue();
       const queue = [...this.yieldPositionPersistQueue];
@@ -867,6 +883,7 @@ 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.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR);

package/cjs/services/multisig-service/index.js

@@ -212,7 +212,7 @@ 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/cjs/services/request-service/handler/SubstrateRequestHandler.js

@@ -44,6 +44,18 @@ class SubstrateRequestHandler {
       };
     });
   }
+  updateSignRequest(id, request, signerAddress) {
+    const current = this.getSignRequest(id);
+    if (!current) {
+      throw new _TransactionError.TransactionError(_types.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/cjs/services/request-service/index.js

@@ -175,6 +175,9 @@ 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 === _types.SubstrateTransactionWrappingStatus.WRAP_RESULT) {
       return this.#substrateRequestHandler.signWrappedTransaction(id, address, url, payload, onSign);

package/cjs/services/setting-service/constants.js

@@ -41,7 +41,8 @@ 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/cjs/services/storage-service/db-stores/InappNotification.js

@@ -89,7 +89,7 @@ class InappNotificationStore extends _BaseStore.default {
         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/cjs/services/swap-service/handler/bittensor-handler.js

@@ -0,0 +1,197 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BittensorSwapHandler = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _utils2 = require("../../chain-service/utils");
+var _baseHandler = require("./base-handler");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BittensorSwapHandler {
+  isReady = false;
+  constructor(chainService, balanceService, feeService, isTestnet) {
+    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: isTestnet ? 'Bittensor Testnet' : 'Bittensor',
+      providerSlug: isTestnet ? _types.SwapProviderId.BITTENSOR_TESTNET : _types.SwapProviderId.BITTENSOR
+    });
+    this.providerSlug = isTestnet ? _types.SwapProviderId.BITTENSOR_TESTNET : _types.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: _types.SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: (0, _utils._reformatAddressWithChain)(params.request.address, originChain),
+        receiver: (0, _utils._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 ((0, _bignumber.default)(selectedQuote.fromAmount).lte(0)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_types.DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+    if (swapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case _types.CommonStepType.DEFAULT:
+        return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+      case _types.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 = (0, _utils2._isNativeTokenBySlug)(fromAsset.slug) ? 0 : (_fromAsset$metadata = fromAsset.metadata) === null || _fromAsset$metadata === void 0 ? void 0 : _fromAsset$metadata.netuid;
+    const toNetuid = (0, _utils2._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.TransactionError(_types.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.default((0, _utils.toBNString)(quote.rate, (0, _utils2._getAssetDecimals)(fromAsset)));
+    const limitPrice = priceRatio.multipliedBy(new _bignumber.default(1).minus(params.slippage)).integerValue(_bignumber.default.ROUND_DOWN).toFixed();
+    const calls = this.buildSwapCalls({
+      stakeInfo,
+      fromNetuid,
+      toNetuid,
+      amount: new _bignumber.default(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: _KoniTypes.ExtrinsicType.SWAP,
+      chainType: _KoniTypes.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.default(i.stake).gt(0)).sort((a, b) => new _bignumber.default(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.default(item.stake);
+      if (stake.lte(0)) {
+        continue;
+      }
+      const swapAmount = _bignumber.default.minimum(stake, remaining);
+      calls.push(api.tx.subtensorModule.swapStakeLimit(item.hotkey, fromNetuid, toNetuid, swapAmount.toFixed(), limitPrice, false));
+      remaining = remaining.minus(swapAmount);
+    }
+    return calls;
+  }
+}
+exports.BittensorSwapHandler = BittensorSwapHandler;