@subwallet/extension-base 0.8.4-0 → 1.0.1

package/koni/api/staking/bonding/utils.d.ts

@@ -0,0 +1,142 @@
+/// <reference types="bn.js" />
+import { NominationInfo, NominatorMetadata, StakingType, UnstakingInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateInflationParams } from '@subwallet/extension-base/services/chain-service/constants';
+import { BN } from '@polkadot/util';
+export interface PalletNominationPoolsPoolMember {
+    poolId: number;
+    points: number;
+    lasRecordedRewardCounter: number;
+    unbondingEras: Record<string, number>;
+}
+export interface PalletDappsStakingDappInfo {
+    address: string;
+    name: string;
+    gitHubUrl: string;
+    tags: string[];
+    url: string;
+    imagesUrl: string[];
+}
+export interface PalletDappsStakingUnlockingChunk {
+    amount: number;
+    unlockEra: number;
+}
+export interface PalletDappsStakingAccountLedger {
+    locked: number;
+    unbondingInfo: {
+        unlockingChunks: PalletDappsStakingUnlockingChunk[];
+    };
+}
+export interface BlockHeader {
+    parentHash: string;
+    number: number;
+    stateRoot: string;
+    extrinsicsRoot: string;
+}
+export interface ParachainStakingStakeOption {
+    owner: string;
+    amount: number;
+}
+export interface ParachainStakingCandidateMetadata {
+    bond: number;
+    delegationCount: number;
+    totalCounted: number;
+    lowestTopDelegationAmount: number;
+    status: any | 'Active';
+}
+export declare enum PalletParachainStakingRequestType {
+    REVOKE = "revoke",
+    DECREASE = "decrease",
+    BOND_LESS = "bondLess"
+}
+export interface PalletParachainStakingDelegationRequestsScheduledRequest {
+    delegator: string;
+    whenExecutable: number;
+    action: Record<PalletParachainStakingRequestType, number>;
+}
+export interface PalletParachainStakingDelegationInfo {
+    owner: string;
+    amount: number;
+}
+export interface PalletParachainStakingDelegator {
+    id: string;
+    delegations: PalletParachainStakingDelegationInfo[];
+    total: number;
+    lessTotal: number;
+    status: number;
+}
+export interface PalletIdentityRegistration {
+    judgements: any[];
+    deposit: number;
+    info: {
+        display: {
+            Raw: string;
+        };
+        web: {
+            Raw: string;
+        };
+        twitter: {
+            Raw: string;
+        };
+        riot: {
+            Raw: string;
+        };
+    };
+}
+export interface ValidatorExtraInfo {
+    commission: string;
+    blocked: false;
+    identity?: string;
+    isVerified: boolean;
+}
+export interface Unlocking {
+    remainingEras: BN;
+    value: BN;
+}
+export declare function transformPoolName(input: string): string;
+export declare function parseIdentity(identityInfo: PalletIdentityRegistration | null): string | undefined;
+export declare function getInflationParams(networkKey: string): _SubstrateInflationParams;
+export declare function calcInflationUniformEraPayout(totalIssuance: BN, yearlyInflationInTokens: number): number;
+export declare function calcInflationRewardCurve(minInflation: number, stakedFraction: number, idealStake: number, idealInterest: number, falloff: number): number;
+export declare function calculateInflation(totalEraStake: BN, totalIssuance: BN, numAuctions: number, networkKey: string): number;
+export declare function calculateChainStakedReturn(inflation: number, totalEraStake: BN, totalIssuance: BN, networkKey: string): number;
+export declare function calculateAlephZeroValidatorReturn(chainStakedReturn: number, commission: number): number;
+export declare function calculateValidatorStakedReturn(chainStakedReturn: number, totalValidatorStake: BN, avgStake: BN, commission: number): number;
+export declare function getCommission(commissionString: string): number;
+export interface InflationConfig {
+    expect: {
+        min: string;
+        ideal: string;
+        max: string;
+    };
+    annual: {
+        min: string;
+        ideal: string;
+        max: string;
+    };
+    round: {
+        min: string;
+        ideal: string;
+        max: string;
+    };
+}
+export declare function getParaCurrentInflation(totalStaked: number, inflationConfig: InflationConfig): number;
+export interface TuringOptimalCompoundFormat {
+    period: string;
+    apy: string;
+}
+export declare function isShowNominationByValidator(chain: string): 'showByValue' | 'showByValidator' | 'mixed';
+export declare function getBondedValidators(nominations: NominationInfo[]): {
+    nominationCount: number;
+    bondedValidators: string[];
+};
+export declare function isUnstakeAll(selectedValidator: string, nominations: NominationInfo[], unstakeAmount: string): boolean;
+export declare enum StakingAction {
+    STAKE = "STAKE",
+    UNSTAKE = "UNSTAKE",
+    WITHDRAW = "WITHDRAW",
+    CLAIM_REWARD = "CLAIM_REWARD",
+    CANCEL_UNSTAKE = "CANCEL_UNSTAKE"
+}
+export declare function getStakingAvailableActions(nominatorMetadata: NominatorMetadata): StakingAction[];
+export declare function isActionFromValidator(stakingType: StakingType, chain: string): boolean;
+export declare function getWithdrawalInfo(nominatorMetadata: NominatorMetadata): UnstakingInfo | undefined;

package/koni/api/staking/bonding/utils.js

@@ -0,0 +1,198 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { StakingType, UnstakingStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { _KNOWN_CHAIN_INFLATION_PARAMS, _STAKING_CHAIN_GROUP, _SUBSTRATE_DEFAULT_INFLATION_PARAMS } from '@subwallet/extension-base/services/chain-service/constants';
+import { parseRawNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import { BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_THOUSAND, BN_ZERO } from '@polkadot/util';
+export let PalletParachainStakingRequestType;
+(function (PalletParachainStakingRequestType) {
+  PalletParachainStakingRequestType["REVOKE"] = "revoke";
+  PalletParachainStakingRequestType["DECREASE"] = "decrease";
+  PalletParachainStakingRequestType["BOND_LESS"] = "bondLess";
+})(PalletParachainStakingRequestType || (PalletParachainStakingRequestType = {}));
+export function transformPoolName(input) {
+  return input.replace(/[^\x20-\x7E]/g, '');
+}
+export function parseIdentity(identityInfo) {
+  let identity;
+  if (identityInfo !== null) {
+    var _identityInfo$info, _identityInfo$info$di, _identityInfo$info2, _identityInfo$info2$w, _identityInfo$info3, _identityInfo$info3$r, _identityInfo$info4, _identityInfo$info4$t;
+    const displayName = identityInfo === null || identityInfo === void 0 ? void 0 : (_identityInfo$info = identityInfo.info) === null || _identityInfo$info === void 0 ? void 0 : (_identityInfo$info$di = _identityInfo$info.display) === null || _identityInfo$info$di === void 0 ? void 0 : _identityInfo$info$di.Raw;
+    const web = identityInfo === null || identityInfo === void 0 ? void 0 : (_identityInfo$info2 = identityInfo.info) === null || _identityInfo$info2 === void 0 ? void 0 : (_identityInfo$info2$w = _identityInfo$info2.web) === null || _identityInfo$info2$w === void 0 ? void 0 : _identityInfo$info2$w.Raw;
+    const riot = identityInfo === null || identityInfo === void 0 ? void 0 : (_identityInfo$info3 = identityInfo.info) === null || _identityInfo$info3 === void 0 ? void 0 : (_identityInfo$info3$r = _identityInfo$info3.riot) === null || _identityInfo$info3$r === void 0 ? void 0 : _identityInfo$info3$r.Raw;
+    const twitter = identityInfo === null || identityInfo === void 0 ? void 0 : (_identityInfo$info4 = identityInfo.info) === null || _identityInfo$info4 === void 0 ? void 0 : (_identityInfo$info4$t = _identityInfo$info4.twitter) === null || _identityInfo$info4$t === void 0 ? void 0 : _identityInfo$info4$t.Raw;
+    if (displayName && !displayName.startsWith('0x')) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      identity = displayName;
+    } else {
+      identity = twitter || web || riot;
+    }
+  }
+  return identity;
+}
+export function getInflationParams(networkKey) {
+  return _KNOWN_CHAIN_INFLATION_PARAMS[networkKey] || _SUBSTRATE_DEFAULT_INFLATION_PARAMS;
+}
+export function calcInflationUniformEraPayout(totalIssuance, yearlyInflationInTokens) {
+  const totalIssuanceInTokens = totalIssuance.div(BN_BILLION).div(BN_THOUSAND).toNumber();
+  return totalIssuanceInTokens === 0 ? 0.0 : yearlyInflationInTokens / totalIssuanceInTokens;
+}
+export function calcInflationRewardCurve(minInflation, stakedFraction, idealStake, idealInterest, falloff) {
+  return minInflation + (stakedFraction <= idealStake ? stakedFraction * (idealInterest - minInflation / idealStake) : (idealInterest * idealStake - minInflation) * Math.pow(2, (idealStake - stakedFraction) / falloff));
+}
+export function calculateInflation(totalEraStake, totalIssuance, numAuctions, networkKey) {
+  const inflationParams = getInflationParams(networkKey);
+  const {
+    auctionAdjust,
+    auctionMax,
+    falloff,
+    maxInflation,
+    minInflation,
+    stakeTarget
+  } = inflationParams;
+  const idealStake = stakeTarget - Math.min(auctionMax, numAuctions) * auctionAdjust;
+  const idealInterest = maxInflation / idealStake;
+  const stakedFraction = totalEraStake.mul(BN_MILLION).div(totalIssuance).toNumber() / BN_MILLION.toNumber();
+  if (_STAKING_CHAIN_GROUP.aleph.includes(networkKey)) {
+    if (inflationParams.yearlyInflationInTokens) {
+      return 100 * calcInflationUniformEraPayout(totalIssuance, inflationParams.yearlyInflationInTokens);
+    } else {
+      return 100 * calcInflationRewardCurve(minInflation, stakedFraction, idealStake, idealInterest, falloff);
+    }
+  } else {
+    return 100 * (minInflation + (stakedFraction <= idealStake ? stakedFraction * (idealInterest - minInflation / idealStake) : (idealInterest * idealStake - minInflation) * Math.pow(2, (idealStake - stakedFraction) / falloff)));
+  }
+}
+export function calculateChainStakedReturn(inflation, totalEraStake, totalIssuance, networkKey) {
+  const stakedFraction = totalEraStake.mul(BN_MILLION).div(totalIssuance).toNumber() / BN_MILLION.toNumber();
+  let stakedReturn = inflation / stakedFraction;
+  if (_STAKING_CHAIN_GROUP.aleph.includes(networkKey)) {
+    stakedReturn *= 0.9; // 10% goes to treasury
+  }
+
+  return stakedReturn;
+}
+export function calculateAlephZeroValidatorReturn(chainStakedReturn, commission) {
+  return chainStakedReturn * (100 - commission) / 100;
+}
+export function calculateValidatorStakedReturn(chainStakedReturn, totalValidatorStake, avgStake, commission) {
+  const bnAdjusted = avgStake.mul(BN_HUNDRED).div(totalValidatorStake);
+  const adjusted = bnAdjusted.toNumber() * chainStakedReturn;
+  const stakedReturn = (adjusted > Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : adjusted) / 100;
+  return stakedReturn * (100 - commission) / 100; // Deduct commission
+}
+
+export function getCommission(commissionString) {
+  return parseFloat(commissionString.split('%')[0]); // Example: 12%
+}
+
+export function getParaCurrentInflation(totalStaked, inflationConfig) {
+  // read more at https://hackmd.io/@sbAqOuXkRvyiZPOB3Ryn6Q/Sypr3ZJh5
+  const expectMin = parseRawNumber(inflationConfig.expect.min);
+  const expectMax = parseRawNumber(inflationConfig.expect.max);
+  if (totalStaked < expectMin) {
+    const inflationString = inflationConfig.annual.min.split('%')[0];
+    return parseFloat(inflationString);
+  } else if (totalStaked > expectMax) {
+    const inflationString = inflationConfig.annual.max.split('%')[0];
+    return parseFloat(inflationString);
+  }
+  const inflationString = inflationConfig.annual.ideal.split('%')[0];
+  return parseFloat(inflationString);
+}
+// validations and check conditions
+export function isShowNominationByValidator(chain) {
+  if (_STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return 'showByValue';
+  } else if (_STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return 'mixed';
+  } else if (_STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return 'showByValidator';
+  }
+  return 'showByValue';
+}
+export function getBondedValidators(nominations) {
+  const bondedValidators = [];
+  let nominationCount = 0;
+  for (const nomination of nominations) {
+    const bnActiveStake = new BN(nomination.activeStake);
+    if (bnActiveStake.gt(BN_ZERO)) {
+      nominationCount += 1;
+      bondedValidators.push(reformatAddress(nomination.validatorAddress, 0));
+    }
+  }
+  return {
+    nominationCount,
+    bondedValidators
+  };
+}
+export function isUnstakeAll(selectedValidator, nominations, unstakeAmount) {
+  let isUnstakeAll = false;
+  for (const nomination of nominations) {
+    if (nomination.validatorAddress === selectedValidator) {
+      if (unstakeAmount === nomination.activeStake) {
+        isUnstakeAll = true;
+      }
+      break;
+    }
+  }
+  return isUnstakeAll;
+}
+export let StakingAction;
+(function (StakingAction) {
+  StakingAction["STAKE"] = "STAKE";
+  StakingAction["UNSTAKE"] = "UNSTAKE";
+  StakingAction["WITHDRAW"] = "WITHDRAW";
+  StakingAction["CLAIM_REWARD"] = "CLAIM_REWARD";
+  StakingAction["CANCEL_UNSTAKE"] = "CANCEL_UNSTAKE";
+})(StakingAction || (StakingAction = {}));
+export function getStakingAvailableActions(nominatorMetadata) {
+  const result = [StakingAction.STAKE];
+  const bnActiveStake = new BN(nominatorMetadata.activeStake);
+  if (nominatorMetadata.activeStake && bnActiveStake.gt(BN_ZERO)) {
+    result.push(StakingAction.UNSTAKE);
+    const isChainAllowClaimReward = _STAKING_CHAIN_GROUP.amplitude.includes(nominatorMetadata.chain) || _STAKING_CHAIN_GROUP.astar.includes(nominatorMetadata.chain);
+    if (nominatorMetadata.type === StakingType.POOLED || isChainAllowClaimReward) {
+      result.push(StakingAction.CLAIM_REWARD);
+    }
+  }
+  if (nominatorMetadata.unstakings.length > 0) {
+    result.push(StakingAction.CANCEL_UNSTAKE);
+    let hasClaimable = false;
+    for (const unstaking of nominatorMetadata.unstakings) {
+      if (unstaking.status === UnstakingStatus.CLAIMABLE) {
+        hasClaimable = true;
+        break;
+      }
+    }
+    if (hasClaimable) {
+      result.push(StakingAction.WITHDRAW);
+    }
+  }
+  return result;
+}
+export function isActionFromValidator(stakingType, chain) {
+  if (stakingType === StakingType.POOLED) {
+    return false;
+  }
+  if (_STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return true;
+  } else if (_STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return true;
+  } else if (_STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return true;
+  }
+  return false;
+}
+export function getWithdrawalInfo(nominatorMetadata) {
+  const unstakings = nominatorMetadata.unstakings;
+  let result;
+  for (const unstaking of unstakings) {
+    if (unstaking.status === UnstakingStatus.CLAIMABLE) {
+      result = unstaking; // only get the first withdrawal
+      break;
+    }
+  }
+  return result;
+}

package/koni/api/staking/config.d.ts

@@ -0,0 +1,3 @@
+export declare const SUBSQUID_ENDPOINTS: Record<string, string>;
+export declare const INDEXER_SUPPORTED_STAKING_CHAINS: string[];
+export declare const SUBQUERY_ENDPOINTS: Record<string, string>;

package/koni/api/staking/config.js

@@ -0,0 +1,38 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+export const SUBSQUID_ENDPOINTS = {
+  [COMMON_CHAIN_SLUGS.KUSAMA]: 'https://squid.subsquid.io/kusama-explorer/graphql',
+  [COMMON_CHAIN_SLUGS.POLKADOT]: 'https://squid.subsquid.io/polkadot-explorer/graphql',
+  [COMMON_CHAIN_SLUGS.ASTAR]: 'https://squid.subsquid.io/astar-explorer/graphql',
+  [COMMON_CHAIN_SLUGS.MOONRIVER]: 'https://squid.subsquid.io/moonriver-explorer/graphql',
+  [COMMON_CHAIN_SLUGS.MOONBEAM]: 'https://squid.subsquid.io/moonbeam-explorer/graphql'
+};
+export const INDEXER_SUPPORTED_STAKING_CHAINS = [COMMON_CHAIN_SLUGS.POLKADOT, COMMON_CHAIN_SLUGS.KUSAMA, COMMON_CHAIN_SLUGS.ASTAR, COMMON_CHAIN_SLUGS.MOONRIVER, COMMON_CHAIN_SLUGS.MOONBEAM];
+export const SUBQUERY_ENDPOINTS = {
+  polkadot: 'https://api.subquery.network/sq/nova-wallet/nova-westend',
+  kusama: 'https://api.subquery.network/sq/nova-wallet/nova-kusama',
+  westend: 'https://api.subquery.network/sq/nova-wallet/nova-westend',
+  picasso: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-picasso',
+  calamari: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-calamari',
+  khala: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-khala',
+  parallel: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-parallel',
+  bifrost: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-bifrost',
+  clover: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-clover',
+  basilisk: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-basilisk',
+  acala: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-acala',
+  astar: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-astar',
+  karura: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-karura',
+  altair: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-altair',
+  kilt: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-kilt',
+  robonomics: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-robonomics',
+  statemint: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-statemint',
+  quartz: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-quartz',
+  zeigeist: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-zeitgeist',
+  shiden: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-shiden',
+  statemine: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-statemine',
+  moonbeam: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-moonbeam',
+  moonriver: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-moonriver',
+  pioneer: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-bit-country'
+};

package/koni/api/staking/index.d.ts

@@ -0,0 +1,6 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { StakingItem, StakingRewardItem } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function stakingOnChainApi(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, callback: (networkKey: string, rs: StakingItem) => void, chainInfoMap: Record<string, _ChainInfo>): () => void;
+export declare function getNominationStakingRewardData(addresses: string[], chainInfoMap: Record<string, _ChainInfo>): Promise<StakingRewardItem[]>;
+export declare function getPoolingStakingRewardData(addresses: string[], networkMap: Record<string, _ChainInfo>, dotSamaApiMap: Record<string, _SubstrateApi>): Promise<StakingRewardItem[]>;

package/koni/api/staking/index.js

@@ -0,0 +1,67 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { getAmplitudeStakingOnChain, getAstarStakingOnChain, getParaStakingOnChain } from '@subwallet/extension-base/koni/api/staking/paraChain';
+import { getNominationPoolReward, getRelayPoolingOnChain, getRelayStakingOnChain } from '@subwallet/extension-base/koni/api/staking/relayChain';
+import { getAllSubsquidStaking } from '@subwallet/extension-base/koni/api/staking/subsquidStaking';
+import { _PURE_EVM_CHAINS, _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _isChainEvmCompatible, _isChainSupportSubstrateStaking } from '@subwallet/extension-base/services/chain-service/utils';
+import { categoryAddresses } from '@subwallet/extension-base/utils';
+export function stakingOnChainApi(addresses, substrateApiMap, callback, chainInfoMap) {
+  const filteredApiMap = [];
+  const [substrateAddresses, evmAddresses] = categoryAddresses(addresses);
+  Object.entries(chainInfoMap).forEach(([networkKey, chainInfo]) => {
+    if (_PURE_EVM_CHAINS.indexOf(networkKey) < 0 && _isChainSupportSubstrateStaking(chainInfo)) {
+      filteredApiMap.push({
+        chain: networkKey,
+        api: substrateApiMap[networkKey]
+      });
+    }
+  });
+  const unsubList = [];
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  filteredApiMap.forEach(async ({
+    api: apiPromise,
+    chain
+  }) => {
+    const parentApi = await apiPromise.isReady;
+    const useAddresses = _isChainEvmCompatible(chainInfoMap[chain]) ? evmAddresses : substrateAddresses;
+    if (_STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+      const unsub = await getAmplitudeStakingOnChain(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    } else if (_STAKING_CHAIN_GROUP.astar.includes(chain)) {
+      const unsub = await getAstarStakingOnChain(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    } else if (_STAKING_CHAIN_GROUP.para.includes(chain)) {
+      const unsub = await getParaStakingOnChain(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    } else if (_STAKING_CHAIN_GROUP.relay.includes(chain)) {
+      const unsub = await getRelayStakingOnChain(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    }
+    if (_STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
+      const unsub = await getRelayPoolingOnChain(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    }
+  });
+  return () => {
+    unsubList.forEach(unsub => {
+      unsub && unsub();
+    });
+  };
+}
+export async function getNominationStakingRewardData(addresses, chainInfoMap) {
+  // might retrieve from other sources
+  return await getAllSubsquidStaking(addresses, chainInfoMap);
+}
+export async function getPoolingStakingRewardData(addresses, networkMap, dotSamaApiMap) {
+  const activeNetworks = [];
+  Object.keys(networkMap).forEach(key => {
+    activeNetworks.push(key);
+  });
+  if (activeNetworks.length === 0) {
+    return [];
+  }
+  return await getNominationPoolReward(addresses, networkMap, dotSamaApiMap);
+}

package/koni/api/staking/paraChain.d.ts

@@ -0,0 +1,7 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { StakingItem, StakingRewardItem } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function getAmplitudeStakingOnChain(parentApi: _SubstrateApi, useAddresses: string[], networks: Record<string, _ChainInfo>, chain: string, callback: (networkKey: string, rs: StakingItem) => void): import("@polkadot/api-base/types").UnsubscribePromise;
+export declare function getAmplitudeUnclaimedStakingReward(substrateApiMap: Record<string, _SubstrateApi>, addresses: string[], networks: Record<string, _ChainInfo>, chains: string[]): Promise<StakingRewardItem[]>;
+export declare function getParaStakingOnChain(parentApi: _SubstrateApi, useAddresses: string[], networks: Record<string, _ChainInfo>, chain: string, callback: (networkKey: string, rs: StakingItem) => void): import("@polkadot/api-base/types").UnsubscribePromise;
+export declare function getAstarStakingOnChain(parentApi: _SubstrateApi, useAddresses: string[], networks: Record<string, _ChainInfo>, chain: string, callback: (networkKey: string, rs: StakingItem) => void): import("@polkadot/api-base/types").UnsubscribePromise;