@subwallet/extension-base 1.3.62-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/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>;

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

@@ -1,13 +1,12 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { COMMON_ASSETS } from '@subwallet/chain-list';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { createBitcoinTransaction } from '@subwallet/extension-base/services/balance-service/transfer/bitcoin-transfer';
 import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/extension-base/services/balance-service/transfer/smart-contract';
 import { createSubstrateExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
-import { _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken, _isPureBitcoinChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { _chainInfoToChainType, _getContractAddressOfToken, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
@@ -15,12 +14,7 @@ import { _reformatAddressWithChain, fetchFromProxyService } from '@subwallet/ext
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
 import * as bitcoin from 'bitcoinjs-lib';
-const INTERMEDIARY_MAINNET_ASSET_SLUG = COMMON_ASSETS.USDC_ETHEREUM;
-const INTERMEDIARY_TESTNET_ASSET_SLUG = COMMON_ASSETS.USDC_SEPOLIA;
 export class ChainflipSwapHandler {
-  // private baseUrl: string;
-  // private assetsUrl: string;
-
   constructor(chainService, balanceService, feeService, isTestnet = true) {
     this.swapBaseHandler = new SwapBaseHandler({
       chainService,
@@ -31,10 +25,7 @@ export class ChainflipSwapHandler {
     });
     this.isTestnet = isTestnet;
     this.providerSlug = isTestnet ? SwapProviderId.CHAIN_FLIP_TESTNET : SwapProviderId.CHAIN_FLIP_MAINNET;
-    // this.baseUrl = getChainflipSwap(isTestnet);
-    // this.assetsUrl = getAssetsUrl(isTestnet);
   }
-
   get chainService() {
     return this.swapBaseHandler.chainService;
   }
@@ -50,13 +41,6 @@ export class ChainflipSwapHandler {
   get slug() {
     return this.swapBaseHandler.slug;
   }
-  get intermediaryAssetSlug() {
-    if (this.isTestnet) {
-      return INTERMEDIARY_TESTNET_ASSET_SLUG;
-    } else {
-      return INTERMEDIARY_MAINNET_ASSET_SLUG;
-    }
-  }
   async handleSubmitStep(params) {
     const {
       address,
@@ -70,7 +54,7 @@ export class ChainflipSwapHandler {
     const fromAsset = this.chainService.getAssetBySlug(pair.from);
     const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
     const toChainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
-    const chainType = _isChainSubstrateCompatible(chainInfo) ? ChainType.SUBSTRATE : _isPureBitcoinChain(chainInfo) ? ChainType.BITCOIN : ChainType.EVM; // todo: improve throw error for unknown chain
+    const chainType = _chainInfoToChainType(chainInfo);
     const receiver = _reformatAddressWithChain(recipient !== null && recipient !== void 0 ? recipient : address, toChainInfo);
     const minReceive = new BigNumber(quote.rate).times(1 - slippage).toString();
     const processMetadata = process.steps[currentStep].metadata;

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

@@ -0,0 +1,43 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import FeeService from '@subwallet/extension-base/services/fee-service/service';
+import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+interface OptimexTradeMetadata {
+    trade_id: string;
+    deposit_address: string;
+    payload: string;
+    need_approve: boolean;
+    approve_address: string;
+    approve_payload: string;
+}
+export declare class OptimexHandler implements SwapBaseInterface {
+    private readonly baseUrl;
+    private currentTradeMetadata;
+    private swapBaseHandler;
+    private isTestnet;
+    providerSlug: SwapProviderId;
+    constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService, isTestnet?: boolean);
+    get chainService(): ChainService;
+    get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
+    get name(): string;
+    get slug(): string;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
+    initTrade(request: OptimalSwapPathParamsV2): Promise<OptimexTradeMetadata | undefined>;
+    getApprovalStep(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleApproveStep(params: SwapSubmitParams): {
+        txChain: string;
+        txData: string;
+        extrinsic: {};
+        extrinsicType: ExtrinsicType;
+        transferNativeAmount: string;
+        chainType: ChainType;
+    };
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+}
+export {};