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

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

@@ -0,0 +1,14 @@
+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[];
+};
+export declare const ST_LIQUID_TOKEN_ABI: Record<string, any>;

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

@@ -0,0 +1,21 @@
+// 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'],
+  astar: ['astar', 'shiden', 'shibuya'],
+  amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum'],
+  // 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']
+};
+
+// 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,112 @@
+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 abstract getDescription(amount?: string): string;
+    protected get maintainBalance(): string;
+    protected 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,226 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
+import { DEFAULT_YIELD_FIRST_STEP } from '@subwallet/extension-base/services/earning-service/constants';
+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
+    };
+  }
+  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) ? ed.mul(new BN(1.5)) : 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 this.state.dbService.getYieldPool(this.slug);
+  }
+  async getPoolPosition(address) {
+    return this.state.dbService.getYieldPositionByAddressAndSlug(address, this.slug);
+  }
+
+  /* Subscribe data */
+
+  /** Subscribe pool info */
+
+  /* Subscribe data */
+
+  /* Join action */
+
+  /* Early validate */
+
+  earlyValidate(request) {
+    return Promise.resolve({
+      passed: false
+    });
+  }
+
+  /* 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,6 @@
+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>;
+}

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

@@ -0,0 +1,12 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { YieldPoolType } from '@subwallet/extension-base/types';
+import BaseSpecialStakingPoolHandler from "../special.js";
+export default class BaseLendingPoolHandler extends BaseSpecialStakingPoolHandler {
+  type = YieldPoolType.LENDING;
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool info */
+}

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,23 @@
+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;
+    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]>;
+}

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

@@ -0,0 +1,176 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getTokenOnChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { EarningStatus, YieldStepType } from '@subwallet/extension-base/types';
+import { BN, BN_ZERO } from '@polkadot/util';
+import { fakeAddress } from "../../constants/index.js";
+import BaseLendingPoolHandler from "./base.js";
+export default class InterlayLendingPoolHandler extends BaseLendingPoolHandler {
+  altInputAsset = 'polkadot-NATIVE-DOT';
+  derivativeAssets = ['interlay-LOCAL-qDOT'];
+  inputAsset = 'interlay-LOCAL-DOT';
+  rewardAssets = ['interlay-LOCAL-DOT'];
+  feeAssets = ['interlay-NATIVE-INTR', 'interlay-LOCAL-DOT'];
+  availableMethod = {
+    join: true,
+    defaultUnstake: false,
+    fastUnstake: true,
+    cancelUnstake: false,
+    withdraw: false,
+    claimReward: false
+  };
+  constructor(state, chain) {
+    super(state, chain);
+    const chainInfo = this.chainInfo;
+    this.slug = `DOT___lending___${chain}`;
+    this.name = `${chainInfo.name} Lending`;
+    this.shortName = chainInfo.name.replaceAll(' Relay Chain', '');
+  }
+  getDescription() {
+    return 'Earn rewards by lending DOT';
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const substrateApi = await this.substrateApi.isReady;
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const _exchangeRate = await substrateApi.api.query.loans.exchangeRate(_getTokenOnChainInfo(inputTokenInfo));
+    const exchangeRate = _exchangeRate.toPrimitive();
+    const decimals = 10 ** 18;
+    return {
+      ...this.baseInfo,
+      type: this.type,
+      metadata: {
+        ...this.metadataInfo,
+        description: this.getDescription()
+      },
+      statistic: {
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apr: 1.29,
+          exchangeRate: exchangeRate / decimals
+        }],
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        minJoinPool: '10000000000',
+        minWithdrawal: '0',
+        totalApr: 1.29,
+        tvl: '291890000000000'
+      }
+    };
+  }
+
+  /* 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.baseInfo,
+          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 qDOT',
+      type: YieldStepType.MINT_QDOT
+    };
+  }
+  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 BN(params.amount).gt(BN_ZERO)) {
+      const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.loans.mint(_getTokenOnChainInfo(inputTokenInfo), params.amount).paymentInfo(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.loans.mint(_getTokenOnChainInfo(inputTokenInfo), data.amount);
+    return {
+      txChain: this.chain,
+      extrinsicType: ExtrinsicType.MINT_QDOT,
+      extrinsic,
+      txData: data,
+      transferNativeAmount: '0'
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    const substrateApi = await this.substrateApi.isReady;
+    // @ts-ignore
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const yieldPositionInfo = await this.getPoolPosition(address);
+    if (!yieldPositionInfo) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const bnAmount = new BN(amount);
+    const bnActiveBalance = new BN(yieldPositionInfo.activeStake);
+    const redeemAll = bnAmount.eq(bnActiveBalance);
+    const extrinsic = !redeemAll ? substrateApi.api.tx.loans.redeem(_getTokenOnChainInfo(inputTokenInfo), amount) : substrateApi.api.tx.loans.redeemAll(_getTokenOnChainInfo(inputTokenInfo));
+    return [ExtrinsicType.REDEEM_QDOT, extrinsic];
+  }
+
+  /* Leave pool action */
+}

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

@@ -0,0 +1,26 @@
+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, UnstakingInfo, YieldPoolMethodInfo, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import BaseLiquidStakingPoolHandler from './base';
+export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
+    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[];
+    readonly minAmountPercent = 0.98;
+    protected readonly availableMethod: YieldPoolMethodInfo;
+    slug: string;
+    constructor(state: KoniState, chain: string);
+    protected getDescription(): 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]>;
+    handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
+}