@subwallet/extension-base 1.3.61-0 → 1.3.63-0

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

@@ -0,0 +1,478 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { APIItemState, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BasicTxErrorType, EarningStatus } from '@subwallet/extension-base/types';
+import BigN from 'bignumber.js';
+import { parseIdentity } from "../../utils/index.js";
+import BaseParaNativeStakingPoolHandler from "./base-para.js";
+function perbillToPercentBn(perbill) {
+  const raw = new BigN((perbill === null || perbill === void 0 ? void 0 : perbill.toString()) || '0');
+  const bnPercent = raw.multipliedBy(new BigN(100)).div(new BigN(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 BigN(results[base + 0].toString());
+    const acSupply = new BigN(results[base + 1].toString());
+    const acTotal = new BigN(results[base + 2].toString());
+    const autoCompounding = acSupply.isZero() ? new BigN(0) : acShares.multipliedBy(acTotal).div(acSupply);
+
+    // Manual rewards
+    const mrShares = new BigN(results[base + 3].toString());
+    const mrSupply = new BigN(results[base + 4].toString());
+    const mrTotal = new BigN(results[base + 5].toString());
+    const manualRewards = mrSupply.isZero() ? new BigN(0) : mrShares.multipliedBy(mrTotal).div(mrSupply);
+
+    // Joining
+    const jShares = new BigN(results[base + 6].toString());
+    const jSupply = new BigN(results[base + 7].toString());
+    const jTotal = new BigN(results[base + 8].toString());
+    const joining = jSupply.isZero() ? new BigN(0) : jShares.multipliedBy(jTotal).div(jSupply);
+
+    // Leaving
+    const lShares = new BigN(results[base + 9].toString());
+    const lSupply = new BigN(results[base + 10].toString());
+    const lTotal = new BigN(results[base + 11].toString());
+    const leaving = lSupply.isZero() ? new BigN(0) : lShares.multipliedBy(lTotal).div(lSupply);
+
+    // Claimable rewards
+    const counter = new BigN(results[base + 12].toString());
+    const checkpoint = new BigN(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;
+}
+export default class TanssiNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
+  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: EarningStatus.NOT_STAKING,
+            isBondedBefore: false,
+            nominations: [],
+            unstakings: []
+          });
+          return;
+        }
+        const candidates = entries.map(([storageKey]) => storageKey.args[1].toString());
+        const ownStakesMap = await getOwnStakes(substrateApi, candidates, delegator);
+        const nominations = [];
+        let bnTotalStake = new BigN(0);
+        let bnActiveStake = new BigN(0);
+        let bnUnstakeBalance = new BigN(0);
+        let bnJoiningStake = new BigN(0);
+        let bnCompoundingStake = new BigN(0);
+        let bnManualStake = new BigN(0);
+        for (const candidate of candidates) {
+          const ownStake = ownStakesMap[candidate];
+          if (!ownStake) {
+            continue;
+          }
+          const autoCompounding = new BigN(ownStake.autoCompounding);
+          const manualRewards = new BigN(ownStake.manualRewards);
+          const joining = new BigN(ownStake.joining);
+          const leaving = new BigN(ownStake.leaving);
+          const totalStake = new BigN(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 parseIdentity(this.substrateIdentityApi, candidate);
+          nominations.push({
+            chain: this.chain,
+            status: EarningStatus.EARNING_REWARD,
+            validatorAddress: candidate,
+            validatorIdentity: identity,
+            activeStake: new BigN(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 ? EarningStatus.EARNING_REWARD : 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(([key, summary]) => {
+      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 BigN(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 BigN(ownStakeInfo.totalStake) : new BigN(0);
+      const otherStake = BigN.max(totalStake.minus(ownStake), 0);
+      const [identity, isReasonable] = await 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 BigN(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(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 BigN(stakeInfo.manualRewards);
+    const autoCompounding = new BigN(stakeInfo.autoCompounding);
+    const unstakeAmount = new BigN(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 BigN(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 BigN(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 [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: APIItemState.READY
+        };
+        callback(earningRewardItem);
+        return;
+      }
+      const candidates = delegatorSummaries.map(([key]) => key.args[1].toString());
+      const ownStakesMap = await getOwnStakes(substrateApi, candidates, address);
+      let totalClaimable = new BigN(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: 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(BasicTxErrorType.INTERNAL_ERROR));
+    }
+    const candidates = delegatorSummaries.map(([key]) => 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 BigN(ownStake.claimable).gt(0)) {
+        claimablePairs.push([candidate, address]);
+      }
+    }
+    if (claimablePairs.length === 0) {
+      return Promise.reject(new TransactionError(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 */
+}

package/services/earning-service/service.js

@@ -13,6 +13,7 @@ import { BasicTxErrorType, 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';
+import TanssiNativeStakingPoolHandler from "./handlers/native-staking/tanssi.js";
 import { AcalaLiquidStakingPoolHandler, AmplitudeNativeStakingPoolHandler, AstarNativeStakingPoolHandler, BifrostLiquidStakingPoolHandler, BifrostMantaLiquidStakingPoolHandler, EnergyNativeStakingPoolHandler, InterlayLendingPoolHandler, NominationPoolHandler, ParallelLiquidStakingPoolHandler, ParaNativeStakingPoolHandler, RelayNativeStakingPoolHandler, StellaSwapLiquidStakingPoolHandler, SubnetTaoStakingPoolHandler, TaoNativeStakingPoolHandler } from "./handlers/index.js";
 export const fetchPoolsData = async () => {
   const fetchData = await fetchStaticCache('earning/yield-pools.json', {
@@ -100,6 +101,9 @@ export default class EarningService {
       if (_STAKING_CHAIN_GROUP.energy.includes(chain)) {
         handlers.push(new EnergyNativeStakingPoolHandler(this.state, chain));
       }
+      if (_STAKING_CHAIN_GROUP.tanssi.includes(chain)) {
+        handlers.push(new TanssiNativeStakingPoolHandler(this.state, chain));
+      }
       if (_STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
         const ahMigratedChain = ahMigratedChainMap[chain];
         if (ahMigratedChain) {

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

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

package/services/fee-service/utils/tokenPayFee.js

@@ -22,7 +22,18 @@ export async function getAssetHubTokensCanPayFee(request) {
 
   // ensure nativeTokenInfo and localTokenInfo have multi-location metadata beforehand to improve performance.
   const tokensHasBalanceSlug = Object.keys(tokensHasBalanceInfoMap);
-  const tokenInfos = tokensHasBalanceSlug.map(tokenSlug => chainService.getAssetBySlug(tokenSlug)).filter(token => token.originChain === substrateApi.chainSlug && token.assetType !== _AssetType.NATIVE && token.metadata && token.metadata.multilocation);
+  const tokenInfos = tokensHasBalanceSlug.map(tokenSlug => {
+    const token = chainService.getAssetBySlug(tokenSlug);
+    if (!token) {
+      console.error(`[getAssetHubTokensCanPayFee] Token not found for slug: ${tokenSlug}`);
+    }
+    return token;
+  }).filter(token => {
+    if (!token) {
+      return false;
+    }
+    return token.originChain === substrateApi.chainSlug && token.assetType !== _AssetType.NATIVE && token.metadata && token.metadata.multilocation;
+  });
   await Promise.all(tokenInfos.map(async tokenInfo => {
     try {
       const tokenSlug = tokenInfo.slug;
@@ -70,7 +81,19 @@ export async function getHydrationTokensCanPayFee(request) {
   if (!nativePriceId) {
     return tokensList;
   }
-  const tokenInfos = Object.keys(tokensHasBalanceInfoMap).map(tokenSlug => chainService.getAssetBySlug(tokenSlug)).filter(token => token.originChain === substrateApi.chainSlug && token.assetType !== _AssetType.NATIVE && !!token.metadata && !!token.metadata.assetId);
+  const tokenInfos = Object.keys(tokensHasBalanceInfoMap).map(tokenSlug => {
+    const token = chainService.getAssetBySlug(tokenSlug);
+    if (!token) {
+      console.error(`[getHydrationTokensCanPayFee] Token not found for slug: ${tokenSlug}`);
+    }
+    return token;
+  }).filter(token => {
+    var _token$metadata;
+    if (!token) {
+      return false;
+    }
+    return token.originChain === substrateApi.chainSlug && token.assetType !== _AssetType.NATIVE && !!((_token$metadata = token.metadata) !== null && _token$metadata !== void 0 && _token$metadata.assetId);
+  });
   await Promise.all(tokenInfos.map(async tokenInfo => {
     const priceId = _getAssetPriceId(tokenInfo);
     const rate = await getHydrationRate(address, nativeTokenInfo, tokenInfo);

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

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

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

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class DeleteEarningData20251010 extends BaseMigrationJob {
+  async run() {
+    try {
+      await this.state.dbService.deleteYieldPoolInfo(['KSM___native_staking___kusama', 'KSM___nomination_pool___kusama']);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}

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

@@ -18,6 +18,7 @@ import MigratePolygonUSDCProvider from "./tokens/MigratePolygonUSDCProvider.js";
 import DeleteChain from "./DeleteChain.js";
 import DeleteChainStaking from "./DeleteChainStaking.js";
 import DeleteEarningData from "./DeleteEarningData.js";
+import DeleteEarningData20251010 from "./DeleteEarningData20251010.js";
 import DisableZeroBalanceTokens from "./DisableZeroBalanceTokens.js";
 import EnableVaraChain from "./EnableVaraChain.js";
 import MigrateAuthUrls from "./MigrateAuthUrls.js";
@@ -67,5 +68,6 @@ export default {
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
   '1.3.42-01': MigrateNewUnifiedAccount,
-  '1.3.54-01': MigrateChainPatrol
+  '1.3.54-01': MigrateChainPatrol,
+  '1.3.62-01': DeleteEarningData20251010
 };

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

@@ -8,10 +8,10 @@ import { _isAccountActive } from '@subwallet/extension-base/core/substrate/syste
 import { _isAcrossBridgeXcm, _isSnowBridgeXcm, _isXcmWithinSameConsensus } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { _isSufficientToken } from '@subwallet/extension-base/core/utils';
 import { createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
-import { _isAcrossChainBridge, AcrossErrorMsg } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
+import { _isAcrossChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
 import { estimateXcmFee } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { _getAssetDecimals, _getAssetOriginChain, _getAssetSymbol, _getChainNativeTokenSlug, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken, _isPureBitcoinChain } from '@subwallet/extension-base/services/chain-service/utils';
-import { DEFAULT_EXCESS_AMOUNT_WEIGHT, FEE_RATE_MULTIPLIER } from '@subwallet/extension-base/services/swap-service/utils';
+import { DEFAULT_EXCESS_AMOUNT_WEIGHT, DetectedGenOptimalProcessErrMsg, FEE_RATE_MULTIPLIER } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType, SwapStepType, TransferTxErrorType } from '@subwallet/extension-base/types';
 import { CommonStepType, DEFAULT_FIRST_STEP, MOCK_STEP_FEE } from '@subwallet/extension-base/types/service-base';
 import { DynamicSwapType, SwapErrorType, SwapFeeType } from '@subwallet/extension-base/types/swap';
@@ -56,7 +56,10 @@ export class SwapBaseHandler {
       return result;
     } catch (e) {
       const errorMessage = e.message;
-      if (errorMessage.toLowerCase().startsWith(AcrossErrorMsg.AMOUNT_TOO_LOW) || errorMessage.toLowerCase().startsWith(AcrossErrorMsg.AMOUNT_TOO_HIGH)) {
+      if (errorMessage.toLowerCase().startsWith(DetectedGenOptimalProcessErrMsg.AMOUNT_TOO_LOW) || errorMessage.toLowerCase().startsWith(DetectedGenOptimalProcessErrMsg.AMOUNT_TOO_HIGH)) {
+        throw new Error(errorMessage);
+      }
+      if (errorMessage.toLowerCase().includes(DetectedGenOptimalProcessErrMsg.NOT_ENOUGHT_BITCOIN)) {
         throw new Error(errorMessage);
       }
       return result;

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

@@ -1,4 +1,3 @@
-import { COMMON_ASSETS } from '@subwallet/chain-list';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
@@ -15,7 +14,6 @@ export declare class ChainflipSwapHandler implements SwapBaseInterface {
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
     get name(): string;
     get slug(): string;
-    get intermediaryAssetSlug(): COMMON_ASSETS.USDC_ETHEREUM | COMMON_ASSETS.USDC_SEPOLIA;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;