@subwallet/extension-base 1.0.6-2 → 1.0.7-1

package/koni/api/staking/paraChain.js

@@ -1,98 +1,143 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { APIItemState, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { APIItemState, StakingStatus, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { subscribeAmplitudeNominatorMetadata } from '@subwallet/extension-base/koni/api/staking/bonding/amplitude';
+import { subscribeAstarNominatorMetadata } from '@subwallet/extension-base/koni/api/staking/bonding/astar';
+import { subscribeParaChainNominatorMetadata } from '@subwallet/extension-base/koni/api/staking/bonding/paraChain';
 import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import { reformatAddress } from '@subwallet/extension-base/utils';
 import { BN, BN_ZERO } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
-function getSingleStakingAmplitude(parentApi, address, networks, chain, callback) {
-  return parentApi.api.queryMulti([[parentApi.api.query.parachainStaking.delegatorState, address], [parentApi.api.query.parachainStaking.unstaking, address]], ([_delegatorState, _unstaking]) => {
-    const _stakingData = _delegatorState.toHuman();
-    const _unstakingData = _unstaking.toHuman();
-    let _activeBalance = '0';
-    if (_stakingData !== null) {
-      _activeBalance = _stakingData.amount || _stakingData.total;
-      _activeBalance = _activeBalance.replaceAll(',', '');
-    }
-    const activeBalance = new BN(_activeBalance);
-    let unstakingBalance = BN_ZERO;
-    if (_unstakingData !== null) {
-      Object.values(_unstakingData).forEach(_unstakingAmount => {
-        const bnUnstakingAmount = new BN(_unstakingAmount.replaceAll(',', ''));
-        unstakingBalance = unstakingBalance.add(bnUnstakingAmount);
-      });
-    }
-    const totalBalance = activeBalance.add(unstakingBalance);
+function getSingleStakingAmplitude(substrateApi, address, chainInfoMap, chain, stakingCallback, nominatorStateCallback) {
+  return substrateApi.api.queryMulti([[substrateApi.api.query.parachainStaking.delegatorState, address], [substrateApi.api.query.parachainStaking.unstaking, address]], async ([_delegatorState, _unstaking]) => {
+    const delegatorState = _delegatorState.toPrimitive();
+    const unstakingInfo = _unstaking.toPrimitive();
     const {
       symbol
-    } = _getChainNativeTokenBasicInfo(networks[chain]);
-    const stakingItem = {
-      name: networks[chain].name,
-      chain: chain,
-      balance: totalBalance.toString(),
-      activeBalance: activeBalance.toString(),
-      unlockingBalance: unstakingBalance.toString(),
-      nativeToken: symbol,
-      unit: symbol,
-      state: APIItemState.READY,
-      type: StakingType.NOMINATED,
-      address
-    };
-    callback(chain, stakingItem);
+    } = _getChainNativeTokenBasicInfo(chainInfoMap[chain]);
+    const owner = reformatAddress(address, 42);
+    if (!delegatorState && !unstakingInfo) {
+      stakingCallback(chain, {
+        name: chainInfoMap[chain].name,
+        chain: chain,
+        balance: '0',
+        activeBalance: '0',
+        unlockingBalance: '0',
+        nativeToken: symbol,
+        unit: symbol,
+        state: APIItemState.READY,
+        type: StakingType.NOMINATED,
+        address: owner
+      });
+      nominatorStateCallback({
+        chain,
+        type: StakingType.NOMINATED,
+        address: owner,
+        status: StakingStatus.NOT_STAKING,
+        activeStake: '0',
+        nominations: [],
+        unstakings: []
+      });
+    } else {
+      const activeBalance = delegatorState ? new BN(delegatorState.amount.toString()) : BN_ZERO;
+      let unstakingBalance = BN_ZERO;
+      if (unstakingInfo) {
+        Object.values(unstakingInfo).forEach(unstakingAmount => {
+          const bnUnstakingAmount = new BN(unstakingAmount.toString());
+          unstakingBalance = unstakingBalance.add(bnUnstakingAmount);
+        });
+      }
+      const totalBalance = activeBalance.add(unstakingBalance);
+      const stakingItem = {
+        name: chainInfoMap[chain].name,
+        chain: chain,
+        balance: totalBalance.toString(),
+        activeBalance: activeBalance.toString(),
+        unlockingBalance: unstakingBalance.toString(),
+        nativeToken: symbol,
+        unit: symbol,
+        state: APIItemState.READY,
+        type: StakingType.NOMINATED,
+        address: owner
+      };
+      stakingCallback(chain, stakingItem);
+      const nominatorMetadata = await subscribeAmplitudeNominatorMetadata(chainInfoMap[chain], owner, substrateApi, delegatorState, unstakingInfo);
+      nominatorStateCallback(nominatorMetadata);
+    }
   });
 }
-function getMultiStakingAmplitude(parentApi, useAddresses, networks, chain, callback) {
-  return parentApi.api.query.parachainStaking.delegatorState.multi(useAddresses, async ledgers => {
+function getMultiStakingAmplitude(substrateApi, useAddresses, chainInfoMap, chain, stakingCallback, nominatorStateCallback) {
+  return substrateApi.api.query.parachainStaking.delegatorState.multi(useAddresses, async ledgers => {
     if (ledgers) {
-      const _unstakingStates = await parentApi.api.query.parachainStaking.unstaking.multi(useAddresses);
-      for (let i = 0; i < ledgers.length; i++) {
-        const ledger = ledgers[i];
-        const _unstakingData = _unstakingStates[i].toHuman();
+      const {
+        symbol
+      } = _getChainNativeTokenBasicInfo(chainInfoMap[chain]);
+      const _unstakingStates = await substrateApi.api.query.parachainStaking.unstaking.multi(useAddresses);
+      await Promise.all(ledgers.map(async (_delegatorState, i) => {
         const owner = reformatAddress(useAddresses[i], 42);
-        const _stakingData = ledger.toHuman();
-        let _activeBalance = '0';
-        if (_stakingData !== null) {
-          _activeBalance = _stakingData.amount || _stakingData.total;
-          _activeBalance = _activeBalance.replaceAll(',', '');
-        }
-        const activeBalance = new BN(_activeBalance);
-        let unstakingBalance = BN_ZERO;
-        if (_unstakingData !== null) {
-          Object.values(_unstakingData).forEach(_unstakingAmount => {
-            const bnUnstakingAmount = new BN(_unstakingAmount.replaceAll(',', ''));
-            unstakingBalance = unstakingBalance.add(bnUnstakingAmount);
+        const delegatorState = _delegatorState.toPrimitive();
+        const unstakingInfo = _unstakingStates[i].toPrimitive();
+        if (!delegatorState && !unstakingInfo) {
+          stakingCallback(chain, {
+            name: chainInfoMap[chain].name,
+            chain: chain,
+            balance: '0',
+            activeBalance: '0',
+            unlockingBalance: '0',
+            nativeToken: symbol,
+            unit: symbol,
+            state: APIItemState.READY,
+            type: StakingType.NOMINATED,
+            address: owner
           });
+          nominatorStateCallback({
+            chain,
+            type: StakingType.NOMINATED,
+            address: owner,
+            status: StakingStatus.NOT_STAKING,
+            activeStake: '0',
+            nominations: [],
+            unstakings: []
+          });
+        } else {
+          const activeBalance = delegatorState ? new BN(delegatorState.amount.toString()) : BN_ZERO;
+          let unstakingBalance = BN_ZERO;
+          if (unstakingInfo) {
+            Object.values(unstakingInfo).forEach(unstakingAmount => {
+              const bnUnstakingAmount = new BN(unstakingAmount.toString());
+              unstakingBalance = unstakingBalance.add(bnUnstakingAmount);
+            });
+          }
+          const totalBalance = activeBalance.add(unstakingBalance);
+          const stakingItem = {
+            name: chainInfoMap[chain].name,
+            chain: chain,
+            balance: totalBalance.toString(),
+            activeBalance: activeBalance.toString(),
+            unlockingBalance: unstakingBalance.toString(),
+            nativeToken: symbol,
+            unit: symbol,
+            state: APIItemState.READY,
+            type: StakingType.NOMINATED,
+            address: owner
+          };
+          stakingCallback(chain, stakingItem);
+          const nominatorMetadata = await subscribeAmplitudeNominatorMetadata(chainInfoMap[chain], owner, substrateApi, delegatorState, unstakingInfo);
+          nominatorStateCallback(nominatorMetadata);
         }
-        const totalBalance = activeBalance.add(unstakingBalance);
-        const {
-          symbol
-        } = _getChainNativeTokenBasicInfo(networks[chain]);
-        const stakingItem = {
-          name: networks[chain].name,
-          chain: chain,
-          balance: totalBalance.toString(),
-          activeBalance: activeBalance.toString(),
-          unlockingBalance: unstakingBalance.toString(),
-          nativeToken: symbol,
-          unit: symbol,
-          state: APIItemState.READY,
-          type: StakingType.NOMINATED,
-          address: owner
-        };
-        callback(chain, stakingItem);
-      }
+      }));
     }
   });
 }
-export function getAmplitudeStakingOnChain(parentApi, useAddresses, networks, chain, callback) {
+export function getAmplitudeStakingOnChain(parentApi, useAddresses, networks, chain, callback, nominatorStateCallback) {
   if (useAddresses.length === 1) {
-    return getSingleStakingAmplitude(parentApi, useAddresses[0], networks, chain, callback);
+    return getSingleStakingAmplitude(parentApi, useAddresses[0], networks, chain, callback, nominatorStateCallback);
   }
-  return getMultiStakingAmplitude(parentApi, useAddresses, networks, chain, callback);
+  return getMultiStakingAmplitude(parentApi, useAddresses, networks, chain, callback, nominatorStateCallback);
 }
-export async function getAmplitudeUnclaimedStakingReward(substrateApiMap, addresses, networks, chains) {
+export async function getAmplitudeUnclaimedStakingReward(substrateApiMap, addresses, networks, chains, callBack) {
   if (chains.length === 0) {
     return [];
   }
@@ -109,42 +154,37 @@ export async function getAmplitudeUnclaimedStakingReward(substrateApiMap, addres
       const apiProps = await substrateApiMap[chain].isReady;
       await Promise.all(useAddresses.map(async address => {
         const _unclaimedReward = await apiProps.api.query.parachainStaking.rewards(address);
-        const unclaimedReward = _unclaimedReward.toString();
-        const rewardItem = {
+        callBack({
           chain,
           name: networkInfo.name,
           state: APIItemState.READY,
           type: StakingType.NOMINATED,
           address: reformatAddress(address, 42),
-          unclaimedReward
-        };
-        unclaimedRewardList.push(rewardItem);
+          unclaimedReward: _unclaimedReward.toString()
+        });
       }));
     }
   }));
   return unclaimedRewardList;
 }
-export function getParaStakingOnChain(parentApi, useAddresses, networks, chain, callback) {
+export function getParaStakingOnChain(substrateApi, useAddresses, chainInfoMap, chain, stakingCallback, nominatorStateCallback) {
   const {
     symbol
-  } = _getChainNativeTokenBasicInfo(networks[chain]);
-  return parentApi.api.query.parachainStaking.delegatorState.multi(useAddresses, ledgers => {
+  } = _getChainNativeTokenBasicInfo(chainInfoMap[chain]);
+  return substrateApi.api.query.parachainStaking.delegatorState.multi(useAddresses, async ledgers => {
     if (ledgers) {
-      for (let i = 0; i < ledgers.length; i++) {
-        const ledger = ledgers[i];
+      await Promise.all(ledgers.map(async (_delegatorState, i) => {
+        const delegatorState = _delegatorState.toPrimitive();
         const owner = reformatAddress(useAddresses[i], 42);
-        const data = ledger.toHuman();
-        if (data !== null) {
-          let _totalBalance = data.total;
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          let _unlockingBalance = data.lessTotal ? data.lessTotal : data.requests.lessTotal;
-          _totalBalance = _totalBalance.replaceAll(',', '');
-          _unlockingBalance = _unlockingBalance.replaceAll(',', '');
-          const totalBalance = new BN(_totalBalance);
-          const unlockingBalance = new BN(_unlockingBalance);
+        if (delegatorState) {
+          const _totalBalance = delegatorState.total;
+          // let _unlockingBalance = delegatorState.lessTotal ? delegatorState.lessTotal : delegatorState.requests.lessTotal;
+          const _unlockingBalance = delegatorState.lessTotal;
+          const totalBalance = new BN(_totalBalance.toString());
+          const unlockingBalance = new BN(_unlockingBalance.toString());
           const activeBalance = totalBalance.sub(unlockingBalance);
-          const stakingItem = {
-            name: networks[chain].name,
+          stakingCallback(chain, {
+            name: chainInfoMap[chain].name,
             chain: chain,
             balance: totalBalance.toString(),
             activeBalance: activeBalance.toString(),
@@ -154,11 +194,12 @@ export function getParaStakingOnChain(parentApi, useAddresses, networks, chain,
             state: APIItemState.READY,
             type: StakingType.NOMINATED,
             address: owner
-          };
-          callback(chain, stakingItem);
+          });
+          const nominatorMetadata = await subscribeParaChainNominatorMetadata(chainInfoMap[chain], owner, substrateApi, delegatorState);
+          nominatorStateCallback(nominatorMetadata);
         } else {
-          const stakingItem = {
-            name: networks[chain].name,
+          stakingCallback(chain, {
+            name: chainInfoMap[chain].name,
             chain: chain,
             balance: '0',
             activeBalance: '0',
@@ -168,49 +209,78 @@ export function getParaStakingOnChain(parentApi, useAddresses, networks, chain,
             state: APIItemState.READY,
             type: StakingType.NOMINATED,
             address: owner
-          };
-          callback(chain, stakingItem);
+          });
+          nominatorStateCallback({
+            chain,
+            type: StakingType.NOMINATED,
+            address: owner,
+            status: StakingStatus.NOT_STAKING,
+            activeStake: '0',
+            nominations: [],
+            unstakings: []
+          });
         }
-      }
+      }));
     }
   });
 }
-export function getAstarStakingOnChain(parentApi, useAddresses, networks, chain, callback) {
+export function getAstarStakingOnChain(substrateApi, useAddresses, chainInfoMap, chain, stakingCallback, nominatorStateCallback) {
   const {
     symbol
-  } = _getChainNativeTokenBasicInfo(networks[chain]);
-  return parentApi.api.query.dappsStaking.ledger.multi(useAddresses, ledgers => {
+  } = _getChainNativeTokenBasicInfo(chainInfoMap[chain]);
+  return substrateApi.api.query.dappsStaking.ledger.multi(useAddresses, async ledgers => {
     if (ledgers) {
-      for (let i = 0; i < ledgers.length; i++) {
+      await Promise.all(ledgers.map(async (_ledger, i) => {
         let bnUnlockingBalance = BN_ZERO;
         const owner = reformatAddress(useAddresses[i], 42);
-        const ledger = ledgers[i];
-        const data = ledger.toHuman();
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        const unlockingChunks = data.unbondingInfo.unlockingChunks;
-        const _totalStake = data.locked;
-        for (const chunk of unlockingChunks) {
-          const bnChunk = new BN(chunk.amount.replaceAll(',', ''));
-          bnUnlockingBalance = bnUnlockingBalance.add(bnChunk);
+        const ledger = _ledger.toPrimitive();
+        if (ledger && ledger.locked > 0) {
+          const unlockingChunks = ledger.unbondingInfo.unlockingChunks;
+          const _totalStake = ledger.locked;
+          const bnTotalStake = new BN(_totalStake.toString());
+          for (const chunk of unlockingChunks) {
+            const bnChunk = new BN(chunk.amount.toString());
+            bnUnlockingBalance = bnUnlockingBalance.add(bnChunk);
+          }
+          const bnActiveStake = bnTotalStake.sub(bnUnlockingBalance);
+          stakingCallback(chain, {
+            name: chainInfoMap[chain].name,
+            chain: chain,
+            balance: bnTotalStake.toString(),
+            activeBalance: bnActiveStake.toString(),
+            unlockingBalance: bnUnlockingBalance.toString(),
+            nativeToken: symbol,
+            unit: symbol,
+            state: APIItemState.READY,
+            type: StakingType.NOMINATED,
+            address: owner
+          });
+          const nominatorMetadata = await subscribeAstarNominatorMetadata(chainInfoMap[chain], owner, substrateApi, ledger);
+          nominatorStateCallback(nominatorMetadata);
+        } else {
+          stakingCallback(chain, {
+            name: chainInfoMap[chain].name,
+            chain,
+            balance: '0',
+            activeBalance: '0',
+            unlockingBalance: '0',
+            nativeToken: symbol,
+            unit: symbol,
+            state: APIItemState.READY,
+            type: StakingType.NOMINATED,
+            address: owner
+          });
+          nominatorStateCallback({
+            chain,
+            type: StakingType.NOMINATED,
+            address: owner,
+            status: StakingStatus.NOT_STAKING,
+            activeStake: '0',
+            nominations: [],
+            unstakings: []
+          });
         }
-        const bnTotalStake = new BN(_totalStake.replaceAll(',', ''));
-        const bnActiveStake = bnTotalStake.sub(bnUnlockingBalance);
-        const stakingItem = {
-          name: networks[chain].name,
-          chain: chain,
-          balance: bnTotalStake.toString(),
-          activeBalance: bnActiveStake.toString(),
-          unlockingBalance: bnUnlockingBalance.toString(),
-          nativeToken: symbol,
-          unit: symbol,
-          state: APIItemState.READY,
-          type: StakingType.NOMINATED,
-          address: owner
-        };
-
-        // eslint-disable-next-line node/no-callback-literal
-        callback(chain, stakingItem);
-      }
+      }));
     }
   });
 }

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

@@ -1,6 +1,6 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
-import { StakingItem, StakingRewardItem } from '@subwallet/extension-base/background/KoniTypes';
+import { NominatorMetadata, StakingItem, StakingRewardItem } from '@subwallet/extension-base/background/KoniTypes';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-export declare function getRelayStakingOnChain(substrateApi: _SubstrateApi, useAddresses: string[], chainInfoMap: Record<string, _ChainInfo>, chain: string, callback: (networkKey: string, rs: StakingItem) => void): import("@polkadot/api-base/types").UnsubscribePromise;
-export declare function getRelayPoolingOnChain(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 getNominationPoolReward(addresses: string[], chainInfoMap: Record<string, _ChainInfo>, substrateApiMap: Record<string, _SubstrateApi>): Promise<StakingRewardItem[]>;
+export declare function getRelayStakingOnChain(substrateApi: _SubstrateApi, useAddresses: string[], chainInfoMap: Record<string, _ChainInfo>, chain: string, stakingCallback: (networkKey: string, rs: StakingItem) => void, nominatorStateCallback: (rs: NominatorMetadata) => void): import("@polkadot/api-base/types").UnsubscribePromise;
+export declare function getRelayPoolingOnChain(substrateApi: _SubstrateApi, useAddresses: string[], chainInfoMap: Record<string, _ChainInfo>, chain: string, stakingCallback: (networkKey: string, rs: StakingItem) => void, nominatorStateCallback: (rs: NominatorMetadata) => void): import("@polkadot/api-base/types").UnsubscribePromise;
+export declare function getNominationPoolReward(addresses: string[], chainInfoMap: Record<string, _ChainInfo>, substrateApiMap: Record<string, _SubstrateApi>, callBack: (rs: StakingRewardItem) => void): Promise<void>;

package/koni/api/staking/relayChain.js

@@ -1,98 +1,89 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { APIItemState, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { APIItemState, StakingStatus, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { subscribeRelayChainNominatorMetadata, subscribeRelayChainPoolMemberMetadata } from '@subwallet/extension-base/koni/api/staking/bonding/relayChain';
 import { _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import { reformatAddress } from '@subwallet/extension-base/utils';
 import { BN } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
-export function getRelayStakingOnChain(substrateApi, useAddresses, chainInfoMap, chain, callback) {
+export function getRelayStakingOnChain(substrateApi, useAddresses, chainInfoMap, chain, stakingCallback, nominatorStateCallback) {
   var _substrateApi$api$que;
   const {
     symbol
   } = _getChainNativeTokenBasicInfo(chainInfoMap[chain]);
-  return (_substrateApi$api$que = substrateApi.api.query.staking) === null || _substrateApi$api$que === void 0 ? void 0 : _substrateApi$api$que.ledger.multi(useAddresses, ledgers => {
-    let unit = '';
+  return (_substrateApi$api$que = substrateApi.api.query.staking) === null || _substrateApi$api$que === void 0 ? void 0 : _substrateApi$api$que.ledger.multi(useAddresses, async ledgers => {
     if (ledgers) {
-      for (let i = 0; i < ledgers.length; i++) {
-        const ledger = ledgers[i];
-        const owner = reformatAddress(useAddresses[i], 42) || undefined;
-        const data = ledger.toHuman();
-        if (data && data.active) {
-          const _totalBalance = data.total;
-          const _activeBalance = data.active;
-          let bnUnlockingBalance = new BN(0);
-          data.unlocking.forEach(({
-            value
-          }) => {
-            value = value.split(' ')[0];
-            const _unlockingBalance = value.replaceAll(',', '');
-            bnUnlockingBalance = bnUnlockingBalance.add(new BN(_unlockingBalance));
-          });
-          let amount = _totalBalance ? _totalBalance.split(' ')[0] : '';
-          amount = amount.replaceAll(',', '');
-          unit = _totalBalance ? _totalBalance.split(' ')[1] : '';
-          const bnTotalBalance = new BN(amount);
-          amount = _activeBalance ? _activeBalance.split(' ')[0] : '';
-          amount = amount.replaceAll(',', '');
-          unit = _activeBalance ? _activeBalance.split(' ')[1] : '';
-          const bnActiveBalance = new BN(amount);
-          const stakingItem = {
+      await Promise.all(ledgers.map(async (_ledger, i) => {
+        const owner = reformatAddress(useAddresses[i], 42);
+        const ledger = _ledger.toPrimitive();
+        if (ledger) {
+          const _totalBalance = ledger.total.toString();
+          const _activeBalance = ledger.active.toString();
+          const bnUnlockingBalance = new BN(_totalBalance).sub(new BN(_activeBalance));
+          stakingCallback(chain, {
             name: chainInfoMap[chain].name,
             chain: chain,
-            balance: bnTotalBalance.toString(),
-            activeBalance: bnActiveBalance.toString(),
+            balance: _totalBalance,
+            activeBalance: _activeBalance,
             unlockingBalance: bnUnlockingBalance.toString(),
             nativeToken: symbol,
-            unit: unit || symbol,
+            unit: symbol,
             state: APIItemState.READY,
             type: StakingType.NOMINATED,
             address: owner
-          };
-          callback(chain, stakingItem);
+          });
+          const nominatorMetadata = await subscribeRelayChainNominatorMetadata(chainInfoMap[chain], owner, substrateApi, ledger);
+          nominatorStateCallback(nominatorMetadata);
         } else {
-          const stakingItem = {
+          stakingCallback(chain, {
             name: chainInfoMap[chain].name,
             chain: chain,
             balance: '0',
             activeBalance: '0',
             unlockingBalance: '0',
             nativeToken: symbol,
-            unit: unit || symbol,
+            unit: symbol,
             state: APIItemState.READY,
             type: StakingType.NOMINATED,
             address: owner
-          };
-          callback(chain, stakingItem);
+          });
+          nominatorStateCallback({
+            chain,
+            type: StakingType.NOMINATED,
+            status: StakingStatus.NOT_STAKING,
+            address: owner,
+            activeStake: '0',
+            nominations: [],
+            unstakings: []
+          });
         }
-      }
+      }));
     }
   });
 }
-export function getRelayPoolingOnChain(parentApi, useAddresses, networks, chain, callback) {
-  var _parentApi$api$query, _parentApi$api$query$;
+export function getRelayPoolingOnChain(substrateApi, useAddresses, chainInfoMap, chain, stakingCallback, nominatorStateCallback) {
+  var _substrateApi$api$que2, _substrateApi$api$que3;
   const {
     symbol
-  } = _getChainNativeTokenBasicInfo(networks[chain]);
-  return (_parentApi$api$query = parentApi.api.query) === null || _parentApi$api$query === void 0 ? void 0 : (_parentApi$api$query$ = _parentApi$api$query.nominationPools) === null || _parentApi$api$query$ === void 0 ? void 0 : _parentApi$api$query$.poolMembers.multi(useAddresses, ledgers => {
+  } = _getChainNativeTokenBasicInfo(chainInfoMap[chain]);
+  return (_substrateApi$api$que2 = substrateApi.api.query) === null || _substrateApi$api$que2 === void 0 ? void 0 : (_substrateApi$api$que3 = _substrateApi$api$que2.nominationPools) === null || _substrateApi$api$que3 === void 0 ? void 0 : _substrateApi$api$que3.poolMembers.multi(useAddresses, async ledgers => {
     if (ledgers) {
-      for (let i = 0; i < ledgers.length; i++) {
-        const ledger = ledgers[i];
+      await Promise.all(ledgers.map(async (_poolMemberInfo, i) => {
+        const poolMemberInfo = _poolMemberInfo.toPrimitive();
         const owner = reformatAddress(useAddresses[i], 42);
-        const data = ledger.toHuman();
-        if (data !== null) {
-          const bondedBalance = data.points;
-          const unbondedBalance = data.unbondingEras;
+        if (poolMemberInfo) {
+          const bondedBalance = poolMemberInfo.points;
+          const unbondedBalance = poolMemberInfo.unbondingEras;
           let unlockingBalance = new BN(0);
-          let totalBalance = new BN(0);
-          Object.entries(unbondedBalance).forEach(([era, value]) => {
-            const bnUnbondedBalance = new BN(value.replaceAll(',', ''));
+          const bnBondedBalance = new BN(bondedBalance.toString());
+          Object.entries(unbondedBalance).forEach(([, value]) => {
+            const bnUnbondedBalance = new BN(value.toString());
             unlockingBalance = unlockingBalance.add(bnUnbondedBalance);
           });
-          const bnBondedBalance = new BN(bondedBalance.replaceAll(',', ''));
-          totalBalance = totalBalance.add(bnBondedBalance).add(unlockingBalance);
-          const stakingItem = {
-            name: networks[chain].name,
+          const totalBalance = bnBondedBalance.add(unlockingBalance);
+          stakingCallback(chain, {
+            name: chainInfoMap[chain].name,
             chain: chain,
             balance: totalBalance.toString(),
             activeBalance: bnBondedBalance.toString(),
@@ -102,11 +93,12 @@ export function getRelayPoolingOnChain(parentApi, useAddresses, networks, chain,
             state: APIItemState.READY,
             type: StakingType.POOLED,
             address: owner
-          };
-          callback(chain, stakingItem);
+          });
+          const nominatorMetadata = await subscribeRelayChainPoolMemberMetadata(chainInfoMap[chain], owner, substrateApi, poolMemberInfo);
+          nominatorStateCallback(nominatorMetadata);
         } else {
-          const stakingItem = {
-            name: networks[chain].name,
+          stakingCallback(chain, {
+            name: chainInfoMap[chain].name,
             chain: chain,
             balance: '0',
             activeBalance: '0',
@@ -116,14 +108,23 @@ export function getRelayPoolingOnChain(parentApi, useAddresses, networks, chain,
             state: APIItemState.READY,
             type: StakingType.POOLED,
             address: owner
-          };
-          callback(chain, stakingItem);
+          });
+          nominatorStateCallback({
+            chain,
+            type: StakingType.POOLED,
+            address: owner,
+            status: StakingStatus.NOT_STAKING,
+            activeStake: '0',
+            nominations: [],
+            // can only join 1 pool at a time
+            unstakings: []
+          });
         }
-      }
+      }));
     }
   });
 }
-export async function getNominationPoolReward(addresses, chainInfoMap, substrateApiMap) {
+export async function getNominationPoolReward(addresses, chainInfoMap, substrateApiMap, callBack) {
   const targetNetworks = [];
   const validAddresses = [];
   Object.keys(chainInfoMap).forEach(key => {
@@ -134,7 +135,6 @@ export async function getNominationPoolReward(addresses, chainInfoMap, substrate
       validAddresses.push(address);
     }
   });
-  const rewardList = [];
   try {
     await Promise.all(targetNetworks.map(async networkKey => {
       const substrateApi = await substrateApiMap[networkKey].isReady;
@@ -143,7 +143,7 @@ export async function getNominationPoolReward(addresses, chainInfoMap, substrate
           var _substrateApi$api$cal, _substrateApi$api$cal2;
           const _unclaimedReward = await ((_substrateApi$api$cal = substrateApi.api.call) === null || _substrateApi$api$cal === void 0 ? void 0 : (_substrateApi$api$cal2 = _substrateApi$api$cal.nominationPoolsApi) === null || _substrateApi$api$cal2 === void 0 ? void 0 : _substrateApi$api$cal2.pendingRewards(address));
           if (_unclaimedReward) {
-            rewardList.push({
+            callBack({
               address: address,
               chain: networkKey,
               unclaimedReward: _unclaimedReward.toString(),
@@ -156,7 +156,6 @@ export async function getNominationPoolReward(addresses, chainInfoMap, substrate
       }
     }));
   } catch (e) {
-    return rewardList;
+    console.debug(e);
   }
-  return rewardList;
 }

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

@@ -1,3 +1,3 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { StakingRewardItem } from '@subwallet/extension-base/background/KoniTypes';
-export declare const getAllSubsquidStaking: (accounts: string[], chainInfoMap: Record<string, _ChainInfo>) => Promise<StakingRewardItem[]>;
+export declare const getAllSubsquidStaking: (accounts: string[], chainInfoMap: Record<string, _ChainInfo>, callback: (rewardItem: StakingRewardItem) => void) => Promise<void>;