@subwallet/extension-base 1.1.35-0 → 1.1.35-beta.0

package/cjs/services/earning-service/handlers/liquid-staking/bifrost.js

@@ -0,0 +1,298 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _constants2 = require("@subwallet/extension-base/services/earning-service/constants");
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+var _util = require("@polkadot/util");
+var _base = _interopRequireDefault(require("./base"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const STATS_URL = 'https://api.bifrost.app/api/site';
+const BIFROST_GRAPHQL_ENDPOINT = 'https://bifrost-subsql.liebi.com/v1/graphql';
+const BIFROST_EXCHANGE_RATE_REQUEST = 'query MyQuery{slp_polkadot_ratio(limit:1 where:{key:{_eq:"0"}} order_by:{timestamp:desc_nulls_first}){ratio key timestamp total_issuance token_pool}}';
+class BifrostLiquidStakingPoolHandler extends _base.default {
+  altInputAsset = 'polkadot-NATIVE-DOT';
+  derivativeAssets = ['bifrost_dot-LOCAL-vDOT'];
+  inputAsset = 'bifrost_dot-LOCAL-DOT';
+  rewardAssets = ['bifrost_dot-LOCAL-DOT'];
+  feeAssets = ['bifrost_dot-NATIVE-BNC', 'bifrost_dot-LOCAL-DOT'];
+  minAmountPercent = 0.99;
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: true,
+    cancelUnstake: false,
+    withdraw: false,
+    claimReward: false
+  };
+  rateDecimals = 0;
+  constructor(state, chain) {
+    super(state, chain);
+    const chainInfo = this.chainInfo;
+    this.slug = `DOT___liquid_staking___${chain}`;
+    this.name = `${chainInfo.name} Liquid Staking`;
+    this.shortName = chainInfo.name.replaceAll(' Relay Chain', '');
+  }
+  getDescription() {
+    return 'Stake DOT to earn yield on vDOT';
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const substrateApi = await this.substrateApi.isReady;
+    const stakingMetaPromise = new Promise(function (resolve) {
+      (0, _crossFetch.default)(STATS_URL, {
+        method: 'GET'
+      }).then(res => {
+        resolve(res.json());
+      }).catch(console.error);
+    });
+    const exchangeRatePromise = new Promise(function (resolve) {
+      (0, _crossFetch.default)(BIFROST_GRAPHQL_ENDPOINT, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          query: BIFROST_EXCHANGE_RATE_REQUEST
+        })
+      }).then(resp => {
+        resolve(resp.json());
+      }).catch(console.error);
+    });
+    const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
+    const inputTokenInfo = this.state.getAssetBySlug(this.inputAsset);
+    const [_stakingMeta, _exchangeRate, _minimumRedeem, _minimumMint] = await Promise.all([stakingMetaPromise, exchangeRatePromise, substrateApi.api.query.vtokenMinting.minimumRedeem((0, _utils._getTokenOnChainInfo)(derivativeTokenInfo)), substrateApi.api.query.vtokenMinting.minimumMint((0, _utils._getTokenOnChainInfo)(inputTokenInfo))]);
+    const minimumRedeem = _minimumRedeem.toString();
+    const minimumMint = _minimumMint.toString();
+    const stakingMeta = _stakingMeta;
+    const exchangeRate = _exchangeRate;
+    const vDOTStats = stakingMeta.vDOT;
+    const assetInfo = this.state.getAssetBySlug(this.inputAsset);
+    const assetDecimals = 10 ** (0, _utils._getAssetDecimals)(assetInfo);
+    const rate = parseFloat(exchangeRate.data.slp_polkadot_ratio[0].ratio);
+    this.updateExchangeRate(rate);
+    return {
+      ...this.baseInfo,
+      type: this.type,
+      metadata: {
+        ...this.metadataInfo,
+        description: this.getDescription()
+      },
+      statistic: {
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apy: parseFloat(vDOTStats.apyBase),
+          exchangeRate: rate
+        }],
+        unstakingPeriod: 24 * 28,
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        earningThreshold: {
+          join: minimumMint,
+          defaultUnstake: minimumRedeem,
+          fastUnstake: '0'
+        },
+        totalApy: parseFloat(vDOTStats.apyBase),
+        tvl: (vDOTStats.tvm * assetDecimals).toString()
+      }
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    await substrateApi.isReady;
+
+    // @ts-ignore
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const unsub = await substrateApi.api.query.tokens.accounts.multi(useAddresses.map(address => [address, (0, _utils._getTokenOnChainInfo)(derivativeTokenInfo)]), async _balance => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const balances = _balance;
+      const [_unlockLedgerList, _currentRelayEra, rate] = await Promise.all([substrateApi.api.query.vtokenMinting.userUnlockLedger.multi(useAddresses.map(address => [address, (0, _utils._getTokenOnChainInfo)(inputTokenInfo)])), substrateApi.api.query.vtokenMinting.ongoingTimeUnit((0, _utils._getTokenOnChainInfo)(inputTokenInfo)), this.getExchangeRate()]);
+      const exchangeRate = new _bignumber.default(rate);
+      const currentRelayEraObj = _currentRelayEra.toPrimitive();
+      const currentRelayEra = currentRelayEraObj.Era;
+      const unlockLedgerList = [];
+      const activeBalanceMap = {};
+      for (let i = 0; i < balances.length; i++) {
+        const balanceItem = balances[i];
+        const address = useAddresses[i];
+        const formattedAddress = (0, _utils2.reformatAddress)(address);
+        activeBalanceMap[formattedAddress] = balanceItem.free || _util.BN_ZERO;
+        const _unlockLedger = _unlockLedgerList[i];
+        const unlockLedger = _unlockLedger.toPrimitive();
+        if (unlockLedger) {
+          // @ts-ignore
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          const unstakingLedgerIds = unlockLedger[1];
+          unstakingLedgerIds.forEach(ledgerId => {
+            unlockLedgerList.push({
+              address: formattedAddress,
+              ledgerId
+            });
+          });
+        }
+
+        // const bnTotalBalance = bnActiveBalance.add(bnUnstakingBalance);
+      }
+
+      const unlockingMap = {};
+
+      // TODO: review unstaking info vtokenMinting.userUnlockLedger
+      const _unlockInfoList = await substrateApi.api.query.vtokenMinting.tokenUnlockLedger.multi(unlockLedgerList.map(_ref => {
+        let {
+          ledgerId
+        } = _ref;
+        return [(0, _utils._getTokenOnChainInfo)(inputTokenInfo), ledgerId];
+      }));
+      for (let i = 0; i < _unlockInfoList.length; i++) {
+        const unlockInfo = _unlockInfoList[i].toPrimitive();
+        const owner = (0, _utils2.reformatAddress)(unlockInfo[0]);
+        const amount = unlockInfo[1].toString();
+        // @ts-ignore
+        const withdrawalEra = unlockInfo[2].era;
+        if (owner in unlockingMap) {
+          unlockingMap[owner].push({
+            balance: amount,
+            era: withdrawalEra
+          });
+        } else {
+          unlockingMap[owner] = [{
+            balance: amount,
+            era: withdrawalEra
+          }];
+        }
+      }
+      const unstakingList = [];
+      useAddresses.forEach(address => {
+        const formattedAddress = (0, _utils2.reformatAddress)(address);
+        const bnActiveBalance = activeBalanceMap[formattedAddress];
+        const unlockings = unlockingMap[formattedAddress];
+        let unlockBalance = _util.BN_ZERO;
+        if (unlockings) {
+          unlockings.forEach(unlocking => {
+            const isClaimable = unlocking.era - currentRelayEra < 0;
+            const remainingEra = unlocking.era - currentRelayEra;
+            const waitingTime = remainingEra * _constants._STAKING_ERA_LENGTH_MAP[this.chain];
+            unlockBalance = unlockBalance.add(new _util.BN(unlocking.balance));
+            unstakingList.push({
+              chain: this.chain,
+              status: isClaimable ? _types.UnstakingStatus.CLAIMABLE : _types.UnstakingStatus.UNLOCKING,
+              claimable: unlocking.balance,
+              waitingTime: waitingTime
+            });
+          });
+        }
+        const activeToTotalBalance = exchangeRate.multipliedBy(bnActiveBalance.toString());
+        const totalBalance = activeToTotalBalance.plus(unlockBalance.toString());
+        const result = {
+          ...this.baseInfo,
+          type: this.type,
+          address,
+          balanceToken: this.inputAsset,
+          derivativeToken: derivativeTokenSlug,
+          totalStake: totalBalance.toString(),
+          activeStake: bnActiveBalance.toString(),
+          unstakeBalance: unlockBalance.toString(),
+          status: bnActiveBalance.gt(_util.BN_ZERO) ? _types.EarningStatus.EARNING_REWARD : _types.EarningStatus.NOT_EARNING,
+          isBondedBefore: totalBalance.gt(_util.BN_ZERO.toString()),
+          nominations: [],
+          unstakings: unstakingList
+        };
+        resultCallback(result);
+      });
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint vDOT',
+      type: _types.YieldStepType.MINT_VDOT
+    };
+  }
+  async getSubmitStepFee(params) {
+    const poolOriginSubstrateApi = await this.substrateApi.isReady;
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const defaultFeeTokenSlug = this.feeAssets[0];
+    if (new _util.BN(params.amount).gt(_util.BN_ZERO)) {
+      const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.vtokenMinting.mint((0, _utils._getTokenOnChainInfo)(inputTokenInfo), params.amount, undefined, undefined).paymentInfo(_constants2.fakeAddress);
+      const mintFeeInfo = _mintFeeInfo.toPrimitive();
+      return {
+        amount: mintFeeInfo.partialFee.toString(),
+        slug: defaultFeeTokenSlug
+      };
+    } else {
+      return {
+        amount: '0',
+        slug: defaultFeeTokenSlug
+      };
+    }
+  }
+  async handleSubmitStep(data, path) {
+    const substrateApi = await this.substrateApi.isReady;
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const extrinsic = substrateApi.api.tx.vtokenMinting.mint((0, _utils._getTokenOnChainInfo)(inputTokenInfo), data.amount, undefined, undefined);
+    return {
+      txChain: this.chain,
+      extrinsicType: _KoniTypes.ExtrinsicType.MINT_VDOT,
+      extrinsic,
+      txData: data,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    const substrateApi = await this.substrateApi.isReady;
+    const weightedMinAmount = await this.createParamToRedeem(amount, address);
+    const extrinsic = substrateApi.api.tx.stablePool.swap(0, 1, 0, amount, weightedMinAmount);
+    return [_KoniTypes.ExtrinsicType.REDEEM_VDOT, extrinsic];
+  }
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const chainApi = await this.substrateApi.isReady;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const extrinsic = chainApi.api.tx.vtokenMinting.redeem((0, _utils._getTokenOnChainInfo)(derivativeTokenInfo), amount);
+    return [_KoniTypes.ExtrinsicType.UNSTAKE_VDOT, extrinsic];
+  }
+
+  /* Leave pool action */
+}
+exports.default = BifrostLiquidStakingPoolHandler;

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

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AcalaLiquidStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _acala.default;
+  }
+});
+Object.defineProperty(exports, "BifrostLiquidStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _bifrost.default;
+  }
+});
+Object.defineProperty(exports, "ParallelLiquidStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _parallel.default;
+  }
+});
+Object.defineProperty(exports, "StellaSwapLiquidStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _stellaSwap.default;
+  }
+});
+var _acala = _interopRequireDefault(require("./acala"));
+var _bifrost = _interopRequireDefault(require("./bifrost"));
+var _parallel = _interopRequireDefault(require("./parallel"));
+var _stellaSwap = _interopRequireDefault(require("./stella-swap"));

package/cjs/services/earning-service/handlers/liquid-staking/parallel.js

@@ -0,0 +1,227 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _constants2 = require("@subwallet/extension-base/services/earning-service/constants");
+var _types = require("@subwallet/extension-base/types");
+var _util = require("@polkadot/util");
+var _base = _interopRequireDefault(require("./base"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class ParallelLiquidStakingPoolHandler extends _base.default {
+  altInputAsset = 'polkadot-NATIVE-DOT';
+  derivativeAssets = ['parallel-LOCAL-sDOT'];
+  inputAsset = 'parallel-LOCAL-DOT';
+  rewardAssets = ['parallel-LOCAL-DOT'];
+  feeAssets = ['parallel-NATIVE-PARA'];
+  minAmountPercent = 0.97;
+  rateDecimals = 18;
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: true,
+    cancelUnstake: false,
+    withdraw: false,
+    claimReward: false
+  };
+  constructor(state, chain) {
+    super(state, chain);
+    const chainInfo = this.chainInfo;
+    this.slug = `DOT___liquid_staking___${chain}`;
+    this.name = `${chainInfo.name} Liquid Staking`;
+    this.shortName = chainInfo.name.replaceAll(' Relay Chain', '');
+  }
+  getDescription() {
+    return 'Stake DOT to earn yield on sDOT';
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const substrateApi = await this.substrateApi.isReady;
+    const [_exchangeRate, _currentBlockHeader, _currentTimestamp, _stakingLedgers] = await Promise.all([substrateApi.api.query.liquidStaking.exchangeRate(), substrateApi.api.rpc.chain.getHeader(), substrateApi.api.query.timestamp.now(), substrateApi.api.query.liquidStaking.stakingLedgers.entries()]);
+    let tvl = _util.BN_ZERO;
+    for (const _stakingLedger of _stakingLedgers) {
+      const _ledger = _stakingLedger[1];
+      const ledger = _ledger.toPrimitive();
+      tvl = tvl.add(new _util.BN(ledger.total.toString()));
+    }
+    const exchangeRate = _exchangeRate.toPrimitive();
+    const currentBlockHeader = _currentBlockHeader.toPrimitive();
+    const currentTimestamp = _currentTimestamp.toPrimitive();
+    const beginBlock = currentBlockHeader.number - 24 * 60 * 60 / 6 * 14;
+    const _beginBlockHash = await substrateApi.api.rpc.chain.getBlockHash(beginBlock);
+    const beginBlockHash = _beginBlockHash.toString();
+    const [_beginTimestamp, _beginExchangeRate] = await Promise.all([substrateApi.api.query.timestamp.now.at(beginBlockHash), substrateApi.api.query.liquidStaking.exchangeRate.at(beginBlockHash)]);
+    const beginTimestamp = _beginTimestamp.toPrimitive();
+    const beginExchangeRate = _beginExchangeRate.toPrimitive();
+    const decimals = 10 ** this.rateDecimals;
+    const apy = (exchangeRate / beginExchangeRate) ** (365 * 24 * 60 * 60000 / (currentTimestamp - beginTimestamp)) - 1;
+    const minStake = substrateApi.api.consts.liquidStaking.minStake.toString();
+    const minUnstake = substrateApi.api.consts.liquidStaking.minUnstake.toString();
+    this.updateExchangeRate(exchangeRate);
+    return {
+      ...this.baseInfo,
+      type: this.type,
+      metadata: {
+        ...this.metadataInfo,
+        description: this.getDescription()
+      },
+      statistic: {
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apy: apy * 100,
+          exchangeRate: exchangeRate / decimals
+        }],
+        unstakingPeriod: 24 * 28,
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        earningThreshold: {
+          join: minStake,
+          defaultUnstake: minUnstake,
+          fastUnstake: '0'
+        },
+        totalApy: apy * 100,
+        tvl: tvl.toString()
+      }
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    await substrateApi.isReady;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const unsub = await substrateApi.api.query.assets.account.multi(useAddresses.map(address => [(0, _utils._getTokenOnChainAssetId)(derivativeTokenInfo), address]), async balances => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const [unlockingChunks, _currentEra, exchangeRate] = await Promise.all([substrateApi.api.query.liquidStaking.unlockings.multi(useAddresses), substrateApi.api.query.liquidStaking.currentEra(), this.getExchangeRate()]);
+      const currentEra = _currentEra.toPrimitive();
+      const decimals = _util.BN_TEN.pow(new _util.BN(this.rateDecimals));
+      for (let i = 0; i < balances.length; i++) {
+        const b = balances[i];
+        const address = useAddresses[i];
+        // @ts-ignore
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment
+        const bdata = b === null || b === void 0 ? void 0 : b.toHuman();
+        const chunks = unlockingChunks[i].toPrimitive();
+
+        // @ts-ignore
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument
+        const activeBalance = bdata && bdata.balance ? new _util.BN(String(bdata === null || bdata === void 0 ? void 0 : bdata.balance).replaceAll(',', '') || '0') : _util.BN_ZERO;
+        let totalBalance = activeBalance.mul(new _util.BN(exchangeRate)).div(decimals);
+        let unlockingBalance = _util.BN_ZERO;
+        const unstakings = [];
+        if (chunks) {
+          for (const chunk of chunks) {
+            const amount = new _util.BN(chunk.value);
+            const isClaimable = chunk.era - currentEra < 0;
+            const remainingEra = chunk.era - currentEra;
+            const eraTime = _constants._STAKING_ERA_LENGTH_MAP[this.chain] || _constants._STAKING_ERA_LENGTH_MAP.default;
+            const waitingTime = remainingEra * eraTime;
+            totalBalance = totalBalance.add(amount);
+            unlockingBalance = unlockingBalance.add(amount);
+            unstakings.push({
+              chain: this.chain,
+              status: isClaimable ? _types.UnstakingStatus.CLAIMABLE : _types.UnstakingStatus.UNLOCKING,
+              claimable: amount.toString(),
+              waitingTime: waitingTime
+            });
+          }
+        }
+        const result = {
+          ...this.baseInfo,
+          type: this.type,
+          address,
+          balanceToken: this.inputAsset,
+          totalStake: totalBalance.toString(),
+          activeStake: activeBalance.toString(),
+          unstakeBalance: unlockingBalance.toString(),
+          status: activeBalance.gt(_util.BN_ZERO) ? _types.EarningStatus.EARNING_REWARD : _types.EarningStatus.NOT_EARNING,
+          derivativeToken: derivativeTokenSlug,
+          isBondedBefore: totalBalance.gt(_util.BN_ZERO),
+          nominations: [],
+          unstakings: unstakings
+        };
+        resultCallback(result);
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint sDOT',
+      type: _types.YieldStepType.MINT_SDOT
+    };
+  }
+  async getSubmitStepFee(params) {
+    const poolOriginSubstrateApi = await this.substrateApi.isReady;
+    const defaultFeeTokenSlug = this.feeAssets[0];
+    if (new _util.BN(params.amount).gt(_util.BN_ZERO)) {
+      const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.liquidStaking.stake(params.amount).paymentInfo(_constants2.fakeAddress);
+      const mintFeeInfo = _mintFeeInfo.toPrimitive();
+      return {
+        amount: mintFeeInfo.partialFee.toString(),
+        slug: defaultFeeTokenSlug
+      };
+    } else {
+      return {
+        amount: '0',
+        slug: defaultFeeTokenSlug
+      };
+    }
+  }
+  async handleSubmitStep(data, path) {
+    const substrateApi = await this.substrateApi.isReady;
+    const extrinsic = substrateApi.api.tx.liquidStaking.stake(data.amount);
+    return {
+      txChain: this.chain,
+      extrinsicType: _KoniTypes.ExtrinsicType.MINT_SDOT,
+      extrinsic,
+      txData: data,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    const substrateApi = await this.substrateApi.isReady;
+    const weightedMinAmount = await this.createParamToRedeem(amount, address);
+    const extrinsic = substrateApi.api.tx.ammRoute.swapExactTokensForTokens(['1001', '101'], amount, weightedMinAmount);
+    return [_KoniTypes.ExtrinsicType.REDEEM_SDOT, extrinsic];
+  }
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const chainApi = await this.substrateApi.isReady;
+    const extrinsic = chainApi.api.tx.liquidStaking.unstake(amount, 'RelayChain');
+    return [_KoniTypes.ExtrinsicType.UNSTAKE_SDOT, extrinsic];
+  }
+
+  /* Leave pool action */
+}
+exports.default = ParallelLiquidStakingPoolHandler;