@subwallet/extension-base 1.0.2-1b → 1.0.2-3

package/background/KoniTypes.d.ts

@@ -2,15 +2,14 @@
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { AuthUrls, Resolver } from '@subwallet/extension-base/background/handlers/State';
-import { AccountAuthType, AccountJson, AuthorizeRequest, ConfirmationRequestBase, RequestAccountList, RequestAccountSubscribe, RequestAuthorizeCancel, RequestAuthorizeReject, RequestAuthorizeSubscribe, RequestAuthorizeTab, RequestCurrentAccountAddress, ResponseAuthorizeList, ResponseJsonGetAccountInfo, SeedLengths } from '@subwallet/extension-base/background/types';
+import { AccountAuthType, AccountJson, AddressJson, AuthorizeRequest, ConfirmationRequestBase, RequestAccountList, RequestAccountSubscribe, RequestAuthorizeCancel, RequestAuthorizeReject, RequestAuthorizeSubscribe, RequestAuthorizeTab, RequestCurrentAccountAddress, ResponseAuthorizeList, ResponseJsonGetAccountInfo, SeedLengths } from '@subwallet/extension-base/background/types';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { _ChainState, _EvmApi, _NetworkUpsertParams, _SubstrateApi, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse } from '@subwallet/extension-base/services/chain-service/types';
 import { SWTransactionResponse, SWTransactionResult } from '@subwallet/extension-base/services/transaction-service/types';
 import { InjectedAccount, MetadataDefBase } from '@subwallet/extension-inject/types';
 import { KeyringPair$Json, KeyringPair$Meta } from '@subwallet/keyring/types';
-import { SingleAddress } from '@subwallet/ui-keyring/observable/types';
 import { KeyringOptions } from '@subwallet/ui-keyring/options/types';
-import { KeyringPairs$Json } from '@subwallet/ui-keyring/types';
+import { KeyringAddress, KeyringPairs$Json } from '@subwallet/ui-keyring/types';
 import Web3 from 'web3';
 import { RequestArguments, TransactionConfig } from 'web3-core';
 import { JsonRpcPayload, JsonRpcResponse } from 'web3-core-helpers';
@@ -439,7 +438,8 @@ export declare enum StakingTxErrorType {
     EXCEED_MAX_NOMINATIONS = "EXCEED_MAX_NOMINATIONS",
     EXIST_UNSTAKING_REQUEST = "EXIST_UNSTAKING_REQUEST",
     INVALID_ACTIVE_STAKE = "INVALID_ACTIVE_STAKE",
-    EXCEED_MAX_UNSTAKING = "EXCEED_MAX_UNSTAKING"
+    EXCEED_MAX_UNSTAKING = "EXCEED_MAX_UNSTAKING",
+    INACTIVE_NOMINATION_POOL = "INACTIVE_NOMINATION_POOL"
 }
 export declare enum TransferTxErrorType {
     NOT_ENOUGH_VALUE = "NOT_ENOUGH_VALUE",
@@ -628,6 +628,16 @@ export interface ResponseAccountCreateWithSecretKey {
     errors: AccountExternalError[];
     success: boolean;
 }
+export interface AddressBookInfo {
+    addresses: AddressJson[];
+}
+export interface RequestEditContactAccount {
+    address: string;
+    meta: KeyringPair$Meta;
+}
+export interface RequestDeleteContactAccount {
+    address: string;
+}
 export declare enum ExternalRequestPromiseStatus {
     PENDING = 0,
     REJECTED = 1,
@@ -749,6 +759,13 @@ export interface RequestFreeBalance {
     networkKey: string;
     token?: string;
 }
+export interface RequestMaxTransferable {
+    address: string;
+    networkKey: string;
+    token?: string;
+    isXcmTransfer?: boolean;
+    destChain: string;
+}
 export interface RequestTransferCheckReferenceCount {
     address: string;
     networkKey: string;
@@ -880,6 +897,7 @@ export interface AddNetworkExternalRequest {
     requestId: string;
 }
 export interface AddTokenRequestExternal {
+    slug?: string;
     contractAddress: string;
     originChain: string;
     type: _AssetType;
@@ -1229,6 +1247,10 @@ export interface KeyringState {
     hasMasterPassword: boolean;
     isLocked: boolean;
 }
+export interface AddressBookState {
+    contacts: AddressJson[];
+    recent: AddressJson[];
+}
 export interface RequestChangeMasterPassword {
     oldPassword?: string;
     newPassword: string;
@@ -1415,10 +1437,13 @@ export interface KoniRequestSignatures {
     'pri(accounts.checkPublicAndSecretKey)': [RequestCheckPublicAndSecretKey, ResponseCheckPublicAndSecretKey];
     'pri(accounts.subscribeWithCurrentAddress)': [RequestAccountSubscribe, AccountsWithCurrentAddress, AccountsWithCurrentAddress];
     'pri(accounts.subscribeAccountsInputAddress)': [RequestAccountSubscribe, string, OptionInputAddress];
-    'pri(accounts.saveRecent)': [RequestSaveRecentAccount, SingleAddress];
+    'pri(accounts.saveRecent)': [RequestSaveRecentAccount, KeyringAddress];
     'pri(accounts.get.meta)': [RequestAccountMeta, ResponseAccountMeta];
     'pri(accounts.updateCurrentAddress)': [string, boolean];
     'pri(currentAccount.saveAddress)': [RequestCurrentAccountAddress, CurrentAccountInfo];
+    'pri(accounts.subscribeAddresses)': [null, AddressBookInfo, AddressBookInfo];
+    'pri(accounts.editContact)': [RequestEditContactAccount, boolean];
+    'pri(accounts.deleteContact)': [RequestDeleteContactAccount, boolean];
     'pri(settings.changeBalancesVisibility)': [null, boolean, UiSettings];
     'pri(settings.subscribe)': [null, UiSettings, UiSettings];
     'pri(settings.saveAccountAllLogo)': [string, boolean, UiSettings];
@@ -1429,6 +1454,7 @@ export interface KoniRequestSignatures {
     'pri(transfer.checkReferenceCount)': [RequestTransferCheckReferenceCount, boolean];
     'pri(transfer.checkSupporting)': [RequestTransferCheckSupporting, SupportTransferResponse];
     'pri(transfer.getExistentialDeposit)': [RequestTransferExistentialDeposit, string];
+    'pri(transfer.getMaxTransferable)': [RequestMaxTransferable, AmountData];
     'pri(subscription.cancel)': [string, boolean];
     'pri(freeBalance.get)': [RequestFreeBalance, AmountData];
     'pri(freeBalance.subscribe)': [RequestFreeBalance, AmountData, AmountData];

package/background/KoniTypes.js

@@ -109,6 +109,7 @@ export let StakingTxErrorType;
   StakingTxErrorType["EXIST_UNSTAKING_REQUEST"] = "EXIST_UNSTAKING_REQUEST";
   StakingTxErrorType["INVALID_ACTIVE_STAKE"] = "INVALID_ACTIVE_STAKE";
   StakingTxErrorType["EXCEED_MAX_UNSTAKING"] = "EXCEED_MAX_UNSTAKING";
+  StakingTxErrorType["INACTIVE_NOMINATION_POOL"] = "INACTIVE_NOMINATION_POOL";
 })(StakingTxErrorType || (StakingTxErrorType = {}));
 export let TransferTxErrorType;
 (function (TransferTxErrorType) {
@@ -130,7 +131,7 @@ export let BalanceErrorType;
 })(BalanceErrorType || (BalanceErrorType = {}));
 export let ProviderErrorType;
 
-// Manage account
+/// Manage account
 // Export private key
 (function (ProviderErrorType) {
   ProviderErrorType["CHAIN_DISCONNECTED"] = "CHAIN_DISCONNECTED";

package/background/errors/TransactionError.js

@@ -69,6 +69,10 @@ const defaultErrorMap = {
   [StakingTxErrorType.EXCEED_MAX_UNSTAKING]: {
     message: 'Exceed max unstaking',
     code: undefined
+  },
+  [StakingTxErrorType.INACTIVE_NOMINATION_POOL]: {
+    message: 'This nomination pool is not active',
+    code: undefined
   }
 };
 export class TransactionError extends SWError {

package/background/types.d.ts

@@ -22,8 +22,14 @@ declare type NullKeys<T> = {
     [K in keyof T]: IsNull<T, K>;
 }[keyof T];
 export declare type SeedLengths = 12 | 24;
-export interface AccountJson extends KeyringPair$Meta {
+export interface AbstractAddressJson extends KeyringPair$Meta {
     address: string;
+    type?: KeypairType;
+    whenCreated?: number;
+    name?: string;
+    originGenesisHash?: string | null;
+}
+export interface AccountJson extends AbstractAddressJson {
     accountIndex?: number;
     addressOffset?: number;
     genesisHash?: string | null;
@@ -33,12 +39,11 @@ export interface AccountJson extends KeyringPair$Meta {
     isMasterAccount?: boolean;
     isMasterPassword?: boolean;
     isReadOnly?: boolean;
-    name?: string;
-    originGenesisHash?: string | null;
     parentAddress?: string;
     suri?: string;
-    type?: KeypairType;
-    whenCreated?: number;
+}
+export interface AddressJson extends AbstractAddressJson {
+    isRecent?: boolean;
 }
 export interface AccountsWithCurrentAddress {
     accounts: AccountJson[];

package/cjs/background/KoniTypes.js

@@ -115,6 +115,7 @@ exports.StakingTxErrorType = StakingTxErrorType;
   StakingTxErrorType["EXIST_UNSTAKING_REQUEST"] = "EXIST_UNSTAKING_REQUEST";
   StakingTxErrorType["INVALID_ACTIVE_STAKE"] = "INVALID_ACTIVE_STAKE";
   StakingTxErrorType["EXCEED_MAX_UNSTAKING"] = "EXCEED_MAX_UNSTAKING";
+  StakingTxErrorType["INACTIVE_NOMINATION_POOL"] = "INACTIVE_NOMINATION_POOL";
 })(StakingTxErrorType || (exports.StakingTxErrorType = StakingTxErrorType = {}));
 let TransferTxErrorType;
 exports.TransferTxErrorType = TransferTxErrorType;
@@ -137,7 +138,7 @@ exports.BalanceErrorType = BalanceErrorType;
   BalanceErrorType["TIMEOUT"] = "TIMEOUT";
   BalanceErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
 })(BalanceErrorType || (exports.BalanceErrorType = BalanceErrorType = {}));
-let ProviderErrorType; // Manage account
+let ProviderErrorType; /// Manage account
 // Export private key
 exports.ProviderErrorType = ProviderErrorType;
 (function (ProviderErrorType) {

package/cjs/background/errors/TransactionError.js

@@ -74,6 +74,10 @@ const defaultErrorMap = {
   [_KoniTypes.StakingTxErrorType.EXCEED_MAX_UNSTAKING]: {
     message: 'Exceed max unstaking',
     code: undefined
+  },
+  [_KoniTypes.StakingTxErrorType.INACTIVE_NOMINATION_POOL]: {
+    message: 'This nomination pool is not active',
+    code: undefined
   }
 };
 class TransactionError extends _SWError.SWError {

package/cjs/koni/api/dotsama/transfer.js

@@ -67,15 +67,17 @@ async function checkSupportTransfer(networkKey, tokenInfo, substrateApiMap, chai
       supportTransferAll: true
     };
   }
+
+  // TODO: need review
   if (_constants._TRANSFER_CHAIN_GROUP.acala.includes(networkKey) && !(0, _utils2._isNativeToken)(tokenInfo) && isTxCurrenciesSupported) {
     result.supportTransfer = true;
-    result.supportTransferAll = false;
+    result.supportTransferAll = true;
   } else if (_constants._TRANSFER_CHAIN_GROUP.kintsugi.includes(networkKey) && !(0, _utils2._isNativeToken)(tokenInfo) && isTxTokensSupported) {
     result.supportTransfer = true;
     result.supportTransferAll = true;
   } else if (_constants._TRANSFER_CHAIN_GROUP.genshiro.includes(networkKey) && !(0, _utils2._isNativeToken)(tokenInfo) && isTxEqBalancesSupported) {
     result.supportTransfer = true;
-    result.supportTransferAll = false;
+    result.supportTransferAll = true;
   } else if (_constants._TRANSFER_CHAIN_GROUP.crab.includes(networkKey) && _constants._BALANCE_TOKEN_GROUP.crab.includes(tokenInfo.symbol)) {
     result.supportTransfer = true;
     result.supportTransferAll = true;
@@ -123,11 +125,7 @@ const createTransferExtrinsic = async _ref => {
     }, to, value, {});
     transferAmount = value;
   } else if (_constants._TRANSFER_CHAIN_GROUP.acala.includes(networkKey) && !(0, _utils2._isNativeToken)(tokenInfo) && isTxCurrenciesSupported) {
-    if (transferAll) {
-      // currently Acala, Karura, Acala testnet do not have transfer all method for sub token
-    } else if (value) {
-      transfer = api.tx.currencies.transfer(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo), value);
-    }
+    transfer = api.tx.currencies.transfer(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo), value);
   } else if (_constants._TRANSFER_CHAIN_GROUP.kintsugi.includes(networkKey) && !(0, _utils2._isNativeToken)(tokenInfo) && isTxTokensSupported) {
     if (transferAll) {
       transfer = api.tx.tokens.transferAll(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo), false);
@@ -135,11 +133,7 @@ const createTransferExtrinsic = async _ref => {
       transfer = api.tx.tokens.transfer(to, (0, _utils2._getTokenOnChainInfo)(tokenInfo), new _util.BN(value));
     }
   } else if (_constants._TRANSFER_CHAIN_GROUP.genshiro.includes(networkKey) && !(0, _utils2._isNativeToken)(tokenInfo) && isTxEqBalancesSupported) {
-    if (transferAll) {
-      // currently genshiro_testnet, genshiro, equilibrium_parachain do not have transfer all method for tokens
-    } else if (value) {
-      transfer = api.tx.eqBalances.transfer((0, _utils2._getTokenOnChainAssetId)(tokenInfo), to, value);
-    }
+    transfer = api.tx.eqBalances.transfer([(0, _utils2._getTokenOnChainAssetId)(tokenInfo)], to, value);
   } else if (!(0, _utils2._isNativeToken)(tokenInfo) && (_constants._TRANSFER_CHAIN_GROUP.crab.includes(networkKey) || _constants._BALANCE_TOKEN_GROUP.crab.includes(tokenInfo.symbol))) {
     if (transferAll) {
       transfer = api.tx.kton.transferAll(to, false);

package/cjs/koni/api/nft/acala_nft/index.js

@@ -79,21 +79,21 @@ class AcalaNftApi extends _nft.BaseNftApi {
     return (await this.substrateApi.api.query.ormlNFT.tokens(assetId.classId, assetId.tokenId)).toHuman();
   }
   async handleNft(address, params) {
-    // const start = performance.now();
     const assetIds = await this.getNfts([address]);
     try {
       if (!assetIds || assetIds.length === 0) {
+        params.cleanUpNfts(this.chain, address, [], [], true);
         return;
       }
-      const collectionNftIds = {};
+      const collectionIds = [];
+      const nftIds = [];
       await Promise.all(assetIds.map(async assetId => {
         const parsedClassId = this.parseTokenId(assetId.classId);
         const parsedTokenId = this.parseTokenId(assetId.tokenId);
-        if (collectionNftIds[parsedClassId]) {
-          collectionNftIds[parsedClassId].push(parsedTokenId);
-        } else {
-          collectionNftIds[parsedClassId] = [parsedTokenId];
+        if (!collectionIds.includes(parsedClassId)) {
+          collectionIds.push(parsedClassId);
         }
+        nftIds.push(parsedTokenId);
         const [tokenInfo, collectionMeta] = await Promise.all([this.getTokenDetails(assetId), this.getCollectionDetails(parseInt(parsedClassId))]);
         const parsedNft = {
           id: parsedTokenId,
@@ -118,10 +118,7 @@ class AcalaNftApi extends _nft.BaseNftApi {
         params.updateItem(this.chain, parsedNft, address);
         params.updateCollection(this.chain, parsedCollection);
       }));
-      Object.entries(collectionNftIds).forEach(_ref => {
-        let [collectionId, nftIds] = _ref;
-        params.cleanUpNfts(this.chain, address, collectionId, nftIds);
-      });
+      params.cleanUpNfts(this.chain, address, collectionIds, nftIds);
     } catch (e) {
       console.error('Failed to fetch acala nft', e);
     }

package/cjs/koni/api/nft/bit.country/index.js

@@ -80,17 +80,18 @@ class BitCountryNftApi extends _nft.BaseNftApi {
     const assetIds = await this.getNfts([address]);
     try {
       if (!assetIds || assetIds.length === 0) {
+        params.cleanUpNfts(this.chain, address, [], [], true);
         return;
       }
-      const collectionNftIds = {};
+      const collectionIds = [];
+      const nftIds = [];
       await Promise.all(assetIds.map(async assetId => {
         const parsedClassId = this.parseTokenId(assetId.classId);
         const parsedTokenId = this.parseTokenId(assetId.tokenId);
-        if (collectionNftIds[parsedClassId]) {
-          collectionNftIds[parsedClassId].push(parsedTokenId);
-        } else {
-          collectionNftIds[parsedClassId] = [parsedTokenId];
+        if (!collectionIds.includes(parsedClassId)) {
+          collectionIds.push(parsedClassId);
         }
+        nftIds.push(parsedTokenId);
         const [tokenInfo, collectionMeta] = await Promise.all([this.getTokenDetails(assetId), this.getCollectionDetails(parsedClassId)]);
         const parsedNft = {
           id: parsedTokenId,
@@ -115,10 +116,7 @@ class BitCountryNftApi extends _nft.BaseNftApi {
         params.updateItem(this.chain, parsedNft, address);
         params.updateCollection(this.chain, parsedCollection);
       }));
-      Object.entries(collectionNftIds).forEach(_ref => {
-        let [collectionId, nftIds] = _ref;
-        params.cleanUpNfts(this.chain, address, collectionId, nftIds);
-      });
+      params.cleanUpNfts(this.chain, address, collectionIds, nftIds);
     } catch (e) {
       console.error('Failed to fetch bit.country nft', e);
     }

package/cjs/koni/api/nft/evm_nft/index.js

@@ -92,6 +92,7 @@ class EvmNftApi extends _nft.BaseNftApi {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
       const balance = await contract.methods.balanceOf(address).call();
       if (Number(balance) === 0) {
+        nftParams.cleanUpNfts(this.chain, address, [smartContract], []);
         return;
       }
       const itemIndexes = [];
@@ -149,7 +150,7 @@ class EvmNftApi extends _nft.BaseNftApi {
       nftParams.updateCollection(this.chain, nftCollection);
       Object.entries(nftOwnerMap).forEach(_ref => {
         let [owner, nftIds] = _ref;
-        nftParams.cleanUpNfts(this.chain, owner, smartContract, nftIds);
+        nftParams.cleanUpNfts(this.chain, owner, [smartContract], nftIds);
       });
     }
   }

package/cjs/koni/api/nft/karura_nft/index.js

@@ -90,17 +90,18 @@ class KaruraNftApi extends _nft.BaseNftApi {
     const assetIds = await this.getNfts([address]);
     try {
       if (!assetIds || assetIds.length === 0) {
+        params.cleanUpNfts(this.chain, address, [], [], true);
         return;
       }
-      const collectionNftIds = {};
+      const collectionIds = [];
+      const nftIds = [];
       await Promise.all(assetIds.map(async assetId => {
         const parsedClassId = this.parseTokenId(assetId.classId);
         const parsedTokenId = this.parseTokenId(assetId.tokenId);
-        if (collectionNftIds[parsedClassId]) {
-          collectionNftIds[parsedClassId].push(parsedTokenId);
-        } else {
-          collectionNftIds[parsedClassId] = [parsedTokenId];
+        if (!collectionIds.includes(parsedClassId)) {
+          collectionIds.push(parsedClassId);
         }
+        nftIds.push(parsedTokenId);
         const [tokenInfo, collectionMeta] = await Promise.all([this.getTokenDetails(assetId), this.getCollectionDetails(parseInt(parsedClassId))]);
         const parsedNft = {
           id: parsedTokenId,
@@ -123,10 +124,7 @@ class KaruraNftApi extends _nft.BaseNftApi {
         params.updateItem(this.chain, parsedNft, address);
         params.updateCollection(this.chain, parsedCollection);
       }));
-      Object.entries(collectionNftIds).forEach(_ref2 => {
-        let [collectionId, nftIds] = _ref2;
-        params.cleanUpNfts(this.chain, address, collectionId, nftIds);
-      });
+      params.cleanUpNfts(this.chain, address, collectionIds, nftIds);
     } catch (e) {
       console.error('Failed to fetch karura nft', e);
     }

package/cjs/koni/api/nft/rmrk_nft/index.js

@@ -139,6 +139,7 @@ class RmrkNftApi extends _nft.BaseNftApi {
       const kusamaAddress = (0, _utils.reformatAddress)(address, 2);
       allNfts = await this.getAllByAccount(kusamaAddress);
       if (allNfts.length <= 0) {
+        params.cleanUpNfts(this.chain, address, [], [], true);
         return;
       }
       const collectionInfoUrl = [];
@@ -246,8 +247,10 @@ class RmrkNftApi extends _nft.BaseNftApi {
           }
         });
         params.updateCollection(this.chain, parsedCollection);
-        params.cleanUpNfts(this.chain, address, item.collectionId, nftIds);
       });
+      const allCollectionIds = allCollections.map(item => item.collectionId);
+      const allNftIds = allNfts.map(nft => nft === null || nft === void 0 ? void 0 : nft.id);
+      params.cleanUpNfts(this.chain, address, allCollectionIds, allNftIds);
     } catch (e) {
       console.error('Failed to fetch rmrk nft', e);
     }

package/cjs/koni/api/nft/statemine_nft/index.js

@@ -93,17 +93,18 @@ class StatemineNftApi extends _nft.BaseNftApi {
     const assetIds = await this.getNfts([address]);
     try {
       if (!assetIds || assetIds.length === 0) {
+        params.cleanUpNfts(this.chain, address, [], [], true);
         return;
       }
-      const collectionNftIds = {};
+      const collectionIds = [];
+      const nftIds = [];
       await Promise.all(assetIds.map(async assetId => {
         const parsedClassId = this.parseTokenId(assetId.classId);
         const parsedTokenId = this.parseTokenId(assetId.tokenId);
-        if (collectionNftIds[parsedClassId]) {
-          collectionNftIds[parsedClassId].push(parsedTokenId);
-        } else {
-          collectionNftIds[parsedClassId] = [parsedTokenId];
+        if (!collectionIds.includes(parsedClassId)) {
+          collectionIds.push(parsedClassId);
         }
+        nftIds.push(parsedTokenId);
         const [tokenInfo, collectionMeta] = await Promise.all([this.getTokenDetails(assetId), this.getCollectionDetail(parseInt(parsedClassId))]);
         const parsedNft = {
           id: parsedTokenId,
@@ -123,10 +124,7 @@ class StatemineNftApi extends _nft.BaseNftApi {
         };
         params.updateCollection(this.chain, parsedCollection);
       }));
-      Object.entries(collectionNftIds).forEach(_ref => {
-        let [collectionId, nftIds] = _ref;
-        params.cleanUpNfts(this.chain, address, collectionId, nftIds);
-      });
+      params.cleanUpNfts(this.chain, address, collectionIds, nftIds);
     } catch (e) {
       console.error('Failed to fetch statemine nft', e);
     }

package/cjs/koni/api/nft/unique_nft/index.js

@@ -141,7 +141,8 @@ class UniqueNftApi extends _nft.BaseNftApi {
           }
         }
       }));
-      const nftCollectionMap = {};
+      const collectionIds = [];
+      let allNftIds = [];
       await Promise.all(allCollectionId.map(async collectionId => {
         const collectionIdStr = collectionId.toString();
 
@@ -149,7 +150,8 @@ class UniqueNftApi extends _nft.BaseNftApi {
         const collection = (await this.substrateApi.api.query.nft.collectionById(collectionId)).toJSON();
         collectionMap[collectionIdStr] = collection;
         const nftIds = Object.entries(nftMap).filter(item => item[1] === collectionId).map(item => item[0]);
-        nftCollectionMap[collectionIdStr] = nftIds;
+        collectionIds.push(collectionIdStr);
+        allNftIds = allNftIds.concat(nftIds);
         const parsedCollection = {
           collectionId: collectionIdStr,
           chain: this.chain
@@ -179,10 +181,7 @@ class UniqueNftApi extends _nft.BaseNftApi {
           }
         }));
       }));
-      Object.entries(nftCollectionMap).forEach(_ref => {
-        let [collectionId, nftIds] = _ref;
-        params.cleanUpNfts(this.chain, address, collectionId, nftIds);
-      });
+      params.cleanUpNfts(this.chain, address, collectionIds, allNftIds);
     } catch (e) {
       console.error('Failed to fetch unique nft', e);
     }

package/cjs/koni/api/nft/wasm_nft/index.js

@@ -267,6 +267,7 @@ class WasmNftApi extends _nft.BaseNftApi {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       const balance = _balance.output ? balanceJson.ok || balanceJson.Ok : '0';
       if (parseInt(balance) === 0) {
+        nftParams.cleanUpNfts(this.chain, address, [smartContract], []);
         return;
       }
       const itemIndexes = [];
@@ -323,7 +324,7 @@ class WasmNftApi extends _nft.BaseNftApi {
       nftParams.updateCollection(this.chain, nftCollection);
       Object.entries(nftOwnerMap).forEach(_ref => {
         let [owner, nftIds] = _ref;
-        nftParams.cleanUpNfts(this.chain, owner, smartContract, nftIds);
+        nftParams.cleanUpNfts(this.chain, owner, [smartContract], nftIds);
       });
     }
   }

package/cjs/koni/api/staking/bonding/relayChain.js

@@ -49,6 +49,9 @@ function validatePoolBondingCondition(chainInfo, amount, selectedPool, address,
   const errors = [];
   let bnTotalStake = new _util.BN(amount);
   const bnMinStake = new _util.BN(chainStakingMetadata.minPoolBonding || '0');
+  if (selectedPool.state !== 'Open') {
+    errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.INACTIVE_NOMINATION_POOL));
+  }
   if (nominatorMetadata) {
     const bnCurrentActiveStake = new _util.BN(nominatorMetadata.activeStake);
     bnTotalStake = bnTotalStake.add(bnCurrentActiveStake);

package/cjs/koni/background/cron.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.KoniCron = void 0;
 var _constants = require("@subwallet/extension-base/constants");
-var _types = require("@subwallet/extension-base/services/chain-service/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _rxjs = require("rxjs");
@@ -85,23 +84,7 @@ class KoniCron {
     if (this.status === 'running') {
       return;
     }
-    this.logger.log('Starting cron jobs');
     const currentAccountInfo = this.state.keyringService.currentAccount;
-    if (!(currentAccountInfo !== null && currentAccountInfo !== void 0 && currentAccountInfo.address)) {
-      return;
-    }
-    if (Object.keys(this.state.getSubstrateApiMap()).length !== 0 || Object.keys(this.state.getEvmApiMap()).length !== 0) {
-      this.resetNft(currentAccountInfo.address);
-      this.addCron('refreshNft', this.refreshNft(currentAccountInfo.address, this.state.getApiMap(), this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), _constants.CRON_REFRESH_NFT_INTERVAL);
-      this.addCron('checkStatusApiMap', this.updateApiMapStatus, _constants.CRON_GET_API_MAP_STATUS);
-      this.addCron('recoverApiMap', this.recoverApiMap, _constants.CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, false);
-      this.addCron('refreshStakingReward', this.refreshStakingReward(currentAccountInfo.address), _constants.CRON_REFRESH_STAKING_REWARD_INTERVAL);
-      this.addCron('refreshPoolingStakingReward', this.refreshStakingRewardFastInterval(currentAccountInfo.address), _constants.CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
-      this.addCron('updateChainStakingMetadata', this.updateChainStakingMetadata(this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap()), _constants.CRON_REFRESH_CHAIN_STAKING_METADATA);
-      this.addCron('updateNominatorMetadata', this.updateNominatorMetadata(currentAccountInfo.address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap()), _constants.CRON_REFRESH_CHAIN_NOMINATOR_METADATA);
-    } else {
-      this.setStakingRewardReady();
-    }
     const commonReloadEvents = ['account.add', 'account.remove', 'account.updateCurrent', 'chain.add', 'asset.updateState'];
     this.eventHandler = (events, eventTypes) => {
       var _serviceInfo$currentA;
@@ -147,7 +130,7 @@ class KoniCron {
       if (this.checkNetworkAvailable(serviceInfo)) {
         // only add cron job if there's at least 1 active network
         (commonReload || needUpdateNft) && this.addCron('refreshNft', this.refreshNft(address, serviceInfo.chainApiMap, this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), _constants.CRON_REFRESH_NFT_INTERVAL);
-        chainUpdated && this.addCron('checkStatusApiMap', this.updateApiMapStatus, _constants.CRON_GET_API_MAP_STATUS);
+        chainUpdated && this.addCron('checkStatusApiMap', this.updateApiMapStatus, _constants.CRON_GET_API_MAP_STATUS, false);
         chainUpdated && this.addCron('recoverApiMap', this.recoverApiMap, _constants.CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, false);
         (commonReload || needUpdateStaking || stakingSubmitted) && this.addCron('refreshStakingReward', this.refreshStakingReward(address), _constants.CRON_REFRESH_STAKING_REWARD_INTERVAL);
         (commonReload || needUpdateStaking || stakingSubmitted) && this.addCron('refreshPoolingStakingReward', this.refreshStakingRewardFastInterval(address), _constants.CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
@@ -158,6 +141,22 @@ class KoniCron {
       }
     };
     this.state.eventService.onLazy(this.eventHandler);
+    if (!(currentAccountInfo !== null && currentAccountInfo !== void 0 && currentAccountInfo.address)) {
+      return;
+    }
+    this.logger.log('Starting cron jobs');
+    if (Object.keys(this.state.getSubstrateApiMap()).length !== 0 || Object.keys(this.state.getEvmApiMap()).length !== 0) {
+      this.resetNft(currentAccountInfo.address);
+      this.addCron('refreshNft', this.refreshNft(currentAccountInfo.address, this.state.getApiMap(), this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), _constants.CRON_REFRESH_NFT_INTERVAL);
+      this.addCron('checkStatusApiMap', this.updateApiMapStatus, _constants.CRON_GET_API_MAP_STATUS);
+      this.addCron('recoverApiMap', this.recoverApiMap, _constants.CRON_AUTO_RECOVER_DOTSAMA_INTERVAL, false);
+      this.addCron('refreshStakingReward', this.refreshStakingReward(currentAccountInfo.address), _constants.CRON_REFRESH_STAKING_REWARD_INTERVAL);
+      this.addCron('refreshPoolingStakingReward', this.refreshStakingRewardFastInterval(currentAccountInfo.address), _constants.CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL);
+      this.addCron('updateChainStakingMetadata', this.updateChainStakingMetadata(this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap()), _constants.CRON_REFRESH_CHAIN_STAKING_METADATA);
+      this.addCron('updateNominatorMetadata', this.updateNominatorMetadata(currentAccountInfo.address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap()), _constants.CRON_REFRESH_CHAIN_NOMINATOR_METADATA);
+    } else {
+      this.setStakingRewardReady();
+    }
     this.status = 'running';
   };
   stop = () => {
@@ -179,35 +178,43 @@ class KoniCron {
     this.status = 'stopped';
   };
   updateApiMapStatus = () => {
-    const apiMap = this.state.getApiMap();
-    const networkMap = this.state.getChainStateMap();
-    for (const [key, substrateApi] of Object.entries(apiMap.substrate)) {
-      let status = _types._ChainConnectionStatus.CONNECTING;
-      if (substrateApi.isApiConnected) {
-        status = _types._ChainConnectionStatus.CONNECTED;
-      }
-      if (!networkMap[key].connectionStatus) {
-        this.state.updateChainConnectionStatus(key, status);
-      } else if (networkMap[key].connectionStatus && networkMap[key].connectionStatus !== status) {
-        this.state.updateChainConnectionStatus(key, status);
-      }
-    }
-    for (const [key, evmApi] of Object.entries(apiMap.evm)) {
-      evmApi.api.eth.net.isListening().then(() => {
-        if (!networkMap[key].connectionStatus) {
-          this.state.updateChainConnectionStatus(key, _types._ChainConnectionStatus.CONNECTED);
-        } else if (networkMap[key].connectionStatus && networkMap[key].connectionStatus !== _types._ChainConnectionStatus.CONNECTED) {
-          this.state.updateChainConnectionStatus(key, _types._ChainConnectionStatus.CONNECTED);
-        }
-      }).catch(() => {
-        if (!networkMap[key].connectionStatus) {
-          this.state.updateChainConnectionStatus(key, _types._ChainConnectionStatus.CONNECTING);
-        } else if (networkMap[key].connectionStatus && networkMap[key].connectionStatus !== _types._ChainConnectionStatus.CONNECTING) {
-          this.state.updateChainConnectionStatus(key, _types._ChainConnectionStatus.CONNECTING);
-        }
-      });
-    }
+    this.state.chainService.updateApiMapStatus().catch(console.error);
+    // const apiMap = this.state.getApiMap();
+    // const networkMap = this.state.getChainStateMap();
+    //
+    // for (const [key, substrateApi] of Object.entries(apiMap.substrate)) {
+    //   let status: _ChainConnectionStatus = _ChainConnectionStatus.CONNECTING;
+    //
+    //   if (substrateApi.isApiConnected) {
+    //     status = _ChainConnectionStatus.CONNECTED;
+    //   }
+    //
+    //   if (!networkMap[key].connectionStatus) {
+    //     this.state.updateChainConnectionStatus(key, status);
+    //   } else if (networkMap[key].connectionStatus && networkMap[key].connectionStatus !== status) {
+    //     this.state.updateChainConnectionStatus(key, status);
+    //   }
+    // }
+    //
+    // for (const [key, evmApi] of Object.entries(apiMap.evm)) {
+    //   evmApi.api.eth.net.isListening()
+    //     .then(() => {
+    //       if (!networkMap[key].connectionStatus) {
+    //         this.state.updateChainConnectionStatus(key, _ChainConnectionStatus.CONNECTED);
+    //       } else if (networkMap[key].connectionStatus && networkMap[key].connectionStatus !== _ChainConnectionStatus.CONNECTED) {
+    //         this.state.updateChainConnectionStatus(key, _ChainConnectionStatus.CONNECTED);
+    //       }
+    //     })
+    //     .catch(() => {
+    //       if (!networkMap[key].connectionStatus) {
+    //         this.state.updateChainConnectionStatus(key, _ChainConnectionStatus.CONNECTING);
+    //       } else if (networkMap[key].connectionStatus && networkMap[key].connectionStatus !== _ChainConnectionStatus.CONNECTING) {
+    //         this.state.updateChainConnectionStatus(key, _ChainConnectionStatus.CONNECTING);
+    //       }
+    //     });
+    // }
   };
+
   recoverApiMap = () => {
     var _this$subscriptions;
     const apiMap = this.state.getApiMap();