@subwallet/extension-base 1.3.1 → 1.3.3-0

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

@@ -4,4 +4,5 @@
 export { default as AmplitudeNativeStakingPoolHandler } from "./amplitude.js";
 export { default as AstarNativeStakingPoolHandler } from "./astar.js";
 export { default as RelayNativeStakingPoolHandler } from "./relay-chain.js";
-export { default as ParaNativeStakingPoolHandler } from "./para-chain.js";
+export { default as ParaNativeStakingPoolHandler } from "./para-chain.js";
+export { default as TaoNativeStakingPoolHandler } from "./tao.js";

package/services/earning-service/handlers/native-staking/tao.d.ts

@@ -0,0 +1,49 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import BaseParaStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/base-para';
+import { BaseYieldPositionInfo, StakeCancelWithdrawalParams, SubmitJoinNativeStaking, TransactionData, UnstakingInfo, ValidatorInfo, YieldPoolInfo, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+interface TaoStakingStakeOption {
+    owner: string;
+    amount: string;
+}
+export interface RawDelegateState {
+    data: Array<{
+        delegate: {
+            ss58: string;
+        };
+        balance: string;
+    }>;
+}
+interface ValidatorResponse {
+    data: Validator[];
+}
+interface Validator {
+    hotkey: {
+        ss58: string;
+    };
+    name: string;
+    nominators: number;
+    stake: string;
+    validator_stake: string;
+    take: string;
+    apr: string;
+}
+export declare const BITTENSOR_API_KEY_1: string;
+export declare const BITTENSOR_API_KEY_2: string;
+export declare const bittensorApiKey: () => string;
+export declare function fetchDelegates(): Promise<ValidatorResponse>;
+export declare function fetchTaoDelegateState(address: string): Promise<RawDelegateState>;
+export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHandler {
+    handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
+    handleYieldCancelUnstake(params: StakeCancelWithdrawalParams): Promise<TransactionData>;
+    get maintainBalance(): string;
+    subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
+    parseNominatorMetadata(chainInfo: _ChainInfo, address: string, delegatorState: TaoStakingStakeOption[]): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
+    subscribePoolPosition(useAddresses: string[], rsCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    private getDevnetPoolTargets;
+    private getMainnetPoolTargets;
+    getPoolTargets(): Promise<ValidatorInfo[]>;
+    createJoinExtrinsic(data: SubmitJoinNativeStaking, positionInfo?: YieldPositionInfo, bondDest?: string): Promise<[TransactionData, YieldTokenBaseInfo]>;
+    handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+}
+export {};

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

@@ -0,0 +1,378 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BITTENSOR_REFRESH_STAKE_APY, BITTENSOR_REFRESH_STAKE_INFO } from '@subwallet/extension-base/constants';
+import { getEarningStatusByNominations } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import BaseParaStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/base-para';
+import { BasicTxErrorType, EarningStatus } from '@subwallet/extension-base/types';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
+import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
+import { calculateReward } from "../../utils/index.js";
+export const BITTENSOR_API_KEY_1 = process.env.BITTENSOR_API_KEY_1 || '';
+export const BITTENSOR_API_KEY_2 = process.env.BITTENSOR_API_KEY_2 || '';
+function random(...keys) {
+  const validKeys = keys.filter(key => key);
+  const randomIndex = Math.floor(Math.random() * validKeys.length);
+  return validKeys[randomIndex];
+}
+export const bittensorApiKey = () => {
+  return random(BITTENSOR_API_KEY_1, BITTENSOR_API_KEY_2);
+};
+
+/* Fetch data */
+
+export 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);
+  });
+}
+export 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: ''
+  }
+};
+export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHandler {
+  /* Unimplemented function  */
+  handleYieldWithdraw(address, unstakingInfo) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+  handleYieldCancelUnstake(params) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+  /* Unimplemented function  */
+
+  get maintainBalance() {
+    const ed = new BN(this.nativeToken.minAmount || '0');
+    const calculateMaintainBalance = new BN(15).mul(ed).div(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 BigN(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, 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 = BN_ZERO;
+    for (const delegate of delegatorState) {
+      const activeStake = delegate.amount;
+      const bnActiveStake = new BN(activeStake);
+      if (bnActiveStake.gt(BN_ZERO)) {
+        const delegationStatus = EarningStatus.EARNING_REWARD;
+        allActiveStake = allActiveStake.add(bnActiveStake);
+        nominationList.push({
+          status: delegationStatus,
+          chain: chainInfo.slug,
+          validatorAddress: delegate.owner,
+          activeStake: activeStake,
+          validatorMinStake: minDelegatorStake
+        });
+      }
+    }
+    const stakingStatus = 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 = BN_ZERO;
+      const stakePromises = useAddresses.map(async address => {
+        const stakeAmount = (await substrateApi.api.query.subtensorModule.stake(testnetAddress, address)).toString();
+        const bnStakeAmount = new 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: EarningStatus.EARNING_REWARD,
+          isBondedBefore: true,
+          nominations: delegatorState.map(delegate => ({
+            chain: this.chain,
+            validatorAddress: delegate.owner,
+            activeStake: delegate.amount,
+            status: 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 = reformatAddress(useAddresses[i], 42);
+          const delegatorState = [];
+          let bnTotalBalance = BN_ZERO;
+          const delegateStateInfo = rawDelegateStateInfo.data;
+          for (const delegate of delegateStateInfo) {
+            bnTotalBalance = bnTotalBalance.add(new 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: 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);
+    }, 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 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 BN(validatorList[i].stake);
+      const bnOwnStake = new 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 = 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, bondDest = 'Staked') {
+    const {
+      amount,
+      selectedValidators: targetValidators
+    } = data;
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new 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 BN(amount);
+    const poolPosition = await this.getPoolPosition(address);
+    if (!selectedTarget || !poolPosition) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const extrinsic = apiPromise.api.tx.subtensorModule.removeStake(selectedTarget, binaryAmount);
+    return [ExtrinsicType.STAKING_LEAVE_POOL, extrinsic];
+  }
+
+  /* Leave pool action */
+}

package/services/earning-service/service.js

@@ -12,7 +12,7 @@ import { BasicTxErrorType, YieldPoolType } from '@subwallet/extension-base/types
 import { addLazy, categoryAddresses, createPromiseHandler, removeLazy } from '@subwallet/extension-base/utils';
 import { fetchStaticCache } from '@subwallet/extension-base/utils/fetchStaticCache';
 import { BehaviorSubject } from 'rxjs';
-import { AcalaLiquidStakingPoolHandler, AmplitudeNativeStakingPoolHandler, AstarNativeStakingPoolHandler, BifrostLiquidStakingPoolHandler, BifrostMantaLiquidStakingPoolHandler, InterlayLendingPoolHandler, NominationPoolHandler, ParallelLiquidStakingPoolHandler, ParaNativeStakingPoolHandler, RelayNativeStakingPoolHandler, StellaSwapLiquidStakingPoolHandler } from "./handlers/index.js";
+import { AcalaLiquidStakingPoolHandler, AmplitudeNativeStakingPoolHandler, AstarNativeStakingPoolHandler, BifrostLiquidStakingPoolHandler, BifrostMantaLiquidStakingPoolHandler, InterlayLendingPoolHandler, NominationPoolHandler, ParallelLiquidStakingPoolHandler, ParaNativeStakingPoolHandler, RelayNativeStakingPoolHandler, StellaSwapLiquidStakingPoolHandler, TaoNativeStakingPoolHandler } from "./handlers/index.js";
 const fetchPoolsData = async () => {
   const fetchData = await fetchStaticCache('earning/yield-pools.json', {
     data: {}
@@ -65,6 +65,9 @@ export default class EarningService {
       if (_STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
         handlers.push(new AmplitudeNativeStakingPoolHandler(this.state, chain));
       }
+      if (_STAKING_CHAIN_GROUP.bittensor.includes(chain)) {
+        handlers.push(new TaoNativeStakingPoolHandler(this.state, chain));
+      }
       if (_STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
         handlers.push(new NominationPoolHandler(this.state, chain));
       }

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

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

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

@@ -114,14 +114,16 @@ export class AccountModifyHandler extends AccountBaseHandler {
   }) {
     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];
     }
@@ -130,7 +132,13 @@ export class AccountModifyHandler extends AccountBaseHandler {
       keyring.forgetAccount(address);
     }
     await Promise.all(addresses.map(address => new Promise(resolve => this.state.removeAccountRef(address, resolve))));
-    this.state.saveCurrentAccountProxyId(ALL_ACCOUNT_KEY);
+
+    // Cannot use `this.state.accounts` because it is not completely updated yet
+    if (afterDeleteAccounts.length > 1) {
+      this.state.saveCurrentAccountProxyId(ALL_ACCOUNT_KEY);
+    } else {
+      this.state.saveCurrentAccountProxyId(afterDeleteAccounts[0]);
+    }
     return addresses;
   }
   tonGetAllTonWalletContractVersion(request) {

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

@@ -437,12 +437,11 @@ export class AccountState {
     if (proxyId === 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/services/keyring-service/index.d.ts

@@ -9,7 +9,7 @@ export declare class KeyringService {
     get keyringState(): KeyringState;
     keyringStateSubscribe(callback: (state: KeyringState) => void): import("rxjs").Subscription;
     eventInjectReady(): void;
-    eventRemoveAccount(proxyId: string): void;
+    eventRemoveAccountProxy(proxyId: string): void;
     updateKeyringState(isReady?: boolean): void;
     lock(): void;
     resetWallet(resetAll: boolean): Promise<void>;

package/services/keyring-service/index.js

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

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

@@ -230,7 +230,6 @@ export class ChainflipSwapHandler {
         switch (fee.type) {
           case ChainflipFeeType.INGRESS:
             {
-              console.log('ingress', fee);
               feeComponent.push({
                 tokenSlug: fromAsset.slug,
                 amount: fee.amount,
@@ -242,7 +241,6 @@ export class ChainflipSwapHandler {
           // eslint-disable-next-line no-fallthrough
           case ChainflipFeeType.EGRESS:
             {
-              console.log('egress', fee);
               feeComponent.push({
                 tokenSlug: toAsset.slug,
                 amount: fee.amount,
@@ -258,7 +256,6 @@ export class ChainflipSwapHandler {
           // eslint-disable-next-line no-fallthrough
           case ChainflipFeeType.BROKER:
             {
-              console.log('broker fee', fee);
               feeComponent.push({
                 tokenSlug: this.intermediaryAssetSlug,
                 amount: fee.amount,
@@ -335,7 +332,8 @@ export class ChainflipSwapHandler {
     const {
       address,
       quote,
-      recipient
+      recipient,
+      slippage
     } = params;
     const pair = quote.pair;
     const fromAsset = this.chainService.getAssetBySlug(pair.from);
@@ -347,14 +345,24 @@ export class ChainflipSwapHandler {
     const destChainId = this.chainMapping[toAsset.originChain];
     const fromAssetId = _getAssetSymbol(fromAsset);
     const toAssetId = _getAssetSymbol(toAsset);
+    const minReceive = new BigNumber(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/services/transaction-service/utils.js

@@ -28,6 +28,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) {
@@ -49,6 +52,9 @@ export 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/types/swap/index.d.ts

@@ -157,3 +157,4 @@ export interface SlippageType {
     slippage: BigN;
     isCustomType: boolean;
 }
+export declare const CHAINFLIP_SLIPPAGE = 0.02;

package/types/swap/index.js

@@ -38,4 +38,5 @@ export let SwapFeeType;
   SwapFeeType["PLATFORM_FEE"] = "PLATFORM_FEE";
   SwapFeeType["NETWORK_FEE"] = "NETWORK_FEE";
   SwapFeeType["WALLET_FEE"] = "WALLET_FEE";
-})(SwapFeeType || (SwapFeeType = {}));
+})(SwapFeeType || (SwapFeeType = {}));
+export const CHAINFLIP_SLIPPAGE = 0.02; // Example: 0.01 for 1%

package/utils/account/derive/info/solo.js

@@ -185,6 +185,8 @@ export const findSoloNextDerive = parentAddress => {
     }
     if (deriveIndex === index) {
       index++;
+    } else if (currentDepth === 0 && deriveIndex === 0 && index > deriveIndex) {
+      // Special case for the first account on the root
     } else {
       break;
     }

package/utils/account/derive/info/unified.js

@@ -86,6 +86,8 @@ export const findUnifiedNextDerive = (proxyId, accounts) => {
     }
     if (deriveIndex === index) {
       index++;
+    } else if (currentDepth === 0 && deriveIndex === 0 && index > deriveIndex) {
+      // Special case for the first account on the root
     } else {
       break;
     }

package/utils/account/transform.js

@@ -395,10 +395,10 @@ export const _combineAccounts = (accounts, modifyPairs, accountProxies) => {
         accountActions.push(AccountActions.EXPORT_MNEMONIC);
       }
 
-      // // Json
-      // if (value.accounts.every((account) => account.accountActions.includes(AccountActions.EXPORT_JSON))) {
-      //   accountActions.push(AccountActions.EXPORT_JSON);
-      // }
+      // Json
+      if (value.accounts.every(account => account.accountActions.includes(AccountActions.EXPORT_JSON))) {
+        accountActions.push(AccountActions.EXPORT_JSON);
+      }
 
       // Derive
       if (value.accounts.every(account => account.accountActions.includes(AccountActions.DERIVE))) {