@subwallet/extension-base 1.1.28-0 → 1.1.28-beta.1

package/services/earning-service/handlers/liquid-staking/acala.js

@@ -0,0 +1,188 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getTokenOnChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { fakeAddress } from '@subwallet/extension-base/services/earning-service/constants';
+import { EarningStatus, YieldStepType } from '@subwallet/extension-base/types';
+import fetch from 'cross-fetch';
+import { BN, BN_ZERO } from '@polkadot/util';
+import BaseLiquidStakingPoolHandler from "./base.js";
+const GRAPHQL_API = 'https://api.polkawallet.io/acala-liquid-staking-subql';
+const EXCHANGE_RATE_REQUEST = 'query { dailySummaries(first:30, orderBy:TIMESTAMP_DESC) {nodes { exchangeRate timestamp }}}';
+export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
+  altInputAsset = 'polkadot-NATIVE-DOT';
+  derivativeAssets = ['acala-LOCAL-LDOT'];
+  inputAsset = 'acala-LOCAL-DOT';
+  rewardAssets = ['acala-LOCAL-DOT'];
+  feeAssets = ['acala-NATIVE-ACA', 'acala-LOCAL-DOT'];
+  /** @inner */
+  minAmountPercent = 0.98;
+  /** @inner */
+  allowDefaultUnstake = true;
+  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', '');
+    this.description = 'Stake DOT to earn yield on LDOT';
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const substrateApi = await this.substrateApi.isReady;
+    const stakingMetaPromise = new Promise(function (resolve) {
+      fetch(GRAPHQL_API, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          query: EXCHANGE_RATE_REQUEST
+        })
+      }).then(res => {
+        resolve(res.json());
+      }).catch(console.error);
+    });
+    const [_toBondPool, _totalStakingBonded, _stakingMeta] = await Promise.all([substrateApi.api.query.homa.toBondPool(), substrateApi.api.query.homa.totalStakingBonded(), stakingMetaPromise]);
+    const stakingMeta = _stakingMeta;
+    const stakingMetaList = stakingMeta.data.dailySummaries.nodes;
+    const latestExchangeRate = parseInt(stakingMetaList[0].exchangeRate);
+    const decimals = 10 ** 10;
+    const endingBalance = parseInt(stakingMetaList[0].exchangeRate);
+    const beginBalance = parseInt(stakingMetaList[29].exchangeRate);
+    const diff = endingBalance / beginBalance;
+    const apy = diff ** (365 / 30) - 1;
+    const toBondPool = new BN(_toBondPool.toString());
+    const totalStakingBonded = new BN(_totalStakingBonded.toString());
+    return {
+      ...this.defaultInfo,
+      description: this.description,
+      type: this.type,
+      metadata: {
+        ...this.baseMetadata,
+        isAvailable: true,
+        allowCancelUnstaking: false,
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apy: apy * 100,
+          exchangeRate: latestExchangeRate / decimals
+        }],
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        minJoinPool: '50000000000',
+        minWithdrawal: '50000000000',
+        totalApy: apy * 100,
+        tvl: totalStakingBonded.add(toBondPool).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.tokens.accounts.multi(useAddresses.map(address => [address, _getTokenOnChainInfo(derivativeTokenInfo)]), _balances => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const balances = _balances;
+      for (let i = 0; i < balances.length; i++) {
+        const balanceItem = balances[i];
+        const address = useAddresses[i];
+        const bnTotalBalance = balanceItem.free || BN_ZERO;
+        const totalBalance = bnTotalBalance.toString();
+        const result = {
+          ...this.defaultInfo,
+          type: this.type,
+          address,
+          balanceToken: this.inputAsset,
+          totalStake: totalBalance,
+          activeStake: totalBalance,
+          unstakeBalance: '0',
+          status: EarningStatus.EARNING_REWARD,
+          derivativeToken: derivativeTokenSlug,
+          isBondedBefore: bnTotalBalance.gt(BN_ZERO),
+          nominations: [],
+          unstakings: []
+        };
+        resultCallback(result);
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint LDOT',
+      type: YieldStepType.MINT_LDOT
+    };
+  }
+  async getSubmitStepFee(params) {
+    const poolOriginSubstrateApi = await this.substrateApi.isReady;
+    const defaultFeeTokenSlug = this.feeAssets[0];
+    const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.homa.mint(params.amount).paymentInfo(fakeAddress);
+    const mintFeeInfo = _mintFeeInfo.toPrimitive();
+    return {
+      amount: mintFeeInfo.partialFee.toString(),
+      slug: defaultFeeTokenSlug
+    };
+  }
+  async handleSubmitStep(data, path) {
+    const substrateApi = await this.substrateApi.isReady;
+    const extrinsic = substrateApi.api.tx.homa.mint(data.amount);
+    return {
+      txChain: this.chain,
+      extrinsicType: ExtrinsicType.MINT_LDOT,
+      extrinsic,
+      txData: data,
+      transferNativeAmount: '0'
+    };
+  }
+
+  /* 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.aggregatedDex.swapWithExactSupply(
+    // Swap path
+    [{
+      Taiga: [0, /* pool id */
+      1, /* supply asset */
+      0 /* target asset */]
+    }],
+    // Supply amount
+    amount,
+    // Min target amount
+    weightedMinAmount // should always set a min target to prevent unexpected result
+    );
+
+    return [ExtrinsicType.REDEEM_QDOT, extrinsic];
+  }
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const chainApi = await this.substrateApi.isReady;
+    const extrinsic = chainApi.api.tx.homa.requestRedeem(amount, false);
+    return [ExtrinsicType.UNSTAKE_QDOT, extrinsic];
+  }
+
+  /* Leave pool action */
+}

package/services/earning-service/handlers/liquid-staking/base.d.ts

@@ -0,0 +1,8 @@
+import { YieldPoolType } from '@subwallet/extension-base/types';
+import BaseSpecialStakingPoolHandler from '../special';
+export default abstract class BaseLiquidStakingPoolHandler extends BaseSpecialStakingPoolHandler {
+    readonly type = YieldPoolType.LIQUID_STAKING;
+    /** Rate convert token when redeem */
+    protected readonly minAmountPercent: number;
+    createParamToRedeem(amount: string, address: string): Promise<number>;
+}

package/services/earning-service/handlers/liquid-staking/base.js

@@ -0,0 +1,31 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { convertDerivativeToOriginToken } from '@subwallet/extension-base/koni/api/yield/helper/utils';
+import { YieldPoolType } from '@subwallet/extension-base/types';
+import BaseSpecialStakingPoolHandler from "../special.js";
+export default class BaseLiquidStakingPoolHandler extends BaseSpecialStakingPoolHandler {
+  type = YieldPoolType.LIQUID_STAKING;
+  /** Rate convert token when redeem */
+  minAmountPercent = 0.98;
+
+  /* Leave pool action */
+
+  async createParamToRedeem(amount, address) {
+    const yieldPositionInfo = await this.getPoolPosition(address);
+    const poolInfo = await this.getPoolInfo();
+    const originTokenSlug = this.inputAsset;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const originTokenInfo = this.state.getAssetBySlug(originTokenSlug);
+    if (!yieldPositionInfo || !poolInfo) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const formattedMinAmount = convertDerivativeToOriginToken(amount, poolInfo, derivativeTokenInfo, originTokenInfo);
+    return Math.floor(this.minAmountPercent * formattedMinAmount);
+  }
+
+  /* Leave pool action */
+}

package/services/earning-service/handlers/liquid-staking/bifrost.d.ts

@@ -0,0 +1,44 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { BaseYieldStepDetail, HandleYieldStepData, LiquidYieldPoolInfo, OptimalYieldPath, OptimalYieldPathParams, SubmitYieldJoinData, TransactionData, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import BaseLiquidStakingPoolHandler from './base';
+export interface BifrostLiquidStakingMeta {
+    apy: string;
+    apyBase: string;
+    apyReward: string;
+    tvl: number;
+    tvm: number;
+    holders: number;
+}
+export interface BifrostVtokenExchangeRateResp {
+    data: {
+        slp_polkadot_ratio: BifrostVtokenExchangeRate[];
+    };
+}
+export interface BifrostVtokenExchangeRate {
+    ratio: string;
+    key: string;
+    timestamp: string;
+    total_issuance: number;
+    token_pool: number;
+}
+export default class BifrostLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
+    protected readonly description: string;
+    protected readonly name: string;
+    protected readonly shortName: string;
+    protected readonly altInputAsset: string;
+    protected readonly derivativeAssets: string[];
+    protected readonly inputAsset: string;
+    protected readonly rewardAssets: string[];
+    protected readonly feeAssets: string[];
+    /** @inner */
+    protected readonly minAmountPercent = 0.99;
+    slug: string;
+    constructor(state: KoniState, chain: string);
+    getPoolStat(): Promise<LiquidYieldPoolInfo>;
+    subscribePoolPosition(useAddresses: string[], resultCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    get submitJoinStepInfo(): BaseYieldStepDetail;
+    getSubmitStepFee(params: OptimalYieldPathParams): Promise<YieldTokenBaseInfo>;
+    handleSubmitStep(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<HandleYieldStepData>;
+    handleYieldRedeem(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+}

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

@@ -0,0 +1,246 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getAssetDecimals, _getTokenOnChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { fakeAddress } from '@subwallet/extension-base/services/earning-service/constants';
+import { EarningStatus, UnstakingStatus, YieldStepType } from '@subwallet/extension-base/types';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+import fetch from 'cross-fetch';
+import { BN, BN_ZERO } from '@polkadot/util';
+import BaseLiquidStakingPoolHandler from "./base.js";
+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}}';
+export default class BifrostLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
+  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'];
+  /** @inner */
+  minAmountPercent = 0.99;
+  constructor(state, chain) {
+    super(state, chain);
+    const chainInfo = this.chainInfo;
+    this.slug = `DOT___liquid_staking___${chain}`;
+    this.name = `${chainInfo.name} Liquid Staking`;
+    this.description = 'Stake DOT to earn yield on vDOT';
+    this.shortName = chainInfo.name.replaceAll(' Relay Chain', '');
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const stakingMetaPromise = new Promise(function (resolve) {
+      fetch(STATS_URL, {
+        method: 'GET'
+      }).then(res => {
+        resolve(res.json());
+      }).catch(console.error);
+    });
+    const exchangeRatePromise = new Promise(function (resolve) {
+      fetch(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 [_stakingMeta, _exchangeRate] = await Promise.all([stakingMetaPromise, exchangeRatePromise]);
+    const stakingMeta = _stakingMeta;
+    const exchangeRate = _exchangeRate;
+    const vDOTStats = stakingMeta.vDOT;
+    const assetInfo = this.state.getAssetBySlug(this.inputAsset);
+    const assetDecimals = 10 ** _getAssetDecimals(assetInfo);
+    return {
+      ...this.defaultInfo,
+      description: this.description,
+      type: this.type,
+      metadata: {
+        ...this.baseMetadata,
+        isAvailable: true,
+        allowCancelUnstaking: false,
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apy: parseFloat(vDOTStats.apyBase),
+          exchangeRate: parseFloat(exchangeRate.data.slp_polkadot_ratio[0].ratio)
+        }],
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        minJoinPool: '5000000000',
+        minWithdrawal: '4000000000',
+        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, _getTokenOnChainInfo(derivativeTokenInfo)]), async _balance => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const balances = _balance;
+      const [_unlockLedgerList, _currentRelayEra] = await Promise.all([substrateApi.api.query.vtokenMinting.userUnlockLedger.multi(useAddresses.map(address => [address, _getTokenOnChainInfo(inputTokenInfo)])), substrateApi.api.query.vtokenMinting.ongoingTimeUnit(_getTokenOnChainInfo(inputTokenInfo))]);
+      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 = reformatAddress(address);
+        activeBalanceMap[formattedAddress] = balanceItem.free || 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 = {};
+      const _unlockInfoList = await substrateApi.api.query.vtokenMinting.tokenUnlockLedger.multi(unlockLedgerList.map(({
+        ledgerId
+      }) => [_getTokenOnChainInfo(inputTokenInfo), ledgerId]));
+      for (let i = 0; i < _unlockInfoList.length; i++) {
+        const unlockInfo = _unlockInfoList[i].toPrimitive();
+        const owner = 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 = reformatAddress(address);
+        const bnActiveBalance = activeBalanceMap[formattedAddress];
+        const unlockings = unlockingMap[formattedAddress];
+        let unlockBalance = BN_ZERO;
+        if (unlockings) {
+          unlockings.forEach(unlocking => {
+            const isClaimable = unlocking.era - currentRelayEra < 0;
+            const remainingEra = unlocking.era - currentRelayEra;
+            const waitingTime = remainingEra * _STAKING_ERA_LENGTH_MAP[this.chain];
+            unlockBalance = unlockBalance.add(new BN(unlocking.balance));
+            unstakingList.push({
+              chain: this.chain,
+              status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+              claimable: unlocking.balance,
+              waitingTime: waitingTime
+            });
+          });
+        }
+        const totalBalance = bnActiveBalance.add(unlockBalance);
+        const result = {
+          ...this.defaultInfo,
+          type: this.type,
+          address,
+          balanceToken: this.inputAsset,
+          derivativeToken: derivativeTokenSlug,
+          totalStake: totalBalance.toString(),
+          activeStake: bnActiveBalance.toString(),
+          unstakeBalance: unlockBalance.toString(),
+          status: bnActiveBalance.eq(BN_ZERO) ? EarningStatus.NOT_EARNING : EarningStatus.EARNING_REWARD,
+          isBondedBefore: totalBalance.gt(BN_ZERO),
+          nominations: [],
+          unstakings: unstakingList
+        };
+        resultCallback(result);
+      });
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint vDOT',
+      type: 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];
+    const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.vtokenMinting.mint(_getTokenOnChainInfo(inputTokenInfo), params.amount, null).paymentInfo(fakeAddress);
+    const mintFeeInfo = _mintFeeInfo.toPrimitive();
+    return {
+      amount: mintFeeInfo.partialFee.toString(),
+      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(_getTokenOnChainInfo(inputTokenInfo), data.amount, undefined);
+    return {
+      txChain: this.chain,
+      extrinsicType: ExtrinsicType.MINT_VDOT,
+      extrinsic,
+      txData: data,
+      transferNativeAmount: '0'
+    };
+  }
+
+  /* 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 [ExtrinsicType.REDEEM_VDOT, extrinsic];
+  }
+
+  /* Leave pool action */
+}

package/services/earning-service/handlers/liquid-staking/index.d.ts

@@ -0,0 +1,4 @@
+export { default as AcalaLiquidStakingPoolHandler } from './acala';
+export { default as BifrostLiquidStakingPoolHandler } from './bifrost';
+export { default as ParallelLiquidStakingPoolHandler } from './parallel';
+export { default as StellaSwapLiquidStakingPoolHandler } from './stella-swap';

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

@@ -0,0 +1,7 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export { default as AcalaLiquidStakingPoolHandler } from "./acala.js";
+export { default as BifrostLiquidStakingPoolHandler } from "./bifrost.js";
+export { default as ParallelLiquidStakingPoolHandler } from "./parallel.js";
+export { default as StellaSwapLiquidStakingPoolHandler } from "./stella-swap.js";

package/services/earning-service/handlers/liquid-staking/parallel.d.ts

@@ -0,0 +1,27 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { BaseYieldStepDetail, HandleYieldStepData, LiquidYieldPoolInfo, OptimalYieldPath, OptimalYieldPathParams, SubmitYieldJoinData, TransactionData, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import BaseLiquidStakingPoolHandler from './base';
+export default class ParallelLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
+    protected readonly description: string;
+    protected readonly name: string;
+    protected readonly shortName: string;
+    protected readonly altInputAsset: string;
+    protected readonly derivativeAssets: string[];
+    protected readonly inputAsset: string;
+    protected readonly rewardAssets: string[];
+    protected readonly feeAssets: string[];
+    /** @inner */
+    protected readonly minAmountPercent = 0.97;
+    /** @inner */
+    protected readonly allowDefaultUnstake = true;
+    slug: string;
+    constructor(state: KoniState, chain: string);
+    getPoolStat(): Promise<LiquidYieldPoolInfo>;
+    subscribePoolPosition(useAddresses: string[], resultCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    get submitJoinStepInfo(): BaseYieldStepDetail;
+    getSubmitStepFee(params: OptimalYieldPathParams): Promise<YieldTokenBaseInfo>;
+    handleSubmitStep(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<HandleYieldStepData>;
+    handleYieldRedeem(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+}