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

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

@@ -0,0 +1,152 @@
+// 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 { YieldPoolType, YieldStepType } from '@subwallet/extension-base/types';
+import { noop } from '@polkadot/util';
+import BasePoolHandler from "../base.js";
+export default class BaseNativeStakingPoolHandler extends BasePoolHandler {
+  type = YieldPoolType.NATIVE_STAKING;
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: false,
+    cancelUnstake: true,
+    withdraw: true,
+    claimReward: false
+  };
+  constructor(state, chain) {
+    super(state, chain);
+    const _chainAsset = this.nativeToken;
+    const _chainInfo = this.chainInfo;
+    const symbol = _chainAsset.symbol;
+    this.slug = `${symbol}___native_staking___${_chainInfo.slug}`;
+    this.name = `${_chainInfo.name} Native Staking`;
+    this.shortName = _chainInfo.name.replaceAll(' Relay Chain', '');
+  }
+  getDescription(amount = '0') {
+    const _chainAsset = this.nativeToken;
+    const symbol = _chainAsset.symbol;
+    return `Start staking with just {{amount}} ${symbol}`.replace('{{amount}}', amount);
+  }
+
+  /* Get pool reward */
+
+  async getPoolReward(useAddresses, callBack) {
+    return new Promise(resolve => resolve(noop));
+  }
+  async getPoolRewardHistory(useAddresses, callBack) {
+    let cancel = false;
+    const haveSubscanService = this.state.subscanService.checkSupportedSubscanChain(this.chain);
+    if (haveSubscanService) {
+      for (const address of useAddresses) {
+        if (cancel) {
+          break;
+        }
+        try {
+          const rs = await this.state.subscanService.getRewardHistoryList(this.chain, address);
+          const items = rs.list;
+          if (items) {
+            for (const item of items) {
+              const now = new Date();
+              const isMillisecond = now.getTime().toString().length === item.block_timestamp.toString().length;
+              const timeStamp = isMillisecond ? item.block_timestamp : item.block_timestamp * 1000;
+              const data = {
+                slug: this.slug,
+                type: this.type,
+                chain: this.chain,
+                address: address,
+                group: this.group,
+                blockTimestamp: timeStamp,
+                amount: item.amount,
+                eventIndex: item.event_index
+              };
+              callBack(data);
+            }
+          }
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    }
+    return () => {
+      cancel = false;
+    };
+  }
+
+  /* Get pool reward */
+
+  /* Join pool action */
+
+  get defaultSubmitStep() {
+    return [{
+      name: 'Nominate validators',
+      type: YieldStepType.NOMINATE
+    }, {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+  async getSubmitStep(params) {
+    const {
+      address,
+      amount,
+      slug,
+      targets
+    } = params;
+    const selectedValidators = !targets ? [] : targets;
+    const data = {
+      amount,
+      address,
+      slug,
+      selectedValidators
+    };
+    const positionInfo = await this.getPoolPosition(address);
+    const [, fee] = await this.createJoinExtrinsic(data, positionInfo);
+    return [this.defaultSubmitStep[0], fee];
+  }
+  async handleYieldJoin(_data, path, currentStep) {
+    const data = _data;
+    const {
+      address,
+      amount,
+      selectedValidators
+    } = data;
+    const positionInfo = await this.getPoolPosition(address);
+    const [extrinsic] = await this.createJoinExtrinsic(data, positionInfo);
+    const bondingData = {
+      poolPosition: positionInfo,
+      slug: this.slug,
+      amount,
+      address,
+      selectedValidators
+    };
+    return {
+      txChain: this.chain,
+      extrinsicType: ExtrinsicType.STAKING_BOND,
+      extrinsic,
+      txData: bondingData,
+      transferNativeAmount: amount,
+      chainType: ChainType.SUBSTRATE
+    };
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldRedeem(amount, address, selectedTarget) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+
+  /* Leave pool action */
+
+  /* Other action */
+
+  async handleYieldClaimReward(address, bondReward) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+
+  /* Other actions */
+}

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

@@ -0,0 +1,4 @@
+export { default as AmplitudeNativeStakingPoolHandler } from './amplitude';
+export { default as AstarNativeStakingPoolHandler } from './astar';
+export { default as RelayNativeStakingPoolHandler } from './relay-chain';
+export { default as ParaNativeStakingPoolHandler } from './para-chain';

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

@@ -0,0 +1,7 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export { default as AmplitudeNativeStakingPoolHandler } from "./amplitude.js";
+export { default as AstarNativeStakingPoolHandler } from "./astar.js";
+export { default as RelayNativeStakingPoolHandler } from "./relay-chain.js";
+export { default as ParaNativeStakingPoolHandler } from "./para-chain.js";

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

@@ -0,0 +1,15 @@
+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, PalletParachainStakingDelegator, StakeCancelWithdrawalParams, SubmitJoinNativeStaking, TransactionData, ValidatorInfo, YieldPoolInfo, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import BaseParaNativeStakingPoolHandler from './base-para';
+export default class ParaNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
+    subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
+    parseNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, delegatorState: PalletParachainStakingDelegator): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
+    subscribePoolPosition(useAddresses: string[], resultCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    getPoolTargets(): Promise<ValidatorInfo[]>;
+    createJoinExtrinsic(data: SubmitJoinNativeStaking, positionInfo?: YieldPositionInfo): Promise<[TransactionData, YieldTokenBaseInfo]>;
+    handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    handleYieldCancelUnstake(params: StakeCancelWithdrawalParams): Promise<TransactionData>;
+    handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
+}

package/services/earning-service/handlers/native-staking/para-chain.js

@@ -0,0 +1,382 @@
+// 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 { getBondedValidators, getEarningStatusByNominations, getParaCurrentInflation, isUnstakeAll } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { parseIdentity } from '@subwallet/extension-base/services/earning-service/utils';
+import { EarningStatus, UnstakingStatus } from '@subwallet/extension-base/types';
+import { balanceFormatter, formatNumber, parseRawNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import { BN, BN_ZERO } from '@polkadot/util';
+import BaseParaNativeStakingPoolHandler from "./base-para.js";
+export default class ParaNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const chainApi = this.substrateApi;
+    const nativeToken = this.nativeToken;
+    const defaultCallback = async () => {
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription()
+        }
+      };
+      const poolInfo = await this.getPoolInfo();
+      !poolInfo && callback(data);
+    };
+    if (!this.isActive) {
+      await defaultCallback();
+      return () => {
+        cancel = true;
+      };
+    }
+    await defaultCallback();
+    await chainApi.isReady;
+    const unsub = await chainApi.api.query.parachainStaking.round(async _round => {
+      var _chainApi$api$consts, _chainApi$api$consts$, _chainApi$api$consts$2;
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const roundObj = _round.toHuman();
+      const round = parseRawNumber(roundObj.current);
+      const maxDelegations = (_chainApi$api$consts = chainApi.api.consts) === null || _chainApi$api$consts === void 0 ? void 0 : (_chainApi$api$consts$ = _chainApi$api$consts.parachainStaking) === null || _chainApi$api$consts$ === void 0 ? void 0 : (_chainApi$api$consts$2 = _chainApi$api$consts$.maxDelegationsPerDelegator) === null || _chainApi$api$consts$2 === void 0 ? void 0 : _chainApi$api$consts$2.toString();
+      const unstakingDelay = chainApi.api.consts.parachainStaking.delegationBondLessDelay.toString();
+      let _unvestedAllocation;
+      if (chainApi.api.query.vesting && chainApi.api.query.vesting.totalUnvestedAllocation) {
+        _unvestedAllocation = await chainApi.api.query.vesting.totalUnvestedAllocation();
+      }
+      const [_totalStake, _totalIssuance, _inflation] = await Promise.all([chainApi.api.query.parachainStaking.staked(round), chainApi.api.query.balances.totalIssuance(), chainApi.api.query.parachainStaking.inflationConfig()]);
+      let unvestedAllocation;
+      if (_unvestedAllocation) {
+        const rawUnvestedAllocation = _unvestedAllocation.toString();
+        unvestedAllocation = new BN(rawUnvestedAllocation);
+      }
+      const totalStake = _totalStake ? new BN(_totalStake.toString()) : BN_ZERO;
+      const totalIssuance = new BN(_totalIssuance.toString());
+      if (unvestedAllocation) {
+        totalIssuance.add(unvestedAllocation); // for Turing network, read more at https://hackmd.io/@sbAqOuXkRvyiZPOB3Ryn6Q/Sypr3ZJh5
+      }
+
+      const inflationConfig = _inflation.toHuman();
+      const inflation = getParaCurrentInflation(parseRawNumber(totalStake.toString()), inflationConfig);
+      const eraTime = _STAKING_ERA_LENGTH_MAP[this.chain] || _STAKING_ERA_LENGTH_MAP.default; // in hours
+      const unstakingPeriod = parseInt(unstakingDelay) * eraTime;
+      const minStake = '0';
+      const minToHuman = formatNumber(minStake.toString(), nativeToken.decimals || 0, balanceFormatter);
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription(minToHuman)
+        },
+        statistic: {
+          assetEarning: [{
+            slug: this.nativeToken.slug
+          }],
+          maxCandidatePerFarmer: parseInt(maxDelegations),
+          maxWithdrawalRequestPerFarmer: 1,
+          // by default
+          earningThreshold: {
+            join: minStake.toString(),
+            defaultUnstake: '0',
+            fastUnstake: '0'
+          },
+          farmerCount: 0,
+          // TODO recheck
+          era: round,
+          eraTime,
+          totalApy: undefined,
+          // not have
+          tvl: totalStake.toString(),
+          unstakingPeriod: unstakingPeriod,
+          inflation
+        }
+      };
+      callback(data);
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async parseNominatorMetadata(chainInfo, address, substrateApi, delegatorState) {
+    const nominationList = [];
+    const unstakingMap = {};
+    let bnTotalActiveStake = BN_ZERO;
+    let bnTotalStake = BN_ZERO;
+    let bnTotalUnstaking = BN_ZERO;
+    const _roundInfo = await substrateApi.api.query.parachainStaking.round();
+    const roundInfo = _roundInfo.toPrimitive();
+    const currentRound = roundInfo.current;
+    await Promise.all(delegatorState.delegations.map(async delegation => {
+      const [_delegationScheduledRequests, [identity], _collatorInfo] = await Promise.all([substrateApi.api.query.parachainStaking.delegationScheduledRequests(delegation.owner), parseIdentity(substrateApi, delegation.owner), substrateApi.api.query.parachainStaking.candidateInfo(delegation.owner)]);
+      const collatorInfo = _collatorInfo.toPrimitive();
+      const minDelegation = collatorInfo === null || collatorInfo === void 0 ? void 0 : collatorInfo.lowestTopDelegationAmount.toString();
+      const delegationScheduledRequests = _delegationScheduledRequests.toPrimitive();
+      let hasUnstaking = false;
+      let delegationStatus = EarningStatus.NOT_EARNING;
+
+      // parse unstaking info
+      if (delegationScheduledRequests) {
+        for (const scheduledRequest of delegationScheduledRequests) {
+          if (reformatAddress(scheduledRequest.delegator, 0) === reformatAddress(address, 0)) {
+            // add network prefix
+            const isClaimable = scheduledRequest.whenExecutable - currentRound < 0;
+            const remainingEra = scheduledRequest.whenExecutable - currentRound;
+            const waitingTime = remainingEra * _STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+            const claimable = Object.values(scheduledRequest.action)[0];
+            unstakingMap[delegation.owner] = {
+              chain: chainInfo.slug,
+              status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+              validatorAddress: delegation.owner,
+              claimable: claimable.toString(),
+              waitingTime
+            };
+            hasUnstaking = true;
+            break; // only handle 1 scheduledRequest per collator
+          }
+        }
+      }
+
+      const bnStake = new BN(delegation.amount);
+      const bnUnstakeBalance = unstakingMap[delegation.owner] ? new BN(unstakingMap[delegation.owner].claimable) : BN_ZERO;
+      const bnActiveStake = bnStake.sub(bnUnstakeBalance);
+      if (bnActiveStake.gt(BN_ZERO) && bnActiveStake.gte(new BN(minDelegation))) {
+        delegationStatus = EarningStatus.EARNING_REWARD;
+      }
+      bnTotalActiveStake = bnTotalActiveStake.add(bnActiveStake);
+      bnTotalStake = bnTotalStake.add(bnStake);
+      bnTotalUnstaking = bnTotalUnstaking.add(bnUnstakeBalance);
+      nominationList.push({
+        chain: chainInfo.slug,
+        status: delegationStatus,
+        validatorAddress: delegation.owner,
+        validatorIdentity: identity,
+        activeStake: bnActiveStake.toString(),
+        hasUnstaking,
+        validatorMinStake: collatorInfo.lowestTopDelegationAmount.toString()
+      });
+    }));
+
+    // await Promise.all(nominationList.map(async (nomination) => {
+    //   const _collatorInfo = await substrateApi.api.query.parachainStaking.candidateInfo(nomination.validatorAddress);
+    //   const collatorInfo = _collatorInfo.toPrimitive() as unknown as ParachainStakingCandidateMetadata;
+    //
+    //   nomination.validatorMinStake = collatorInfo.lowestTopDelegationAmount.toString();
+    // }));
+
+    const stakingStatus = getEarningStatusByNominations(bnTotalActiveStake, nominationList);
+    const totalStake = bnTotalStake.toString();
+    const activeStake = bnTotalActiveStake.toString();
+    const unstakingBalance = bnTotalUnstaking.toString();
+    return {
+      status: stakingStatus,
+      totalStake,
+      balanceToken: this.nativeToken.slug,
+      activeStake: activeStake,
+      unstakeBalance: unstakingBalance,
+      isBondedBefore: !!nominationList.length,
+      nominations: nominationList,
+      unstakings: Object.values(unstakingMap)
+    };
+  }
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    const defaultInfo = this.baseInfo;
+    const chainInfo = this.chainInfo;
+    await substrateApi.isReady;
+    const unsub = await substrateApi.api.query.parachainStaking.delegatorState.multi(useAddresses, async ledgers => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      if (ledgers) {
+        await Promise.all(ledgers.map(async (_delegatorState, i) => {
+          const delegatorState = _delegatorState.toPrimitive();
+          const owner = reformatAddress(useAddresses[i], 42);
+          if (delegatorState) {
+            const nominatorMetadata = await this.parseNominatorMetadata(chainInfo, owner, substrateApi, delegatorState);
+            resultCallback({
+              ...defaultInfo,
+              ...nominatorMetadata,
+              address: owner,
+              type: this.type
+            });
+          } else {
+            resultCallback({
+              ...defaultInfo,
+              type: this.type,
+              address: owner,
+              balanceToken: this.nativeToken.slug,
+              totalStake: '0',
+              activeStake: '0',
+              unstakeBalance: '0',
+              status: EarningStatus.NOT_STAKING,
+              isBondedBefore: false,
+              nominations: [],
+              unstakings: []
+            });
+          }
+        }));
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool targets */
+
+  async getPoolTargets() {
+    const apiProps = await this.substrateApi.isReady;
+    const allCollators = [];
+    const [_allCollators, _collatorCommission] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo.entries(), apiProps.api.query.parachainStaking.collatorCommission()]);
+    const maxDelegationPerCollator = apiProps.api.consts.parachainStaking.maxTopDelegationsPerCandidate.toString();
+    const rawCollatorCommission = _collatorCommission.toHuman();
+    const collatorCommission = parseFloat(rawCollatorCommission.split('%')[0]);
+    for (const collator of _allCollators) {
+      const _collatorAddress = collator[0].toHuman();
+      const collatorAddress = _collatorAddress[0];
+      const collatorInfo = collator[1].toPrimitive();
+      const bnTotalStake = new BN(collatorInfo.totalCounted);
+      const bnOwnStake = new BN(collatorInfo.bond);
+      const bnOtherStake = bnTotalStake.sub(bnOwnStake);
+      const bnMinBond = new BN(collatorInfo.lowestTopDelegationAmount);
+      allCollators.push({
+        commission: 0,
+        expectedReturn: 0,
+        address: collatorAddress,
+        totalStake: bnTotalStake.toString(),
+        ownStake: bnOwnStake.toString(),
+        otherStake: bnOtherStake.toString(),
+        nominatorCount: collatorInfo.delegationCount,
+        blocked: false,
+        isVerified: false,
+        minBond: bnMinBond.toString(),
+        chain: this.chain,
+        isCrowded: parseInt(maxDelegationPerCollator) > 0
+      });
+    }
+    const extraInfoMap = {};
+    await Promise.all(allCollators.map(async collator => {
+      const [_info, [identity, isReasonable]] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo(collator.address), parseIdentity(apiProps, collator.address)]);
+      const rawInfo = _info.toHuman();
+      const active = (rawInfo === null || rawInfo === void 0 ? void 0 : rawInfo.status) === 'Active';
+      extraInfoMap[collator.address] = {
+        identity,
+        isVerified: isReasonable,
+        active
+      };
+    }));
+    for (const validator of allCollators) {
+      validator.blocked = !extraInfoMap[validator.address].active;
+      validator.identity = extraInfoMap[validator.address].identity;
+      validator.isVerified = extraInfoMap[validator.address].isVerified;
+      // @ts-ignore
+      validator.commission = collatorCommission;
+    }
+    return allCollators;
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  async createJoinExtrinsic(data, positionInfo) {
+    const {
+      amount,
+      selectedValidators
+    } = data;
+    const apiPromise = await this.substrateApi.isReady;
+    const binaryAmount = new BN(amount);
+    const selectedCollatorInfo = selectedValidators[0];
+
+    // eslint-disable-next-line @typescript-eslint/require-await
+    const compoundResult = async extrinsic => {
+      const tokenSlug = this.nativeToken.slug;
+      // const feeInfo = await extrinsic.paymentInfo(address);
+      // const fee = feeInfo.toPrimitive() as unknown as RuntimeDispatchInfo;
+
+      // Not use the fee to validate and to display on UI
+      return [extrinsic, {
+        slug: tokenSlug,
+        amount: '0'
+      }];
+    };
+    if (!positionInfo) {
+      const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new BN(selectedCollatorInfo.nominatorCount), 0);
+      return compoundResult(extrinsic);
+    }
+    const {
+      bondedValidators,
+      nominationCount
+    } = getBondedValidators(positionInfo.nominations);
+    const parsedSelectedCollatorAddress = reformatAddress(selectedCollatorInfo.address, 0);
+    if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
+      const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new BN(selectedCollatorInfo.nominatorCount), nominationCount);
+      return compoundResult(extrinsic);
+    } else {
+      const extrinsic = apiPromise.api.tx.parachainStaking.delegatorBondMore(selectedCollatorInfo.address, binaryAmount);
+      return compoundResult(extrinsic);
+    }
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const apiPromise = await this.substrateApi.isReady;
+    const binaryAmount = new BN(amount);
+    const poolPosition = await this.getPoolPosition(address);
+    if (!selectedTarget || !poolPosition) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const unstakeAll = isUnstakeAll(selectedTarget, poolPosition.nominations, amount);
+    let extrinsic;
+    if (!unstakeAll) {
+      extrinsic = apiPromise.api.tx.parachainStaking.scheduleDelegatorBondLess(selectedTarget, binaryAmount);
+    } else {
+      extrinsic = apiPromise.api.tx.parachainStaking.scheduleRevokeDelegation(selectedTarget);
+    }
+    return [ExtrinsicType.STAKING_LEAVE_POOL, extrinsic];
+  }
+
+  /* Leave pool action */
+
+  /* Other action */
+
+  async handleYieldCancelUnstake(params) {
+    const {
+      selectedUnstaking
+    } = params;
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.parachainStaking.cancelDelegationRequest(selectedUnstaking.validatorAddress);
+  }
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const collatorAddress = unstakingInfo.validatorAddress;
+    if (!collatorAddress) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.parachainStaking.executeDelegationRequest(address, collatorAddress);
+  }
+
+  /* Other actions */
+}

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

@@ -0,0 +1,21 @@
+/// <reference types="bn.js" />
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ExtrinsicType, UnstakingInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { BaseYieldPositionInfo, OptimalYieldPath, PalletStakingStakingLedger, StakeCancelWithdrawalParams, SubmitJoinNativeStaking, SubmitYieldJoinData, TransactionData, ValidatorInfo, YieldPoolInfo, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import { DeriveSessionProgress } from '@polkadot/api-derive/types';
+import { BN } from '@polkadot/util';
+import BaseNativeStakingPoolHandler from './base';
+export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPoolHandler {
+    subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
+    parseNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, ledger: PalletStakingStakingLedger, currentEra: string, minStake: BN, _deriveSessionProgress: DeriveSessionProgress): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
+    subscribePoolPosition(useAddresses: string[], resultCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    getPoolTargets(): Promise<ValidatorInfo[]>;
+    validateYieldJoin(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<TransactionError[]>;
+    createJoinExtrinsic(data: SubmitJoinNativeStaking, positionInfo?: YieldPositionInfo, bondDest?: string): Promise<[TransactionData, YieldTokenBaseInfo]>;
+    validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string): Promise<TransactionError[]>;
+    handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    handleYieldCancelUnstake(params: StakeCancelWithdrawalParams): Promise<TransactionData>;
+    handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
+}