@subwallet/extension-base 1.3.1 → 1.3.3-0

package/cjs/services/balance-service/helpers/subscribe/substrate/index.js

@@ -138,6 +138,13 @@ const subscribeWithSystemAccountPallet = async _ref => {
       args: addresses
     });
   }
+  let bittensorStakingBalances = new Array(addresses.length).fill(new _bignumber.default(0));
+  if (['bittensor'].includes(chainInfo.slug)) {
+    bittensorStakingBalances = await Promise.all(addresses.map(async address => {
+      const TaoTotalStake = await substrateApi.api.query.subtensorModule.totalColdkeyStake(address);
+      return new _bignumber.default(TaoTotalStake.toString());
+    }));
+  }
   const subscription = substrateApi.subscribeDataWithMulti(params, rs => {
     const balances = rs[systemAccountKey];
     const poolMemberInfos = rs[poolMembersKey];
@@ -151,6 +158,8 @@ const subscribeWithSystemAccountPallet = async _ref => {
         const nominationPoolBalance = poolMemberInfo ? (0, _nominationpoolsPallet._getTotalStakeInNominationPool)(poolMemberInfo) : BigInt(0);
         totalLockedFromTransfer += nominationPoolBalance;
       }
+      const stakeValue = BigInt(bittensorStakingBalances[index].toString());
+      totalLockedFromTransfer += stakeValue;
       return {
         address: addresses[index],
         tokenSlug: (0, _utils2._getChainNativeTokenSlug)(chainInfo),

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

@@ -64,7 +64,8 @@ const _NFT_CHAIN_GROUP = {
   unique_evm: ['unique_evm'],
   bitcountry: ['bitcountry', 'pioneer', 'continuum_network'],
   vara: ['vara_network'],
-  avail: ['avail_mainnet']
+  avail: ['avail_mainnet'],
+  ternoa: ['ternoa', 'ternoa_alphanet']
 };
 
 // Staking--------------------------------------------------------------------------------------------------------------

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

@@ -1603,21 +1603,18 @@ class ChainService {
     const assetSettings = await this.getAssetSettings();
     const activeChainSlugs = this.getActiveChainSlugs();
     const assetRegistry = this.getAssetRegistry();
-    if (Object.keys(assetSettings).length === 0) {
-      // only initiate the first time
-      Object.values(assetRegistry).forEach(assetInfo => {
-        const isSettingExisted = (assetInfo.slug in assetSettings);
+    Object.values(assetRegistry).forEach(assetInfo => {
+      const isSettingExisted = (assetInfo.slug in assetSettings);
 
-        // Set visible for every enabled chains
-        if (activeChainSlugs.includes(assetInfo.originChain) && !isSettingExisted) {
-          // Setting only exist when set either by chain settings or user
-          assetSettings[assetInfo.slug] = {
-            visible: true
-          };
-        }
-      });
-      this.setAssetSettings(assetSettings, false);
-    }
+      // Set visible for every enabled chains
+      if (activeChainSlugs.includes(assetInfo.originChain) && !isSettingExisted) {
+        // Setting only exist when set either by chain settings or user
+        assetSettings[assetInfo.slug] = {
+          visible: true
+        };
+      }
+    });
+    this.setAssetSettings(assetSettings, false);
     this.eventService.emit('asset.ready', true);
   }
   setAssetSettings(assetSettings) {

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

@@ -22,7 +22,8 @@ const _STAKING_CHAIN_GROUP = {
   liquidStaking: ['bifrost_dot', 'acala', 'parallel', 'moonbeam'],
   lending: ['interlay'],
   krest_network: ['krest_network'],
-  manta: ['manta_network']
+  manta: ['manta_network'],
+  bittensor: ['bittensor', 'bittensor_devnet']
 };
 exports._STAKING_CHAIN_GROUP = _STAKING_CHAIN_GROUP;
 const TON_CHAINS = ['ton', 'ton_testnet'];

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

@@ -82,7 +82,8 @@ class BasePoolHandler {
     const decimals = this.nativeToken.decimals || 0;
     const defaultMaintainBalance = new _util.BN(1).mul(_util.BN_TEN.pow(new _util.BN(decimals)));
     const ed = new _util.BN(this.nativeToken.minAmount || '0');
-    const maintainBalance = ed.gte(defaultMaintainBalance) ? new _util.BN(15).mul(ed).div(_util.BN_TEN) : defaultMaintainBalance;
+    const calculateMaintainBalance = new _util.BN(15).mul(ed).div(_util.BN_TEN);
+    const maintainBalance = ed.gte(defaultMaintainBalance) ? calculateMaintainBalance : defaultMaintainBalance;
     return maintainBalance.toString();
   }
   get metadataInfo() {

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

@@ -28,7 +28,14 @@ Object.defineProperty(exports, "RelayNativeStakingPoolHandler", {
     return _relayChain.default;
   }
 });
+Object.defineProperty(exports, "TaoNativeStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _tao.default;
+  }
+});
 var _amplitude = _interopRequireDefault(require("./amplitude"));
 var _astar = _interopRequireDefault(require("./astar"));
 var _relayChain = _interopRequireDefault(require("./relay-chain"));
-var _paraChain = _interopRequireDefault(require("./para-chain"));
+var _paraChain = _interopRequireDefault(require("./para-chain"));
+var _tao = _interopRequireDefault(require("./tao"));

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

@@ -0,0 +1,394 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.bittensorApiKey = exports.BITTENSOR_API_KEY_2 = exports.BITTENSOR_API_KEY_1 = void 0;
+exports.fetchDelegates = fetchDelegates;
+exports.fetchTaoDelegateState = fetchTaoDelegateState;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/koni/api/staking/bonding/utils");
+var _basePara = _interopRequireDefault(require("@subwallet/extension-base/services/earning-service/handlers/native-staking/base-para"));
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("@polkadot/util");
+var _utils3 = require("../../utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const BITTENSOR_API_KEY_1 = process.env.BITTENSOR_API_KEY_1 || '';
+exports.BITTENSOR_API_KEY_1 = BITTENSOR_API_KEY_1;
+const BITTENSOR_API_KEY_2 = process.env.BITTENSOR_API_KEY_2 || '';
+exports.BITTENSOR_API_KEY_2 = BITTENSOR_API_KEY_2;
+function random() {
+  for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) {
+    keys[_key] = arguments[_key];
+  }
+  const validKeys = keys.filter(key => key);
+  const randomIndex = Math.floor(Math.random() * validKeys.length);
+  return validKeys[randomIndex];
+}
+const bittensorApiKey = () => {
+  return random(BITTENSOR_API_KEY_1, BITTENSOR_API_KEY_2);
+};
+
+/* Fetch data */
+exports.bittensorApiKey = bittensorApiKey;
+async function fetchDelegates() {
+  const apiKey = bittensorApiKey();
+  return new Promise(function (resolve) {
+    fetch('https://api-prod-v2.taostats.io/api/validator/latest/v1', {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `${apiKey}`
+      }
+    }).then(resp => {
+      resolve(resp.json());
+    }).catch(console.error);
+  });
+}
+async function fetchTaoDelegateState(address) {
+  const apiKey = bittensorApiKey();
+  return new Promise(function (resolve) {
+    fetch(`https://api-prod-v2.taostats.io/api/delegation/balance/latest/v1?nominator=${address}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `${apiKey}`
+      }
+    }).then(resp => {
+      resolve(resp.json());
+    }).catch(console.error);
+  });
+}
+
+/* Fetch data */
+
+const testnetDelegate = {
+  '5G6wdAdS7hpBuH1tjuZDhpzrGw9Wf71WEVakDCxHDm1cxEQ2': {
+    name: '0x436c6f776e4e616d65f09fa4a1',
+    url: 'https://example.com  ',
+    image: 'https://example.com/image.png',
+    discord: '0xe28094446973636f7264',
+    description: 'This is an example identity.',
+    additional: ''
+  }
+};
+class TaoNativeStakingPoolHandler extends _basePara.default {
+  /* Unimplemented function  */
+  handleYieldWithdraw(address, unstakingInfo) {
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+  }
+  handleYieldCancelUnstake(params) {
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+  }
+  /* Unimplemented function  */
+
+  get maintainBalance() {
+    const ed = new _util.BN(this.nativeToken.minAmount || '0');
+    const calculateMaintainBalance = new _util.BN(15).mul(ed).div(_util.BN_TEN);
+    const maintainBalance = calculateMaintainBalance;
+    return maintainBalance.toString();
+  }
+
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    const updateStakingInfo = async () => {
+      try {
+        if (cancel) {
+          return;
+        }
+        const minDelegatorStake = await substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
+        const BNminDelegatorStake = new _bignumber.default(minDelegatorStake.toString());
+        const data = {
+          ...this.baseInfo,
+          type: this.type,
+          metadata: {
+            ...this.metadataInfo,
+            description: this.getDescription('0')
+          },
+          statistic: {
+            assetEarning: [{
+              slug: this.nativeToken.slug
+            }],
+            maxCandidatePerFarmer: 16,
+            maxWithdrawalRequestPerFarmer: 1,
+            earningThreshold: {
+              join: BNminDelegatorStake.toString(),
+              defaultUnstake: '0',
+              fastUnstake: '0'
+            },
+            eraTime: 1.2,
+            era: 0,
+            unstakingPeriod: 1.2
+          }
+        };
+        callback(data);
+      } catch (error) {
+        console.log(error);
+      }
+    };
+    const subscribeStakingMetadataInterval = () => {
+      updateStakingInfo().catch(console.error);
+    };
+    await substrateApi.isReady;
+    subscribeStakingMetadataInterval();
+    const interval = setInterval(subscribeStakingMetadataInterval, _constants.BITTENSOR_REFRESH_STAKE_APY);
+    return () => {
+      cancel = true;
+      clearInterval(interval);
+    };
+  }
+
+  /* Subscribe pool position */
+
+  async parseNominatorMetadata(chainInfo, address, delegatorState) {
+    const nominationList = [];
+    const getMinDelegatorStake = this.substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
+    const minDelegatorStake = (await getMinDelegatorStake).toString();
+    let allActiveStake = _util.BN_ZERO;
+    for (const delegate of delegatorState) {
+      const activeStake = delegate.amount;
+      const bnActiveStake = new _util.BN(activeStake);
+      if (bnActiveStake.gt(_util.BN_ZERO)) {
+        const delegationStatus = _types.EarningStatus.EARNING_REWARD;
+        allActiveStake = allActiveStake.add(bnActiveStake);
+        nominationList.push({
+          status: delegationStatus,
+          chain: chainInfo.slug,
+          validatorAddress: delegate.owner,
+          activeStake: activeStake,
+          validatorMinStake: minDelegatorStake
+        });
+      }
+    }
+    const stakingStatus = (0, _utils.getEarningStatusByNominations)(allActiveStake, nominationList);
+    return {
+      status: stakingStatus,
+      balanceToken: this.nativeToken.slug,
+      totalStake: allActiveStake.toString(),
+      activeStake: allActiveStake.toString(),
+      unstakeBalance: '0',
+      isBondedBefore: true,
+      nominations: nominationList,
+      unstakings: []
+    };
+  }
+  async subscribePoolPosition(useAddresses, rsCallback) {
+    let cancel = false;
+    const substrateApi = await this.substrateApi.isReady;
+    const defaultInfo = this.baseInfo;
+    const chainInfo = this.chainInfo;
+    const getDevnetPoolPosition = async () => {
+      const testnetAddress = Object.keys(testnetDelegate)[0];
+      const delegatorState = [];
+      let bnTotalBalance = _util.BN_ZERO;
+      const stakePromises = useAddresses.map(async address => {
+        const stakeAmount = (await substrateApi.api.query.subtensorModule.stake(testnetAddress, address)).toString();
+        const bnStakeAmount = new _util.BN(stakeAmount);
+        bnTotalBalance = bnTotalBalance.add(bnStakeAmount);
+        delegatorState.push({
+          owner: testnetAddress,
+          amount: bnStakeAmount.toString()
+        });
+        rsCallback({
+          ...defaultInfo,
+          type: this.type,
+          address: address,
+          balanceToken: this.nativeToken.slug,
+          totalStake: bnTotalBalance.toString(),
+          activeStake: bnStakeAmount.toString(),
+          unstakeBalance: '0',
+          status: _types.EarningStatus.EARNING_REWARD,
+          isBondedBefore: true,
+          nominations: delegatorState.map(delegate => ({
+            chain: this.chain,
+            validatorAddress: delegate.owner,
+            activeStake: delegate.amount,
+            status: _types.EarningStatus.EARNING_REWARD
+          })),
+          unstakings: []
+        });
+      });
+      await Promise.all(stakePromises);
+    };
+    const getMainnetPoolPosition = async () => {
+      const rawDelegateStateInfos = await Promise.all(useAddresses.map(address => fetchTaoDelegateState(address)));
+      if (rawDelegateStateInfos.length > 0) {
+        rawDelegateStateInfos.forEach((rawDelegateStateInfo, i) => {
+          const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42);
+          const delegatorState = [];
+          let bnTotalBalance = _util.BN_ZERO;
+          const delegateStateInfo = rawDelegateStateInfo.data;
+          for (const delegate of delegateStateInfo) {
+            bnTotalBalance = bnTotalBalance.add(new _util.BN(delegate.balance));
+            delegatorState.push({
+              owner: delegate.delegate.ss58,
+              amount: delegate.balance.toString()
+            });
+          }
+          if (delegateStateInfo && delegateStateInfo.length > 0) {
+            this.parseNominatorMetadata(chainInfo, owner, delegatorState).then(nominatorMetadata => {
+              rsCallback({
+                ...defaultInfo,
+                ...nominatorMetadata,
+                address: owner,
+                type: this.type
+              });
+            }).catch(console.error);
+          } else {
+            rsCallback({
+              ...defaultInfo,
+              type: this.type,
+              address: owner,
+              balanceToken: this.nativeToken.slug,
+              totalStake: '0',
+              activeStake: '0',
+              unstakeBalance: '0',
+              status: _types.EarningStatus.NOT_STAKING,
+              isBondedBefore: false,
+              nominations: [],
+              unstakings: []
+            });
+          }
+        });
+      }
+    };
+    const getStakingPositionInterval = async () => {
+      if (cancel) {
+        return;
+      }
+      if (this.chain === 'bittensor_devnet') {
+        await getDevnetPoolPosition();
+      } else {
+        await getMainnetPoolPosition();
+      }
+    };
+    getStakingPositionInterval().catch(console.error);
+    const intervalId = setInterval(() => {
+      getStakingPositionInterval().catch(console.error);
+    }, _constants.BITTENSOR_REFRESH_STAKE_INFO);
+    return () => {
+      cancel = true;
+      clearInterval(intervalId);
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool targets */
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getDevnetPoolTargets() {
+    const _topValidator = testnetDelegate;
+    const validatorAddresses = Object.keys(_topValidator);
+    return validatorAddresses.map(address => {
+      return {
+        address: address,
+        totalStake: '0',
+        ownStake: '0',
+        otherStake: '0',
+        minBond: '0',
+        nominatorCount: 0,
+        commission: '0',
+        expectedReturn: 0,
+        blocked: false,
+        isVerified: false,
+        chain: this.chain,
+        isCrowded: false,
+        identity: address
+      };
+    });
+  }
+  async getMainnetPoolTargets() {
+    const _topValidator = await fetchDelegates();
+    const topValidator = _topValidator;
+    const getNominatorMinRequiredStake = this.substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
+    const nominatorMinRequiredStake = (await getNominatorMinRequiredStake).toString();
+    const bnMinBond = new _util.BN(nominatorMinRequiredStake);
+    const validatorList = topValidator.data;
+    const validatorAddresses = Object.keys(validatorList);
+    const results = await Promise.all(validatorAddresses.map(i => {
+      const address = validatorList[i].hotkey.ss58;
+      const bnTotalStake = new _util.BN(validatorList[i].stake);
+      const bnOwnStake = new _util.BN(validatorList[i].validator_stake);
+      const otherStake = bnTotalStake.sub(bnOwnStake);
+      const nominatorCount = validatorList[i].nominators;
+      const commission = validatorList[i].take;
+      const roundedCommission = (parseFloat(commission) * 100).toFixed(0);
+      const apr = (parseFloat(validatorList[i].apr) / 10 ** 9 * 100).toFixed(2);
+      const apyCalculate = (0, _utils3.calculateReward)(parseFloat(apr));
+      const name = validatorList[i].name || address;
+      return {
+        address: address,
+        totalStake: bnTotalStake.toString(),
+        ownStake: bnOwnStake.toString(),
+        otherStake: otherStake.toString(),
+        minBond: bnMinBond.toString(),
+        nominatorCount: nominatorCount,
+        commission: roundedCommission,
+        expectedReturn: apyCalculate.apy,
+        blocked: false,
+        isVerified: false,
+        chain: this.chain,
+        isCrowded: false,
+        identity: name
+      };
+    }));
+    return results;
+  }
+  async getPoolTargets() {
+    if (this.chain === 'bittensor_devnet') {
+      return this.getDevnetPoolTargets();
+    } else {
+      return this.getMainnetPoolTargets();
+    }
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  async createJoinExtrinsic(data, positionInfo) {
+    let bondDest = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'Staked';
+    const {
+      amount,
+      selectedValidators: targetValidators
+    } = data;
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const selectedValidatorInfo = targetValidators[0];
+    const hotkey = selectedValidatorInfo.address;
+    const extrinsic = chainApi.api.tx.subtensorModule.addStake(hotkey, binaryAmount);
+    return [extrinsic, {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const apiPromise = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const poolPosition = await this.getPoolPosition(address);
+    if (!selectedTarget || !poolPosition) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const extrinsic = apiPromise.api.tx.subtensorModule.removeStake(selectedTarget, binaryAmount);
+    return [_KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL, extrinsic];
+  }
+
+  /* Leave pool action */
+}
+exports.default = TaoNativeStakingPoolHandler;

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

@@ -72,6 +72,9 @@ class EarningService {
       if (_constants2._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
         handlers.push(new _handlers.AmplitudeNativeStakingPoolHandler(this.state, chain));
       }
+      if (_constants2._STAKING_CHAIN_GROUP.bittensor.includes(chain)) {
+        handlers.push(new _handlers.TaoNativeStakingPoolHandler(this.state, chain));
+      }
       if (_constants2._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
         handlers.push(new _handlers.NominationPoolHandler(this.state, chain));
       }

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

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

package/cjs/services/keyring-service/context/handlers/Modify.js

@@ -121,14 +121,16 @@ class AccountModifyHandler extends _Base.AccountBaseHandler {
     } = _ref2;
     const modifyPairs = this.state.modifyPairs;
     const isUnified = this.state.isUnifiedAccount(proxyId);
+    const oldAccounts = Object.keys(this.state.accounts);
+    const afterDeleteAccounts = oldAccounts.filter(id => id !== proxyId);
     let addresses;
     if (!isUnified) {
       addresses = [proxyId];
     } else {
       addresses = Object.keys(modifyPairs).filter(address => modifyPairs[address].accountProxyId === proxyId);
-      this.state.deleteAccountProxy(proxyId);
-      this.parentService.eventRemoveAccount(proxyId);
     }
+    this.state.deleteAccountProxy(proxyId);
+    this.parentService.eventRemoveAccountProxy(proxyId);
     for (const address of addresses) {
       delete modifyPairs[address];
     }
@@ -137,7 +139,13 @@ class AccountModifyHandler extends _Base.AccountBaseHandler {
       _uiKeyring.keyring.forgetAccount(address);
     }
     await Promise.all(addresses.map(address => new Promise(resolve => this.state.removeAccountRef(address, resolve))));
-    this.state.saveCurrentAccountProxyId(_constants.ALL_ACCOUNT_KEY);
+
+    // Cannot use `this.state.accounts` because it is not completely updated yet
+    if (afterDeleteAccounts.length > 1) {
+      this.state.saveCurrentAccountProxyId(_constants.ALL_ACCOUNT_KEY);
+    } else {
+      this.state.saveCurrentAccountProxyId(afterDeleteAccounts[0]);
+    }
     return addresses;
   }
   tonGetAllTonWalletContractVersion(request) {

package/cjs/services/keyring-service/context/state.js

@@ -450,12 +450,11 @@ class AccountState {
     if (proxyId === _constants.ALL_ACCOUNT_KEY) {
       return allowGetAllAccount ? this.getAllAddresses() : [];
     }
-    const accountProxies = this._accountProxy.value;
-    const modifyPairs = this._modifyPair.value;
+    const accountProxies = this.accounts;
     if (!accountProxies[proxyId]) {
       return [proxyId];
     } else {
-      return Object.keys(modifyPairs).filter(address => modifyPairs[address].accountProxyId === proxyId);
+      return accountProxies[proxyId].accounts.map(account => account.address);
     }
   }
 

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

@@ -29,7 +29,7 @@ class KeyringService {
   eventInjectReady() {
     this.state.eventService.emit('inject.ready', true);
   }
-  eventRemoveAccount(proxyId) {
+  eventRemoveAccountProxy(proxyId) {
     this.state.eventService.emit('accountProxy.remove', proxyId);
   }
   updateKeyringState() {

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

@@ -238,7 +238,6 @@ class ChainflipSwapHandler {
         switch (fee.type) {
           case ChainflipFeeType.INGRESS:
             {
-              console.log('ingress', fee);
               feeComponent.push({
                 tokenSlug: fromAsset.slug,
                 amount: fee.amount,
@@ -250,7 +249,6 @@ class ChainflipSwapHandler {
           // eslint-disable-next-line no-fallthrough
           case ChainflipFeeType.EGRESS:
             {
-              console.log('egress', fee);
               feeComponent.push({
                 tokenSlug: toAsset.slug,
                 amount: fee.amount,
@@ -266,7 +264,6 @@ class ChainflipSwapHandler {
           // eslint-disable-next-line no-fallthrough
           case ChainflipFeeType.BROKER:
             {
-              console.log('broker fee', fee);
               feeComponent.push({
                 tokenSlug: this.intermediaryAssetSlug,
                 amount: fee.amount,
@@ -343,7 +340,8 @@ class ChainflipSwapHandler {
     const {
       address,
       quote,
-      recipient
+      recipient,
+      slippage
     } = params;
     const pair = quote.pair;
     const fromAsset = this.chainService.getAssetBySlug(pair.from);
@@ -355,14 +353,24 @@ class ChainflipSwapHandler {
     const destChainId = this.chainMapping[toAsset.originChain];
     const fromAssetId = (0, _utils._getAssetSymbol)(fromAsset);
     const toAssetId = (0, _utils._getAssetSymbol)(toAsset);
+    const minReceive = new _bignumber.default(quote.rate).times(1 - slippage).toString();
     const depositAddressResponse = await this.swapSdk.requestDepositAddress({
       srcChain: srcChainId,
       destChain: destChainId,
       srcAsset: fromAssetId,
       destAsset: toAssetId,
       destAddress: receiver,
-      amount: quote.fromAmount
+      amount: quote.fromAmount,
+      fillOrKillParams: {
+        minPrice: minReceive,
+        // minimum accepted price for swaps through the channel
+        refundAddress: address,
+        // address to which assets are refunded
+        retryDurationBlocks: 100 // 100 blocks * 6 seconds = 10 minutes before deposits are refunded
+      }
     });
+
+    console.log('depositAddressResp', depositAddressResponse);
     const txData = {
       address,
       provider: this.providerInfo,

package/cjs/services/transaction-service/utils.js

@@ -36,6 +36,9 @@ function getBlockExplorerAccountRoute(explorerLink) {
   if (explorerLink.includes('invarch.statescan.io')) {
     return '#/accounts';
   }
+  if (explorerLink.includes('explorer.zkverify.io')) {
+    return 'account';
+  }
   return 'address';
 }
 function getBlockExplorerTxRoute(chainInfo) {
@@ -57,6 +60,9 @@ function getExplorerLink(chainInfo, value, type) {
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }
   if (explorerLink && value.startsWith('0x')) {
+    if (chainInfo.slug === 'bittensor') {
+      return undefined;
+    }
     const route = getBlockExplorerTxRoute(chainInfo);
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }

package/cjs/types/swap/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._SUPPORTED_SWAP_PROVIDERS = exports.SwapStepType = exports.SwapProviderId = exports.SwapFeeType = exports.SwapErrorType = void 0;
+exports._SUPPORTED_SWAP_PROVIDERS = exports.SwapStepType = exports.SwapProviderId = exports.SwapFeeType = exports.SwapErrorType = exports.CHAINFLIP_SLIPPAGE = void 0;
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 // core
@@ -47,4 +47,6 @@ exports.SwapFeeType = SwapFeeType;
   SwapFeeType["PLATFORM_FEE"] = "PLATFORM_FEE";
   SwapFeeType["NETWORK_FEE"] = "NETWORK_FEE";
   SwapFeeType["WALLET_FEE"] = "WALLET_FEE";
-})(SwapFeeType || (exports.SwapFeeType = SwapFeeType = {}));
+})(SwapFeeType || (exports.SwapFeeType = SwapFeeType = {}));
+const CHAINFLIP_SLIPPAGE = 0.02; // Example: 0.01 for 1%
+exports.CHAINFLIP_SLIPPAGE = CHAINFLIP_SLIPPAGE;