@subwallet/extension-base 1.3.62-0 → 1.3.64-0

package/cjs/services/earning-service/handlers/native-staking/tanssi.js

@@ -0,0 +1,496 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = 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 _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _utils = require("../../utils");
+var _basePara = _interopRequireDefault(require("./base-para"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function perbillToPercentBn(perbill) {
+  const raw = new _bignumber.default((perbill === null || perbill === void 0 ? void 0 : perbill.toString()) || '0');
+  const bnPercent = raw.multipliedBy(new _bignumber.default(100)).div(new _bignumber.default(1000000000));
+  return bnPercent.toNumber();
+}
+async function getOwnStakes(chainApi, candidates, delegator) {
+  const queries = [];
+  for (const candidate of candidates) {
+    // Auto-compounding
+    queries.push([candidate, {
+      AutoCompoundingShares: {
+        delegator
+      }
+    }]);
+    queries.push([candidate, 'AutoCompoundingSharesSupply']);
+    queries.push([candidate, 'AutoCompoundingSharesTotalStaked']);
+
+    // Manual rewards
+    queries.push([candidate, {
+      ManualRewardsShares: {
+        delegator
+      }
+    }]);
+    queries.push([candidate, 'ManualRewardsSharesSupply']);
+    queries.push([candidate, 'ManualRewardsSharesTotalStaked']);
+
+    // Joining
+    queries.push([candidate, {
+      JoiningShares: {
+        delegator
+      }
+    }]);
+    queries.push([candidate, 'JoiningSharesSupply']);
+    queries.push([candidate, 'JoiningSharesTotalStaked']);
+
+    // Leaving
+    queries.push([candidate, {
+      LeavingShares: {
+        delegator
+      }
+    }]);
+    queries.push([candidate, 'LeavingSharesSupply']);
+    queries.push([candidate, 'LeavingSharesTotalStaked']);
+
+    // Claimable reward
+    queries.push([candidate, 'ManualRewardsCounter']);
+    queries.push([candidate, {
+      ManualRewardsCheckpoint: {
+        delegator
+      }
+    }]);
+  }
+  const results = await chainApi.api.query.pooledStaking.pools.multi(queries);
+  const stakes = {};
+  const stride = 14;
+  for (let i = 0; i < candidates.length; i++) {
+    const base = i * stride;
+
+    // Auto-compounding
+    const acShares = new _bignumber.default(results[base + 0].toString());
+    const acSupply = new _bignumber.default(results[base + 1].toString());
+    const acTotal = new _bignumber.default(results[base + 2].toString());
+    const autoCompounding = acSupply.isZero() ? new _bignumber.default(0) : acShares.multipliedBy(acTotal).div(acSupply);
+
+    // Manual rewards
+    const mrShares = new _bignumber.default(results[base + 3].toString());
+    const mrSupply = new _bignumber.default(results[base + 4].toString());
+    const mrTotal = new _bignumber.default(results[base + 5].toString());
+    const manualRewards = mrSupply.isZero() ? new _bignumber.default(0) : mrShares.multipliedBy(mrTotal).div(mrSupply);
+
+    // Joining
+    const jShares = new _bignumber.default(results[base + 6].toString());
+    const jSupply = new _bignumber.default(results[base + 7].toString());
+    const jTotal = new _bignumber.default(results[base + 8].toString());
+    const joining = jSupply.isZero() ? new _bignumber.default(0) : jShares.multipliedBy(jTotal).div(jSupply);
+
+    // Leaving
+    const lShares = new _bignumber.default(results[base + 9].toString());
+    const lSupply = new _bignumber.default(results[base + 10].toString());
+    const lTotal = new _bignumber.default(results[base + 11].toString());
+    const leaving = lSupply.isZero() ? new _bignumber.default(0) : lShares.multipliedBy(lTotal).div(lSupply);
+
+    // Claimable rewards
+    const counter = new _bignumber.default(results[base + 12].toString());
+    const checkpoint = new _bignumber.default(results[base + 13].toString());
+    const claimable = counter.minus(checkpoint).multipliedBy(mrShares);
+
+    // Total stake
+    const totalStake = autoCompounding.plus(manualRewards).plus(joining).plus(leaving);
+    stakes[candidates[i]] = {
+      autoCompounding: autoCompounding.toFixed(0),
+      autoCompoundingShares: acShares.toFixed(0),
+      manualRewards: manualRewards.toFixed(0),
+      joining: joining.toFixed(0),
+      leaving: leaving.toFixed(0),
+      totalStake: totalStake.toFixed(0),
+      claimable: claimable.toFixed(0)
+    };
+  }
+  return stakes;
+}
+class TanssiNativeStakingPoolHandler extends _basePara.default {
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: false,
+    cancelUnstake: false,
+    withdraw: false,
+    claimReward: true,
+    changeValidator: false
+  };
+
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const defaultCallback = async () => {
+      const api = await this.substrateApi.isReady;
+      const activeConfig = (await api.api.query.collatorConfiguration.activeConfig()).toPrimitive();
+      const maxCollators = activeConfig.maxCollators;
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription()
+        },
+        statistic: {
+          assetEarning: [{
+            slug: this.nativeToken.slug
+          }],
+          maxCandidatePerFarmer: maxCollators,
+          maxWithdrawalRequestPerFarmer: 1,
+          earningThreshold: {
+            join: '0',
+            defaultUnstake: '0',
+            fastUnstake: '0'
+          },
+          era: 0,
+          eraTime: 6 / 3600,
+          unstakingPeriod: 12
+        }
+      };
+      if (!cancel) {
+        callback(data);
+      }
+    };
+    await defaultCallback();
+    return () => {
+      cancel = true;
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async subscribePoolPosition(useAddresses, onUpdate) {
+    const substrateApi = this.substrateApi;
+    await substrateApi.isReady;
+    let cancel = false;
+    const intervalIds = [];
+    for (const delegator of useAddresses) {
+      const fetchAndUpdate = async () => {
+        if (cancel) {
+          return;
+        }
+        const entries = await substrateApi.api.query.pooledStaking.delegatorCandidateSummaries.entries(delegator);
+        if (!entries || entries.length === 0) {
+          onUpdate({
+            ...this.baseInfo,
+            type: this.type,
+            address: delegator,
+            balanceToken: this.nativeToken.slug,
+            totalStake: '0',
+            activeStake: '0',
+            unstakeBalance: '0',
+            status: _types.EarningStatus.NOT_STAKING,
+            isBondedBefore: false,
+            nominations: [],
+            unstakings: []
+          });
+          return;
+        }
+        const candidates = entries.map(_ref => {
+          let [storageKey] = _ref;
+          return storageKey.args[1].toString();
+        });
+        const ownStakesMap = await getOwnStakes(substrateApi, candidates, delegator);
+        const nominations = [];
+        let bnTotalStake = new _bignumber.default(0);
+        let bnActiveStake = new _bignumber.default(0);
+        let bnUnstakeBalance = new _bignumber.default(0);
+        let bnJoiningStake = new _bignumber.default(0);
+        let bnCompoundingStake = new _bignumber.default(0);
+        let bnManualStake = new _bignumber.default(0);
+        for (const candidate of candidates) {
+          const ownStake = ownStakesMap[candidate];
+          if (!ownStake) {
+            continue;
+          }
+          const autoCompounding = new _bignumber.default(ownStake.autoCompounding);
+          const manualRewards = new _bignumber.default(ownStake.manualRewards);
+          const joining = new _bignumber.default(ownStake.joining);
+          const leaving = new _bignumber.default(ownStake.leaving);
+          const totalStake = new _bignumber.default(ownStake.totalStake);
+          if (totalStake.isZero()) {
+            continue;
+          }
+          bnTotalStake = bnTotalStake.plus(totalStake);
+          bnActiveStake = bnActiveStake.plus(autoCompounding).plus(manualRewards).plus(joining);
+          bnUnstakeBalance = bnUnstakeBalance.plus(leaving);
+          bnJoiningStake = bnJoiningStake.plus(joining);
+          bnCompoundingStake = bnCompoundingStake.plus(autoCompounding);
+          bnManualStake = bnManualStake.plus(manualRewards);
+          const [identity] = await (0, _utils.parseIdentity)(this.substrateIdentityApi, candidate);
+          nominations.push({
+            chain: this.chain,
+            status: _types.EarningStatus.EARNING_REWARD,
+            validatorAddress: candidate,
+            validatorIdentity: identity,
+            activeStake: new _bignumber.default(autoCompounding).plus(manualRewards).toFixed(),
+            hasUnstaking: !leaving.isZero(),
+            validatorMinStake: '0'
+          });
+        }
+        onUpdate({
+          ...this.baseInfo,
+          type: this.type,
+          address: delegator,
+          balanceToken: this.nativeToken.slug,
+          totalStake: bnTotalStake.toString(),
+          activeStake: bnActiveStake.toString(),
+          unstakeBalance: bnUnstakeBalance.toString(),
+          status: nominations.length > 0 ? _types.EarningStatus.EARNING_REWARD : _types.EarningStatus.NOT_STAKING,
+          isBondedBefore: nominations.length > 0,
+          nominations,
+          unstakings: [],
+          metadata: {
+            pendingStake: bnJoiningStake.toString(),
+            compoundingStake: bnCompoundingStake.toString(),
+            manualStake: bnManualStake.toString()
+          }
+        });
+      };
+      fetchAndUpdate().catch(console.error);
+      const intervalId = setInterval(() => {
+        fetchAndUpdate().catch(console.error);
+      }, 30000);
+      intervalIds.push(intervalId);
+    }
+    return () => {
+      cancel = true;
+      intervalIds.forEach(id => clearInterval(id));
+    };
+  }
+  async checkAccountHaveStake(addresses) {
+    const stakedAddresses = [];
+    const api = await this.substrateApi.isReady;
+    const candidateSummariesByAddress = await Promise.all(addresses.map(address => api.api.query.pooledStaking.delegatorCandidateSummaries.entries(address)));
+    for (let i = 0; i < addresses.length; i++) {
+      const candidateSummaries = candidateSummariesByAddress[i];
+      if (candidateSummaries && candidateSummaries.length > 0) {
+        stakedAddresses.push(addresses[i]);
+      }
+    }
+    return stakedAddresses;
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool targets */
+
+  async getPoolTargets() {
+    const chainApi = await this.substrateApi.isReady;
+    const commissionRaw = chainApi.api.consts.pooledStaking.rewardsCollatorCommission.toJSON();
+    const commission = perbillToPercentBn(commissionRaw);
+    const candidates = await chainApi.api.query.pooledStaking.sortedEligibleCandidates();
+    const candidateSummaries = await chainApi.api.query.pooledStaking.candidateSummaries.entries();
+    const candidateSummariesMap = {};
+    candidateSummaries.forEach(_ref2 => {
+      let [key, summary] = _ref2;
+      const address = key.args[0].toString();
+      candidateSummariesMap[address] = summary.toJSON();
+    });
+    const candidateAddresses = candidates.map(c => c.candidate.toString());
+    const targets = await Promise.all(candidates.map(async c => {
+      const address = c.candidate.toString();
+      const totalStake = new _bignumber.default(c.stake.toString());
+      const candidateInfo = candidateSummariesMap[address];
+      const nominatorCount = (candidateInfo === null || candidateInfo === void 0 ? void 0 : candidateInfo.delegators) || 0;
+      const ownStakesMap = await getOwnStakes(chainApi, candidateAddresses, address);
+      const ownStakeInfo = ownStakesMap[address];
+      const ownStake = ownStakeInfo ? new _bignumber.default(ownStakeInfo.totalStake) : new _bignumber.default(0);
+      const otherStake = _bignumber.default.max(totalStake.minus(ownStake), 0);
+      const [identity, isReasonable] = await (0, _utils.parseIdentity)(this.substrateApi, address);
+      const validator = {
+        address,
+        chain: this.chain,
+        totalStake: totalStake.toFixed(),
+        ownStake: ownStake.toFixed(),
+        otherStake: otherStake.toFixed(),
+        minBond: '0',
+        nominatorCount,
+        commission,
+        blocked: false,
+        isVerified: isReasonable,
+        isCrowded: false,
+        identity
+      };
+      return validator;
+    }));
+    return targets;
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  async createJoinExtrinsic(data, positionInfo, bondDest, netuid) {
+    const {
+      amount,
+      selectedValidators
+    } = data;
+    const substrateApi = this.substrateApi;
+    const api = await substrateApi.isReady;
+    const binaryAmount = new _bignumber.default(amount);
+    const selectedCollatorInfo = selectedValidators[0];
+    const {
+      address: selectedCollatorAddress
+    } = selectedCollatorInfo;
+    const extrinsic = api.api.tx.pooledStaking.requestDelegate(selectedCollatorAddress, 'AutoCompounding',
+    // 'ManualRewards'
+    binaryAmount.toFixed());
+    return [extrinsic, {
+      slug: this.nativeToken.slug,
+      amount
+    }];
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    if (!selectedTarget) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const substrateApi = await this.substrateApi.isReady;
+    const txs = [];
+    const stakesMap = await getOwnStakes(substrateApi, [selectedTarget], address);
+    const stakeInfo = stakesMap[selectedTarget];
+    const manualRewards = new _bignumber.default(stakeInfo.manualRewards);
+    const autoCompounding = new _bignumber.default(stakeInfo.autoCompounding);
+    const unstakeAmount = new _bignumber.default(amount);
+    if (manualRewards.gt(0)) {
+      if (unstakeAmount.lte(manualRewards)) {
+        txs.push(substrateApi.api.tx.pooledStaking.requestUndelegate(selectedTarget, 'ManualRewards', {
+          Stake: unstakeAmount.toFixed()
+        }));
+      } else {
+        txs.push(substrateApi.api.tx.pooledStaking.requestUndelegate(selectedTarget, 'ManualRewards', {
+          Stake: manualRewards.toFixed()
+        }));
+        const remaining = unstakeAmount.minus(manualRewards);
+        if (remaining.gt(0)) {
+          const acShares = new _bignumber.default(stakeInfo.autoCompoundingShares || '0');
+          // Unstake all: use Shares to avoid small leftovers as rewards are automatically compounded every 6 seconds
+          const isUnstakeAll = remaining.gte(autoCompounding.multipliedBy(0.9999));
+          txs.push(substrateApi.api.tx.pooledStaking.requestUndelegate(selectedTarget, 'AutoCompounding', isUnstakeAll ? {
+            Shares: acShares.toFixed(0)
+          } : {
+            Stake: remaining.toFixed(0)
+          }));
+        }
+      }
+    } else {
+      const acShares = new _bignumber.default(stakeInfo.autoCompoundingShares || '0');
+      const isUnstakeAll = unstakeAmount.gte(autoCompounding.multipliedBy(0.9999));
+      txs.push(substrateApi.api.tx.pooledStaking.requestUndelegate(selectedTarget, 'AutoCompounding', isUnstakeAll ? {
+        Shares: acShares.toFixed(0)
+      } : {
+        Stake: unstakeAmount.toFixed(0)
+      }));
+    }
+    const extrinsic = txs.length === 1 ? txs[0] : substrateApi.api.tx.utility.batchAll(txs);
+    return [_KoniTypes.ExtrinsicType.STAKING_UNBOND, extrinsic];
+  }
+
+  /* Leave pool action */
+
+  /* Get pool reward */
+  async getPoolReward(useAddresses, callback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    await substrateApi.isReady;
+    await Promise.all(useAddresses.map(async address => {
+      if (cancel) {
+        return;
+      }
+      const delegatorSummaries = await substrateApi.api.query.pooledStaking.delegatorCandidateSummaries.entries(address);
+      if (!delegatorSummaries || delegatorSummaries.length === 0) {
+        const earningRewardItem = {
+          ...this.baseInfo,
+          address,
+          type: this.type,
+          unclaimedReward: '0',
+          state: _KoniTypes.APIItemState.READY
+        };
+        callback(earningRewardItem);
+        return;
+      }
+      const candidates = delegatorSummaries.map(_ref3 => {
+        let [key] = _ref3;
+        return key.args[1].toString();
+      });
+      const ownStakesMap = await getOwnStakes(substrateApi, candidates, address);
+      let totalClaimable = new _bignumber.default(0);
+      for (const candidate of candidates) {
+        const ownStake = ownStakesMap[candidate];
+        if (ownStake) {
+          totalClaimable = totalClaimable.plus(ownStake.claimable || 0);
+        }
+      }
+      const _unclaimedReward = totalClaimable.toFixed();
+      const earningRewardItem = {
+        ...this.baseInfo,
+        address,
+        type: this.type,
+        unclaimedReward: _unclaimedReward,
+        state: _KoniTypes.APIItemState.READY
+      };
+      if (_unclaimedReward !== '0') {
+        await this.createClaimNotification(earningRewardItem, this.nativeToken);
+      }
+      callback(earningRewardItem);
+    }));
+    return () => {
+      cancel = true;
+    };
+  }
+
+  /* Get pool reward */
+
+  /* Other actions */
+
+  async handleYieldClaimReward(address, bondReward) {
+    const api = await this.substrateApi.isReady;
+    const delegatorSummaries = await api.api.query.pooledStaking.delegatorCandidateSummaries.entries(address);
+    if (!delegatorSummaries || delegatorSummaries.length === 0) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR));
+    }
+    const candidates = delegatorSummaries.map(_ref4 => {
+      let [key] = _ref4;
+      return key.args[1].toString();
+    });
+    const ownStakesMap = await getOwnStakes(api, candidates, address);
+    const claimablePairs = [];
+    for (const candidate of candidates) {
+      const ownStake = ownStakesMap[candidate];
+      if (ownStake && new _bignumber.default(ownStake.claimable).gt(0)) {
+        claimablePairs.push([candidate, address]);
+      }
+    }
+    if (claimablePairs.length === 0) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR));
+    }
+    const extrinsic = api.api.tx.pooledStaking.claimManualRewards(claimablePairs);
+    return extrinsic;
+  }
+  handleYieldWithdraw(address, unstakingInfo) {
+    throw new Error('Method not implemented.');
+  }
+  handleYieldCancelUnstake(params) {
+    throw new Error('Method not implemented.');
+  }
+
+  /* Other actions */
+}
+exports.default = TanssiNativeStakingPoolHandler;

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

@@ -17,6 +17,7 @@ var _types2 = require("@subwallet/extension-base/types");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _fetchStaticCache = require("@subwallet/extension-base/utils/fetchStaticCache");
 var _rxjs = require("rxjs");
+var _tanssi = _interopRequireDefault(require("./handlers/native-staking/tanssi"));
 var _handlers = require("./handlers");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
@@ -108,6 +109,9 @@ class EarningService {
       if (_constants2._STAKING_CHAIN_GROUP.energy.includes(chain)) {
         handlers.push(new _handlers.EnergyNativeStakingPoolHandler(this.state, chain));
       }
+      if (_constants2._STAKING_CHAIN_GROUP.tanssi.includes(chain)) {
+        handlers.push(new _tanssi.default(this.state, chain));
+      }
       if (_constants2._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
         const ahMigratedChain = ahMigratedChainMap[chain];
         if (ahMigratedChain) {

package/cjs/services/earning-service/utils/index.js

@@ -122,6 +122,8 @@ function isActionFromValidator(stakingType, chain) {
     return true;
   } else if (_constants._STAKING_CHAIN_GROUP.energy.includes(chain)) {
     return true;
+  } else if (_constants._STAKING_CHAIN_GROUP.tanssi.includes(chain)) {
+    return true;
   }
   return false;
 }

package/cjs/services/migration-service/scripts/MigrateTransactionHistoryBySymbol20251027.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateTransactionHistoryBySymbol20251027 extends _Base.default {
+  async run() {
+    const state = this.state;
+    try {
+      const changeSlugsMap = {
+        'moonriver-ERC20-GLMR.wb-0xFfFffFff1a49463978f19dfD6983f2fa1885C254': 'moonriver-ERC20-GLMR.mb-0xFfFffFff1a49463978f19dfD6983f2fa1885C254'
+      };
+      const allTxs = [];
+      await Promise.all(Object.entries(changeSlugsMap).map(async (_ref, i) => {
+        let [oldSlug, newSlug] = _ref;
+        const oldSlugSplit = oldSlug.split('-');
+        const oldChainSlug = oldSlugSplit[0];
+        const oldSymbolSlug = oldSlugSplit[2];
+        const newSlugSplit = newSlug.split('-');
+        const newSymbolSlug = newSlugSplit[2];
+        const filterTransactions = await state.dbService.stores.transaction.table.where({
+          chain: oldChainSlug
+        }).and(tx => {
+          var _tx$amount;
+          return ((_tx$amount = tx.amount) === null || _tx$amount === void 0 ? void 0 : _tx$amount.symbol) === oldSymbolSlug;
+        }).toArray();
+        if (filterTransactions.length > 0) {
+          for (const transaction of filterTransactions) {
+            if (transaction.amount && transaction.amount.symbol === oldSymbolSlug) {
+              transaction.amount.symbol = newSymbolSlug;
+            }
+            if (transaction.fee && transaction.fee.symbol === oldSymbolSlug) {
+              transaction.fee.symbol = newSymbolSlug;
+            }
+          }
+        }
+        allTxs.push(...filterTransactions);
+      }));
+      await state.dbService.stores.transaction.table.bulkPut(allTxs);
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+}
+exports.default = MigrateTransactionHistoryBySymbol20251027;

package/cjs/services/migration-service/scripts/databases/MigrateAssetSetting20251027.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateAssetSetting20251027 extends _Base.default {
+  async run() {
+    try {
+      const changeSlugsMap = {
+        'moonriver-ERC20-GLMR.wb-0xFfFffFff1a49463978f19dfD6983f2fa1885C254': 'moonriver-ERC20-GLMR.mb-0xFfFffFff1a49463978f19dfD6983f2fa1885C254'
+      };
+      const assetSetting = await this.state.chainService.getAssetSettings();
+      const migratedAssetSetting = {};
+      for (const [oldSlug, newSlug] of Object.entries(changeSlugsMap)) {
+        if (Object.keys(assetSetting).includes(oldSlug)) {
+          const isVisible = assetSetting[oldSlug].visible;
+          migratedAssetSetting[newSlug] = {
+            visible: isVisible
+          };
+        }
+      }
+      this.state.chainService.setAssetSettings({
+        ...assetSetting,
+        ...migratedAssetSetting
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = MigrateAssetSetting20251027;

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

@@ -9,6 +9,7 @@ var _MigrateChainPatrol = _interopRequireDefault(require("@subwallet/extension-b
 var _ClearMetadataDatabase = _interopRequireDefault(require("./databases/ClearMetadataDatabase"));
 var _ClearMetadataForMythos = _interopRequireDefault(require("./databases/ClearMetadataForMythos"));
 var _MigrateAssetSetting = _interopRequireDefault(require("./databases/MigrateAssetSetting"));
+var _MigrateAssetSetting2 = _interopRequireDefault(require("./databases/MigrateAssetSetting20251027"));
 var _MigrateEarningVersion = _interopRequireDefault(require("./databases/MigrateEarningVersion"));
 var _ReloadMetadata = _interopRequireDefault(require("./databases/ReloadMetadata"));
 var _MigrateLedgerAccount = _interopRequireDefault(require("./keyring/MigrateLedgerAccount"));
@@ -33,6 +34,7 @@ var _MigrateTokenDecimals = _interopRequireDefault(require("./MigrateTokenDecima
 var _MigrateTransactionHistory = _interopRequireDefault(require("./MigrateTransactionHistory"));
 var _MigrateTransactionHistoryBridge = _interopRequireDefault(require("./MigrateTransactionHistoryBridge"));
 var _MigrateTransactionHistoryBySymbol = _interopRequireDefault(require("./MigrateTransactionHistoryBySymbol"));
+var _MigrateTransactionHistoryBySymbol2 = _interopRequireDefault(require("./MigrateTransactionHistoryBySymbol20251027"));
 var _MigrateWalletReference = _interopRequireDefault(require("./MigrateWalletReference"));
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -78,6 +80,8 @@ var _default = {
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
   '1.3.42-01': _MigrateNewUnifiedAccount.default,
   '1.3.54-01': _MigrateChainPatrol.default,
-  '1.3.62-01': _DeleteEarningData2.default
+  '1.3.62-01': _DeleteEarningData2.default,
+  '1.3.64-01': _MigrateAssetSetting2.default,
+  '1.3.64-02': _MigrateTransactionHistoryBySymbol2.default
 };
 exports.default = _default;

package/cjs/services/swap-service/handler/base-handler.js

@@ -64,7 +64,10 @@ class SwapBaseHandler {
       return result;
     } catch (e) {
       const errorMessage = e.message;
-      if (errorMessage.toLowerCase().startsWith(_acrossBridge.AcrossErrorMsg.AMOUNT_TOO_LOW) || errorMessage.toLowerCase().startsWith(_acrossBridge.AcrossErrorMsg.AMOUNT_TOO_HIGH)) {
+      if (errorMessage.toLowerCase().startsWith(_utils4.DetectedGenOptimalProcessErrMsg.AMOUNT_TOO_LOW) || errorMessage.toLowerCase().startsWith(_utils4.DetectedGenOptimalProcessErrMsg.AMOUNT_TOO_HIGH)) {
+        throw new Error(errorMessage);
+      }
+      if (errorMessage.toLowerCase().includes(_utils4.DetectedGenOptimalProcessErrMsg.NOT_ENOUGHT_BITCOIN)) {
         throw new Error(errorMessage);
       }
       return result;