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

package/services/earning-service/constants/chains.d.ts

@@ -0,0 +1,15 @@
+export declare const _STAKING_CHAIN_GROUP: {
+    relay: string[];
+    para: string[];
+    astar: string[];
+    amplitude: string[];
+    kilt: string[];
+    nominationPool: string[];
+    bifrost: string[];
+    aleph: string[];
+    ternoa: string[];
+    liquidStaking: string[];
+    lending: string[];
+    krest_network: string[];
+};
+export declare const ST_LIQUID_TOKEN_ABI: Record<string, any>;

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

@@ -0,0 +1,22 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export const _STAKING_CHAIN_GROUP = {
+  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'ternoa_alphanet', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin', 'vara_network', 'goldberg_testnet'],
+  para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari', 'manta_network'],
+  astar: ['astar', 'shiden', 'shibuya'],
+  amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum', 'krest_network'],
+  // amplitude and kilt only share some common logic
+  kilt: ['kilt', 'kilt_peregrine'],
+  nominationPool: ['polkadot', 'kusama', 'westend', 'alephTest', 'aleph', 'kate', 'vara_network', 'goldberg_testnet'],
+  bifrost: ['bifrost', 'bifrost_testnet'],
+  aleph: ['aleph', 'alephTest'],
+  // A0 has distinct tokenomics
+  ternoa: ['ternoa', 'ternoa_alphanet'],
+  liquidStaking: ['bifrost_dot', 'acala', 'parallel', 'moonbeam'],
+  lending: ['interlay'],
+  krest_network: ['krest_network']
+};
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
+export const ST_LIQUID_TOKEN_ABI = require("./abis/st_liquid_token_abi.json");

package/services/earning-service/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './chains';
+export * from './step';

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

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./chains.js";
+export * from "./step.js";

package/services/earning-service/constants/step.d.ts

@@ -0,0 +1,3 @@
+import { YieldStepDetail } from '@subwallet/extension-base/types';
+export declare const DEFAULT_YIELD_FIRST_STEP: YieldStepDetail;
+export declare const fakeAddress = "15MLn9YQaHZ4GMkhK3qXqR5iGGSdULyJ995ctjeBgFRseyi6";

package/services/earning-service/constants/step.js

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { YieldStepType } from '@subwallet/extension-base/types';
+export const DEFAULT_YIELD_FIRST_STEP = {
+  id: 0,
+  name: 'Fill information',
+  type: YieldStepType.DEFAULT
+};
+export const fakeAddress = '15MLn9YQaHZ4GMkhK3qXqR5iGGSdULyJ995ctjeBgFRseyi6';

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

@@ -0,0 +1,113 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { BasePoolInfo, BaseYieldPoolMetadata, EarningRewardHistoryItem, EarningRewardItem, HandleYieldStepData, OptimalYieldPath, OptimalYieldPathParams, RequestEarlyValidateYield, ResponseEarlyValidateYield, StakeCancelWithdrawalParams, SubmitYieldJoinData, TransactionData, UnstakingInfo, YieldPoolInfo, YieldPoolMethodInfo, YieldPoolTarget, YieldPoolType, YieldPositionInfo, YieldStepBaseInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+/**
+ * @class BasePoolHandler
+ * @description Base pool handler
+ * */
+export default abstract class BasePoolHandler {
+    /** Koni state */
+    protected readonly state: KoniState;
+    /** Pool's chain */
+    readonly chain: string;
+    /** Pool's logo */
+    protected _logo: string;
+    /** Pool's slug */
+    abstract slug: string;
+    /** Pool's type */
+    abstract type: YieldPoolType;
+    /** Pool's name */
+    protected abstract name: string;
+    /** Pool's short name */
+    protected abstract shortName: string;
+    /** Pool's transaction type */
+    readonly transactionChainType: ChainType;
+    /** Pool's available method */
+    protected abstract readonly availableMethod: YieldPoolMethodInfo;
+    /**
+     * @constructor
+     * @param {KoniState} state - Koni state
+     * @param {string} chain - Pool's chain
+     * */
+    protected constructor(state: KoniState, chain: string);
+    get logo(): string;
+    get group(): string;
+    get isActive(): boolean;
+    protected get substrateApi(): _SubstrateApi;
+    protected get evmApi(): _EvmApi;
+    get chainInfo(): _ChainInfo;
+    protected get nativeToken(): _ChainAsset;
+    protected get baseInfo(): Omit<BasePoolInfo, 'type'>;
+    protected getAssetBySlug(slug: string): _ChainAsset;
+    protected abstract getDescription(amount?: string): string;
+    protected get maintainBalance(): string;
+    get metadataInfo(): Omit<BaseYieldPoolMetadata, 'description'>;
+    /** Can mint when haven't enough native token (use input token for fee) */
+    get isPoolSupportAlternativeFee(): boolean;
+    getPoolInfo(): Promise<YieldPoolInfo | undefined>;
+    getPoolPosition(address: string): Promise<YieldPositionInfo | undefined>;
+    /** Subscribe pool info */
+    abstract subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
+    /** Subscribe pool position */
+    abstract subscribePoolPosition(useAddresses: string[], callback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    /** Get pool reward */
+    abstract getPoolReward(useAddresses: string[], callback: (rs: EarningRewardItem) => void): Promise<VoidFunction>;
+    /** Get pool reward history */
+    abstract getPoolRewardHistory(useAddresses: string[], callback: (rs: EarningRewardHistoryItem) => void): Promise<VoidFunction>;
+    /** Get pool target */
+    abstract getPoolTargets(): Promise<YieldPoolTarget[]>;
+    earlyValidate(request: RequestEarlyValidateYield): Promise<ResponseEarlyValidateYield>;
+    /**
+     * @function firstStepFee
+     * */
+    protected get firstStepFee(): YieldTokenBaseInfo;
+    /**
+     * @function defaultSubmitStep
+     * @description Default submit step data
+     * */
+    protected abstract get defaultSubmitStep(): YieldStepBaseInfo;
+    /**
+     * @async
+     * @function getTokenApproveStep
+     * @param {OptimalYieldPathParams} params - base param to join pool
+     * @description Generate token approve step data
+     * */
+    protected getTokenApproveStep(params: OptimalYieldPathParams): Promise<YieldStepBaseInfo | undefined>;
+    /**
+     * @async
+     * @function getXcmStep
+     * @param {OptimalYieldPathParams} params - base param to join pool
+     * @description Generate token approve step data
+     * */
+    protected getXcmStep(params: OptimalYieldPathParams): Promise<YieldStepBaseInfo | undefined>;
+    /**
+     * @async
+     * @function getSubmitStep
+     * @param {OptimalYieldPathParams} params - base param to join pool
+     * @description Generate token approve step data
+     * */
+    protected abstract getSubmitStep(params: OptimalYieldPathParams): Promise<YieldStepBaseInfo>;
+    /** Generate the optimal steps to join pool */
+    generateOptimalPath(params: OptimalYieldPathParams): Promise<OptimalYieldPath>;
+    /** Validate param to join the pool */
+    abstract validateYieldJoin(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<TransactionError[]>;
+    /** Create `transaction` to join the pool step-by-step */
+    abstract handleYieldJoin(data: SubmitYieldJoinData, path: OptimalYieldPath, currentStep: number): Promise<HandleYieldStepData>;
+    /** Validate param to leave the pool */
+    abstract validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string): Promise<TransactionError[]>;
+    /** Create `transaction` to leave the pool normal (default unstake) */
+    protected abstract handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    /** Create `transaction` to leave the pool fast (swap token) */
+    protected abstract handleYieldRedeem(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    /** Create `transaction` to leave the pool */
+    handleYieldLeave(fastLeave: boolean, amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    /** Create `transaction` to withdraw unstaked amount */
+    abstract handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
+    /** Create `transaction` to cancel unstake */
+    abstract handleYieldCancelUnstake(params: StakeCancelWithdrawalParams): Promise<TransactionData>;
+    /** Create `transaction` to claim reward */
+    abstract handleYieldClaimReward(address: string, bondReward?: boolean): Promise<TransactionData>;
+}

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

@@ -0,0 +1,256 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { DEFAULT_YIELD_FIRST_STEP } from '@subwallet/extension-base/services/earning-service/constants';
+import { formatNumber } from '@subwallet/extension-base/utils';
+import { BN, BN_TEN } from '@polkadot/util';
+
+/**
+ * @class BasePoolHandler
+ * @description Base pool handler
+ * */
+export default class BasePoolHandler {
+  /** Koni state */
+
+  /** Pool's chain */
+
+  /** Pool's logo */
+
+  /** Pool's slug */
+
+  /** Pool's type */
+
+  /** Pool's name */
+
+  /** Pool's short name */
+
+  /** Pool's transaction type */
+  transactionChainType = ChainType.SUBSTRATE;
+
+  /** Pool's available method */
+
+  /**
+   * @constructor
+   * @param {KoniState} state - Koni state
+   * @param {string} chain - Pool's chain
+   * */
+  constructor(state, chain) {
+    this.state = state;
+    this.chain = chain;
+    this._logo = chain;
+  }
+  get logo() {
+    return this._logo;
+  }
+  get group() {
+    const groupSlug = this.nativeToken.multiChainAsset;
+    return groupSlug || this.nativeToken.slug;
+  }
+  get isActive() {
+    return this.state.activeChainSlugs.includes(this.chain);
+  }
+  get substrateApi() {
+    return this.state.getSubstrateApi(this.chain);
+  }
+  get evmApi() {
+    return this.state.getEvmApi(this.chain);
+  }
+  get chainInfo() {
+    return this.state.getChainInfo(this.chain);
+  }
+  get nativeToken() {
+    return this.state.getNativeTokenInfo(this.chain);
+  }
+  get baseInfo() {
+    return {
+      group: this.group,
+      chain: this.chain,
+      slug: this.slug
+    };
+  }
+  getAssetBySlug(slug) {
+    return this.state.getAssetBySlug(slug);
+  }
+  get maintainBalance() {
+    const decimals = this.nativeToken.decimals || 0;
+    const defaultMaintainBalance = new BN(1).mul(BN_TEN.pow(new BN(decimals)));
+    const ed = new BN(this.nativeToken.minAmount || '0');
+    const maintainBalance = ed.gte(defaultMaintainBalance) ? new BN(15).mul(ed).div(BN_TEN) : defaultMaintainBalance;
+    return maintainBalance.toString();
+  }
+  get metadataInfo() {
+    return {
+      name: this.name,
+      shortName: this.shortName,
+      logo: this.logo,
+      inputAsset: this.nativeToken.slug,
+      isAvailable: true,
+      maintainAsset: this.nativeToken.slug,
+      maintainBalance: this.maintainBalance,
+      availableMethod: this.availableMethod
+    };
+  }
+
+  /** Can mint when haven't enough native token (use input token for fee) */
+  get isPoolSupportAlternativeFee() {
+    return false;
+  }
+  async getPoolInfo() {
+    return await this.state.earningService.getYieldPool(this.slug);
+  }
+  async getPoolPosition(address) {
+    return await this.state.earningService.getYieldPosition(address, this.slug);
+  }
+
+  /* Subscribe data */
+
+  /** Subscribe pool info */
+
+  /* Subscribe data */
+
+  /* Join action */
+
+  /* Early validate */
+
+  async earlyValidate(request) {
+    var _poolInfo$statistic, _poolInfo$statistic2, _poolInfo$statistic2$;
+    const poolInfo = await this.getPoolInfo();
+    if (!poolInfo || !((_poolInfo$statistic = poolInfo.statistic) !== null && _poolInfo$statistic !== void 0 && _poolInfo$statistic.earningThreshold.join)) {
+      return {
+        passed: false,
+        errorMessage: 'There is a problem fetching your data. Check your Internet connection or change the network endpoint and try again.'
+      };
+    }
+    if (request.address === ALL_ACCOUNT_KEY) {
+      return {
+        passed: true
+      };
+    }
+    const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(this.chain);
+    const nativeTokenBalance = await this.state.balanceService.getTokenFreeBalance(request.address, this.chain);
+    const bnNativeTokenBalance = new BN(nativeTokenBalance.value);
+    const bnMinBalanceToJoin = new BN(((_poolInfo$statistic2 = poolInfo.statistic) === null || _poolInfo$statistic2 === void 0 ? void 0 : (_poolInfo$statistic2$ = _poolInfo$statistic2.earningThreshold) === null || _poolInfo$statistic2$ === void 0 ? void 0 : _poolInfo$statistic2$.join) || '0').add(new BN(poolInfo.metadata.maintainBalance));
+    if (bnNativeTokenBalance.lte(bnMinBalanceToJoin)) {
+      const minJoin = formatNumber(bnMinBalanceToJoin.toString(), this.nativeToken.decimals || 0);
+      const originChain = this.state.getChainInfo(nativeTokenInfo.originChain);
+      return {
+        passed: false,
+        errorMessage: `You need at least ${minJoin} ${nativeTokenInfo.symbol} (${originChain.name}) to start earning`
+      };
+    }
+    return {
+      passed: true
+    };
+  }
+
+  /* Early validate */
+
+  /* Generate steps */
+
+  /**
+   * @function firstStepFee
+   * */
+  get firstStepFee() {
+    return {
+      slug: ''
+    };
+  }
+
+  /**
+   * @function defaultSubmitStep
+   * @description Default submit step data
+   * */
+
+  /**
+   * @async
+   * @function getTokenApproveStep
+   * @param {OptimalYieldPathParams} params - base param to join pool
+   * @description Generate token approve step data
+   * */
+  async getTokenApproveStep(params) {
+    return Promise.resolve(undefined);
+  }
+
+  /**
+   * @async
+   * @function getXcmStep
+   * @param {OptimalYieldPathParams} params - base param to join pool
+   * @description Generate token approve step data
+   * */
+  async getXcmStep(params) {
+    return Promise.resolve(undefined);
+  }
+
+  /**
+   * @async
+   * @function getSubmitStep
+   * @param {OptimalYieldPathParams} params - base param to join pool
+   * @description Generate token approve step data
+   * */
+
+  /** Generate the optimal steps to join pool */
+  async generateOptimalPath(params) {
+    const result = {
+      totalFee: [this.firstStepFee],
+      steps: [DEFAULT_YIELD_FIRST_STEP]
+    };
+    try {
+      const stepFunctions = [this.getTokenApproveStep, this.getXcmStep, this.getSubmitStep];
+      for (const stepFunction of stepFunctions) {
+        const step = await stepFunction.bind(this, params)();
+        if (step) {
+          const [info, fee] = step;
+          result.steps.push({
+            id: result.steps.length,
+            ...info
+          });
+          result.totalFee.push(fee);
+        }
+      }
+      return result;
+    } catch (e) {
+      const errorMessage = e.message;
+      if (errorMessage.includes('network')) {
+        result.connectionError = errorMessage.split(' ')[0];
+      }
+
+      /* Submit step */
+
+      const [step, fee] = this.defaultSubmitStep;
+      result.steps.push({
+        id: result.steps.length,
+        ...step
+      });
+      result.totalFee.push(fee);
+
+      /* Submit step */
+
+      return result;
+    }
+  }
+
+  /* Generate steps */
+
+  /* Validate */
+
+  /** Validate param to join the pool */
+
+  /** Create `transaction` to leave the pool */
+  async handleYieldLeave(fastLeave, amount, address, selectedTarget) {
+    if (fastLeave) {
+      return this.handleYieldRedeem(amount, address, selectedTarget);
+    } else {
+      return this.handleYieldUnstake(amount, address, selectedTarget);
+    }
+  }
+
+  /* Leave action */
+
+  /* Other actions */
+
+  /** Create `transaction` to withdraw unstaked amount */
+
+  /* Other actions */
+}

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

@@ -0,0 +1,5 @@
+export { default as BasePoolHandler } from './base';
+export { default as NominationPoolHandler } from './nomination-pool';
+export * from './lending';
+export * from './liquid-staking';
+export * from './native-staking';

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

@@ -0,0 +1,8 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export { default as BasePoolHandler } from "./base.js";
+export { default as NominationPoolHandler } from "./nomination-pool/index.js";
+export * from "./lending/index.js";
+export * from "./liquid-staking/index.js";
+export * from "./native-staking/index.js";

package/services/earning-service/handlers/lending/base.d.ts

@@ -0,0 +1,8 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { LendingYieldPoolInfo, YieldPoolType } from '@subwallet/extension-base/types';
+import BaseSpecialStakingPoolHandler from '../special';
+export default abstract class BaseLendingPoolHandler extends BaseSpecialStakingPoolHandler {
+    readonly type = YieldPoolType.LENDING;
+    abstract getPoolStat(): Promise<LendingYieldPoolInfo>;
+    validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string): Promise<TransactionError[]>;
+}

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

@@ -0,0 +1,73 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, StakingTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { YieldPoolType } from '@subwallet/extension-base/types';
+import { BN_ZERO, formatNumber } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
+import { t } from 'i18next';
+import BaseSpecialStakingPoolHandler from "../special.js";
+export default class BaseLendingPoolHandler extends BaseSpecialStakingPoolHandler {
+  type = YieldPoolType.LENDING;
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool info */
+
+  /* Leave pool action */
+
+  async validateYieldLeave(amount, address, fastLeave, selectedTarget) {
+    const poolInfo = await this.getPoolInfo();
+    const poolPosition = await this.getPoolPosition(address);
+    if (!poolInfo || !poolInfo.statistic || !poolPosition) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!this.availableMethod.defaultUnstake && !fastLeave) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!this.availableMethod.fastUnstake && fastLeave) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const errors = [];
+    const bnActiveStake = new BigN(poolPosition.activeStake).multipliedBy(poolInfo.statistic.assetEarning[0].exchangeRate || 1);
+    const bnAmount = new BigN(amount);
+    const bnRemainingStake = bnActiveStake.minus(bnAmount);
+    const minStake = new BigN(poolInfo.statistic.earningThreshold.join || '0');
+    const minUnstake = new BigN((fastLeave ? poolInfo.statistic.earningThreshold.fastUnstake : poolInfo.statistic.earningThreshold.defaultUnstake) || '0');
+    const maxUnstakeRequest = poolInfo.statistic.maxWithdrawalRequestPerFarmer;
+    const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
+    if (bnAmount.lte(BN_ZERO)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Amount must be greater than 0'))];
+    }
+    if (bnAmount.lt(minUnstake)) {
+      const minUnstakeStr = formatNumber(minUnstake.toString(), derivativeTokenInfo.decimals || 0);
+      errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_UNSTAKE, t('You need to unstake at least {{amount}} {{token}}', {
+        replace: {
+          amount: minUnstakeStr,
+          token: derivativeTokenInfo.symbol
+        }
+      })));
+    }
+    if (!fastLeave) {
+      if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(minStake))) {
+        errors.push(new TransactionError(StakingTxErrorType.INVALID_ACTIVE_STAKE)); // TODO
+      }
+
+      if (poolPosition.unstakings.length > maxUnstakeRequest) {
+        errors.push(new TransactionError(StakingTxErrorType.EXCEED_MAX_UNSTAKING, t('You cannot unstake more than {{number}} times', {
+          replace: {
+            number: maxUnstakeRequest
+          }
+        })));
+      }
+    }
+    if (bnRemainingStake.lt(0)) {
+      errors.push(new TransactionError(StakingTxErrorType.INVALID_ACTIVE_STAKE)); // TODO
+    }
+
+    return Promise.resolve(errors);
+  }
+
+  /* Leave pool action */
+}

package/services/earning-service/handlers/lending/index.d.ts

@@ -0,0 +1 @@
+export { default as InterlayLendingPoolHandler } from './interlay';

package/services/earning-service/handlers/lending/index.js

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export { default as InterlayLendingPoolHandler } from "./interlay.js";

package/services/earning-service/handlers/lending/interlay.d.ts

@@ -0,0 +1,24 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { BaseYieldStepDetail, HandleYieldStepData, LendingYieldPoolInfo, OptimalYieldPath, OptimalYieldPathParams, SubmitYieldJoinData, TransactionData, YieldPoolMethodInfo, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import BaseLendingPoolHandler from './base';
+export default class InterlayLendingPoolHandler extends BaseLendingPoolHandler {
+    slug: 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[];
+    protected readonly availableMethod: YieldPoolMethodInfo;
+    protected readonly rateDecimals = 18;
+    constructor(state: KoniState, chain: string);
+    protected getDescription(): string;
+    getPoolStat(): Promise<LendingYieldPoolInfo>;
+    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]>;
+}