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

package/services/earning-service/handlers/liquid-staking/parallel.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 { _getTokenOnChainAssetId } 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 { BN, BN_ZERO } from '@polkadot/util';
+import BaseLiquidStakingPoolHandler from "./base.js";
+export default class ParallelLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
+  altInputAsset = 'polkadot-NATIVE-DOT';
+  derivativeAssets = ['parallel-LOCAL-sDOT'];
+  inputAsset = 'parallel-LOCAL-DOT';
+  rewardAssets = ['parallel-LOCAL-DOT'];
+  feeAssets = ['parallel-NATIVE-PARA'];
+  minAmountPercent = 0.97;
+  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 = BN_ZERO;
+    for (const _stakingLedger of _stakingLedgers) {
+      const _ledger = _stakingLedger[1];
+      const ledger = _ledger.toPrimitive();
+      tvl = tvl.add(new 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 ** 18;
+    const apy = (exchangeRate / beginExchangeRate) ** (365 * 24 * 60 * 60000 / (currentTimestamp - beginTimestamp)) - 1;
+    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,
+        minJoinPool: '10000000000',
+        minWithdrawal: '5000000000',
+        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 => [_getTokenOnChainAssetId(derivativeTokenInfo), address]), balances => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      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();
+
+        // @ts-ignore
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument
+        const bnTotalBalance = bdata && bdata.balance ? new BN(String(bdata === null || bdata === void 0 ? void 0 : bdata.balance).replaceAll(',', '') || '0') : 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: [],
+          // TODO: add unstaking info from liquidStaking.unlockings
+          unstakings: []
+        };
+        resultCallback(result);
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint sDOT',
+      type: YieldStepType.MINT_SDOT
+    };
+  }
+  async getSubmitStepFee(params) {
+    const poolOriginSubstrateApi = await this.substrateApi.isReady;
+    const defaultFeeTokenSlug = this.feeAssets[0];
+    if (new BN(params.amount).gt(BN_ZERO)) {
+      const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.liquidStaking.stake(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 extrinsic = substrateApi.api.tx.liquidStaking.stake(data.amount);
+    return {
+      txChain: this.chain,
+      extrinsicType: ExtrinsicType.MINT_SDOT,
+      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.ammRoute.swapExactTokensForTokens(['1001', '101'], amount, weightedMinAmount);
+    return [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 [ExtrinsicType.UNSTAKE_SDOT, extrinsic];
+  }
+
+  /* Leave pool action */
+}

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

@@ -0,0 +1,34 @@
+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 } from '@subwallet/extension-base/services/chain-service/types';
+import { BaseYieldStepDetail, HandleYieldStepData, LiquidYieldPoolInfo, OptimalYieldPath, OptimalYieldPathParams, SubmitYieldJoinData, TransactionData, UnstakingInfo, YieldPoolMethodInfo, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import { Contract } from 'web3-eth-contract';
+import BaseLiquidStakingPoolHandler from './base';
+export declare const getStellaswapLiquidStakingContract: (networkKey: string, assetAddress: string, evmApi: _EvmApi, options?: {}) => Contract;
+export default class StellaSwapLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
+    slug: string;
+    protected readonly name: string;
+    protected readonly shortName: string;
+    protected readonly inputAsset: string;
+    protected readonly altInputAsset: string;
+    protected readonly derivativeAssets: string[];
+    protected readonly rewardAssets: string[];
+    protected readonly feeAssets: string[];
+    transactionChainType: ChainType;
+    protected readonly availableMethod: YieldPoolMethodInfo;
+    constructor(state: KoniState, chain: string);
+    protected getDescription(): string;
+    getPoolStat(): Promise<LiquidYieldPoolInfo>;
+    subscribePoolPosition(useAddresses: string[], resultCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    get submitJoinStepInfo(): BaseYieldStepDetail;
+    getTokenApproveStep(params: OptimalYieldPathParams): Promise<[BaseYieldStepDetail, YieldTokenBaseInfo] | undefined>;
+    getSubmitStepFee(params: OptimalYieldPathParams): Promise<YieldTokenBaseInfo>;
+    generateOptimalPath(params: OptimalYieldPathParams): Promise<OptimalYieldPath>;
+    protected validateTokenApproveStep(params: OptimalYieldPathParams, path: OptimalYieldPath): Promise<TransactionError[]>;
+    protected handleTokenApproveStep(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<HandleYieldStepData>;
+    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>;
+}

package/services/earning-service/handlers/liquid-staking/stella-swap.js

@@ -0,0 +1,399 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { getERC20Contract } from '@subwallet/extension-base/koni/api/tokens/evm/web3';
+import { _getAssetDecimals, _getContractAddressOfToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { EarningStatus, UnstakingStatus, YieldStepType } from '@subwallet/extension-base/types';
+import fetch from 'cross-fetch';
+import { BN, BN_ZERO } from '@polkadot/util';
+import { DEFAULT_YIELD_FIRST_STEP, ST_LIQUID_TOKEN_ABI } from "../../constants/index.js";
+import BaseLiquidStakingPoolHandler from "./base.js";
+export const getStellaswapLiquidStakingContract = (networkKey, assetAddress, evmApi, options = {}) => {
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-member-access
+  return new evmApi.api.eth.Contract(ST_LIQUID_TOKEN_ABI, assetAddress, options);
+};
+const APR_STATS_URL = 'https://apr-api.stellaswap.com/api/v1/stdot';
+const SUBWALLET_REFERRAL = '0x7e6815f45E624768548d085231f2d453f16FD7DD';
+const MAX_INT = '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+export default class StellaSwapLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
+  inputAsset = 'moonbeam-LOCAL-xcDOT';
+  altInputAsset = '';
+  derivativeAssets = ['moonbeam-ERC20-stDOT-0xbc7E02c4178a7dF7d3E564323a5c359dc96C4db4'];
+  rewardAssets = ['moonbeam-LOCAL-xcDOT'];
+  feeAssets = ['moonbeam-NATIVE-GLMR'];
+  transactionChainType = ChainType.EVM;
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: true,
+    cancelUnstake: false,
+    withdraw: true,
+    claimReward: false
+  };
+  constructor(state, chain) {
+    super(state, chain);
+    this.slug = 'xcDOT___liquid_staking___stellaswap';
+    this.name = 'Stellaswap Liquid Staking';
+    this._logo = 'stellaswap';
+    this.shortName = 'Stellaswap';
+  }
+  getDescription() {
+    return 'Earn rewards by staking xcDOT for stDOT';
+  }
+
+  /* Subscribe pool info */
+
+  async getPoolStat() {
+    const evmApi = this.evmApi;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const stakingContract = getStellaswapLiquidStakingContract(this.chain, _getContractAddressOfToken(derivativeTokenInfo), evmApi);
+    const aprPromise = new Promise(function (resolve) {
+      fetch(APR_STATS_URL, {
+        method: 'GET'
+      }).then(res => {
+        resolve(res.json());
+      }).catch(console.error);
+    });
+    const sampleTokenShare = 10 ** _getAssetDecimals(derivativeTokenInfo);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const tvlCall = stakingContract.methods.fundRaisedBalance();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const exchangeRateCall = stakingContract.methods.getPooledTokenByShares(sampleTokenShare);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const [aprObject, tvl, equivalentTokenShare] = await Promise.all([aprPromise,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    tvlCall.call(),
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    exchangeRateCall.call()]);
+    const exchangeRate = equivalentTokenShare / 10 ** _getAssetDecimals(derivativeTokenInfo);
+    return {
+      ...this.baseInfo,
+      type: this.type,
+      metadata: {
+        ...this.metadataInfo,
+        description: this.getDescription()
+      },
+      statistic: {
+        assetEarning: [{
+          slug: this.rewardAssets[0],
+          apr: aprObject.result,
+          exchangeRate: exchangeRate
+        }],
+        unstakingPeriod: 24 * 28,
+        maxCandidatePerFarmer: 1,
+        maxWithdrawalRequestPerFarmer: 1,
+        minJoinPool: '0',
+        minWithdrawal: '0',
+        totalApr: aprObject.result,
+        tvl: tvl.toString()
+      }
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    var _this$derivativeAsset;
+    let cancel = false;
+    const evmApi = this.evmApi;
+    const derivativeTokenSlug = ((_this$derivativeAsset = this.derivativeAssets) === null || _this$derivativeAsset === void 0 ? void 0 : _this$derivativeAsset[0]) || '';
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const contract = getStellaswapLiquidStakingContract(this.chain, _getContractAddressOfToken(derivativeTokenInfo), evmApi);
+    const getTokenBalance = () => {
+      if (!cancel) {
+        useAddresses.map(async address => {
+          if (!cancel) {
+            return;
+          }
+
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          const balance = await contract.methods.balanceOf(address).call();
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          const unbondedObject = await contract.methods.getUnbonded(address).call();
+          const unstakings = [];
+          let unlockBalance = BN_ZERO;
+          if (parseInt(unbondedObject.unbonded) > 0) {
+            unlockBalance = unlockBalance.add(new BN(unbondedObject.unbonded));
+            unstakings.push({
+              chain: this.chain,
+              claimable: unbondedObject.unbonded,
+              status: UnstakingStatus.CLAIMABLE,
+              waitingTime: 0
+            });
+          }
+          if (parseInt(unbondedObject.waiting) > 0) {
+            unlockBalance = unlockBalance.add(new BN(unbondedObject.waiting));
+            unstakings.push({
+              chain: this.chain,
+              claimable: unbondedObject.waiting,
+              status: UnstakingStatus.UNLOCKING
+            });
+          }
+          const totalBalance = new BN(balance).add(unlockBalance);
+          const result = {
+            ...this.baseInfo,
+            type: this.type,
+            address,
+            balanceToken: this.inputAsset,
+            totalStake: totalBalance.toString(),
+            activeStake: balance.toString(),
+            unstakeBalance: unlockBalance.toString(),
+            isBondedBefore: totalBalance.gt(BN_ZERO),
+            derivativeToken: derivativeTokenSlug,
+            status: EarningStatus.EARNING_REWARD,
+            nominations: [],
+            unstakings
+          };
+          resultCallback(result);
+        });
+      }
+    };
+    getTokenBalance();
+    const interval = setInterval(getTokenBalance, 30000);
+    return () => {
+      cancel = true;
+      clearInterval(interval);
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Join pool action */
+
+  get submitJoinStepInfo() {
+    return {
+      name: 'Mint stDOT',
+      type: YieldStepType.MINT_STDOT
+    };
+  }
+  async getTokenApproveStep(params) {
+    const evmApi = this.evmApi;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const inputTokenContract = getERC20Contract(this.chain, _getContractAddressOfToken(inputTokenInfo), this.state.getEvmApiMap());
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const allowanceCall = inputTokenContract.methods.allowance(params.address, _getContractAddressOfToken(derivativeTokenInfo));
+    const [allowance, gasPrice] = await Promise.all([
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    await allowanceCall.call(), evmApi.api.eth.getGasPrice()]);
+    if (!allowance || parseInt(allowance) <= 0) {
+      const step = {
+        name: 'Authorize token approval',
+        type: YieldStepType.TOKEN_APPROVAL
+      };
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      const estimatedGas = await allowanceCall.estimateGas();
+      const fee = {
+        slug: this.feeAssets[0],
+        amount: (estimatedGas * parseInt(gasPrice)).toString()
+      };
+      return [step, fee];
+    }
+    return undefined;
+  }
+  async getSubmitStepFee(params) {
+    const evmApi = this.evmApi;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    if (new BN(params.amount).gt(BN_ZERO)) {
+      const stakingContract = getStellaswapLiquidStakingContract(this.chain, _getContractAddressOfToken(derivativeTokenInfo), evmApi);
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+      const depositCall = stakingContract.methods.deposit(params.amount);
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      const estimatedDepositGas = await depositCall.estimateGas();
+      const gasPrice = await evmApi.api.eth.getGasPrice();
+      return {
+        slug: this.feeAssets[0],
+        amount: (estimatedDepositGas * parseInt(gasPrice)).toString()
+      };
+    } else {
+      return {
+        slug: this.feeAssets[0],
+        amount: '0'
+      };
+    }
+  }
+  async generateOptimalPath(params) {
+    const result = {
+      totalFee: [{
+        slug: ''
+      }],
+      steps: [DEFAULT_YIELD_FIRST_STEP]
+    };
+    try {
+      /* Token approve step */
+
+      const approveStep = await this.getTokenApproveStep(params);
+      if (approveStep) {
+        const [step, fee] = approveStep;
+        result.steps.push({
+          id: result.steps.length,
+          ...step
+        });
+        result.totalFee.push(fee);
+      }
+
+      /* Token approve step */
+
+      /* Submit step */
+
+      const submitFee = await this.getSubmitStepFee(params);
+      result.steps.push({
+        id: result.steps.length,
+        ...this.submitJoinStepInfo
+      });
+      result.totalFee.push(submitFee);
+
+      /* Submit step */
+
+      return result;
+    } catch (e) {
+      const errorMessage = e.message;
+      if (errorMessage.includes('network')) {
+        result.connectionError = errorMessage.split(' ')[0];
+      }
+
+      /* Submit step */
+
+      result.steps.push({
+        id: result.steps.length,
+        ...this.submitJoinStepInfo
+      });
+      result.totalFee.push({
+        slug: this.feeAssets[0],
+        amount: '0'
+      });
+
+      /* Submit step */
+
+      return result;
+    }
+  }
+  async validateTokenApproveStep(params, path) {
+    return Promise.resolve([]);
+  }
+  async handleTokenApproveStep(data, path) {
+    const {
+      address
+    } = data;
+    const inputTokenSlug = this.inputAsset;
+    const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
+    const derivativeTokenInfo = this.state.getAssetBySlug(this.derivativeAssets[0]);
+    const derivativeTokenContractAddress = _getContractAddressOfToken(derivativeTokenInfo);
+    const inputTokenContract = getERC20Contract(this.chain, _getContractAddressOfToken(inputTokenInfo), this.state.getEvmApiMap());
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const approveCall = inputTokenContract.methods.approve(derivativeTokenContractAddress, MAX_INT); // TODO: need test
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const approveEncodedCall = approveCall.encodeABI();
+    const transactionObject = {
+      from: address,
+      to: _getContractAddressOfToken(inputTokenInfo),
+      data: approveEncodedCall
+    };
+    return Promise.resolve({
+      txChain: this.chain,
+      extrinsicType: ExtrinsicType.EVM_EXECUTE,
+      extrinsic: transactionObject,
+      txData: transactionObject,
+      transferNativeAmount: '0'
+    });
+  }
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async handleSubmitStep(data, path) {
+    const {
+      address,
+      amount
+    } = data;
+    const evmApi = this.evmApi;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const stakingContract = getStellaswapLiquidStakingContract(this.chain, _getContractAddressOfToken(derivativeTokenInfo), evmApi);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const depositCall = stakingContract.methods.deposit(amount, SUBWALLET_REFERRAL); // TODO: need test
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const depositEncodedCall = depositCall.encodeABI();
+    const transactionObject = {
+      from: address,
+      to: _getContractAddressOfToken(derivativeTokenInfo),
+      data: depositEncodedCall
+    };
+    return {
+      txChain: this.chain,
+      extrinsicType: ExtrinsicType.MINT_STDOT,
+      extrinsic: transactionObject,
+      txData: data,
+      transferNativeAmount: '0'
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const evmApi = this.evmApi;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const stakingContract = getStellaswapLiquidStakingContract(this.chain, _getContractAddressOfToken(derivativeTokenInfo), evmApi);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const redeemCall = stakingContract.methods.redeem(amount);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const redeemEncodedCall = redeemCall.encodeABI();
+    const transaction = {
+      from: address,
+      to: _getContractAddressOfToken(derivativeTokenInfo),
+      data: redeemEncodedCall
+    };
+    return [ExtrinsicType.STAKING_UNBOND, transaction];
+  }
+
+  /* Leave pool action */
+
+  /* Other actions */
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const evmApi = this.evmApi;
+    const derivativeTokenSlug = this.derivativeAssets[0];
+    const derivativeTokenInfo = this.state.getAssetBySlug(derivativeTokenSlug);
+    const stakingContract = getStellaswapLiquidStakingContract(this.chain, _getContractAddressOfToken(derivativeTokenInfo), evmApi);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const withdrawCall = stakingContract.methods.claimUnbonded();
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+    const withdrawEncodedCall = withdrawCall.encodeABI();
+    return {
+      from: address,
+      to: _getContractAddressOfToken(derivativeTokenInfo),
+      data: withdrawEncodedCall
+    }; // TODO: check tx history parsing
+  }
+
+  /* Other actions */
+}

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

@@ -0,0 +1,22 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ExtrinsicType, UnstakingInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { BaseYieldPositionInfo, EarningRewardItem, ParachainStakingStakeOption, StakeCancelWithdrawalParams, SubmitJoinNativeStaking, TransactionData, ValidatorInfo, YieldPoolInfo, YieldPositionInfo, YieldStepBaseInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import { SubmittableExtrinsic } from '@polkadot/api/types';
+import BaseParaNativeStakingPoolHandler from './base-para';
+export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
+    subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
+    parseNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, delegatorState: ParachainStakingStakeOption, unstakingInfo: Record<string, number>): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
+    subscribePoolPosition(useAddresses: string[], resultCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    getPoolReward(useAddresses: string[], callBack: (rs: EarningRewardItem) => void): Promise<VoidFunction>;
+    getPoolTargets(): Promise<ValidatorInfo[]>;
+    get defaultSubmitStep(): YieldStepBaseInfo;
+    createJoinExtrinsic(data: SubmitJoinNativeStaking, positionInfo?: YieldPositionInfo, bondDest?: string): Promise<[TransactionData, YieldTokenBaseInfo]>;
+    handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    /**
+     * @todo Need recheck
+     * */
+    handleYieldCancelUnstake(params: StakeCancelWithdrawalParams): Promise<TransactionData>;
+    handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
+    handleYieldClaimReward(address: string, bondReward?: boolean): Promise<SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+}