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

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

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ChainflipSwapHandler = void 0;
-var _chainList = require("@subwallet/chain-list");
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _bitcoinTransfer = require("@subwallet/extension-base/services/balance-service/transfer/bitcoin-transfer");
@@ -24,12 +23,7 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const INTERMEDIARY_MAINNET_ASSET_SLUG = _chainList.COMMON_ASSETS.USDC_ETHEREUM;
-const INTERMEDIARY_TESTNET_ASSET_SLUG = _chainList.COMMON_ASSETS.USDC_SEPOLIA;
 class ChainflipSwapHandler {
-  // private baseUrl: string;
-  // private assetsUrl: string;
-
   constructor(chainService, balanceService, feeService) {
     let isTestnet = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
     this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
@@ -41,10 +35,7 @@ class ChainflipSwapHandler {
     });
     this.isTestnet = isTestnet;
     this.providerSlug = isTestnet ? _types.SwapProviderId.CHAIN_FLIP_TESTNET : _types.SwapProviderId.CHAIN_FLIP_MAINNET;
-    // this.baseUrl = getChainflipSwap(isTestnet);
-    // this.assetsUrl = getAssetsUrl(isTestnet);
   }
-
   get chainService() {
     return this.swapBaseHandler.chainService;
   }
@@ -60,13 +51,6 @@ 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,
@@ -80,7 +64,7 @@ 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 = (0, _utils._isChainSubstrateCompatible)(chainInfo) ? _KoniTypes.ChainType.SUBSTRATE : (0, _utils._isPureBitcoinChain)(chainInfo) ? _KoniTypes.ChainType.BITCOIN : _KoniTypes.ChainType.EVM; // todo: improve throw error for unknown chain
+    const chainType = (0, _utils._chainInfoToChainType)(chainInfo);
     const receiver = (0, _utils2._reformatAddressWithChain)(recipient !== null && recipient !== void 0 ? recipient : address, toChainInfo);
     const minReceive = new _bignumber.default(quote.rate).times(1 - slippage).toString();
     const processMetadata = process.steps[currentStep].metadata;