@subwallet/extension-base 1.3.67-0 → 1.3.68-0

package/cjs/services/nft-service/index.js

@@ -0,0 +1,173 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _types = require("@subwallet/chain-list/types");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _keyring = require("@subwallet/keyring");
+var _types2 = require("@subwallet/keyring/types");
+var _subwalletServicesSdk = _interopRequireDefault(require("@subwallet-monorepos/subwallet-services-sdk"));
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function mapSdkToNftItem(rawInstance, chain, collectionId, owner) {
+  var _rawInstance$token_ty, _rawInstance$token_ty2, _rawInstance$id;
+  const metadata = rawInstance.metadata || {};
+  const image = metadata.image || rawInstance.image_url || rawInstance.media_url || '';
+  const attributes = Array.isArray(metadata.attributes) ? metadata.attributes : [];
+  let rarity;
+  const properties = {};
+  for (const attr of attributes) {
+    try {
+      var _attr$trait_type;
+      const key = (_attr$trait_type = attr.trait_type) === null || _attr$trait_type === void 0 ? void 0 : _attr$trait_type.trim();
+      if (!key) {
+        continue;
+      }
+      let value = attr.value;
+      if (typeof value === 'string') {
+        const lower = value.toLowerCase();
+        if (lower === 'true') {
+          value = true;
+        } else if (lower === 'false') {
+          value = false;
+        }
+      }
+      properties[key] = value;
+      if (key.toLowerCase() === 'rarity') {
+        rarity = String(value);
+      }
+    } catch {}
+  }
+  const hasProperties = Object.keys(properties).length > 0;
+  const normalizedType = (_rawInstance$token_ty = rawInstance.token_type) === null || _rawInstance$token_ty === void 0 ? void 0 : (_rawInstance$token_ty2 = _rawInstance$token_ty.replace('-', '')) === null || _rawInstance$token_ty2 === void 0 ? void 0 : _rawInstance$token_ty2.toUpperCase();
+
+  // Only support ERC721
+  if (normalizedType !== 'ERC721') {
+    return null;
+  }
+  return {
+    id: (_rawInstance$id = rawInstance.id) === null || _rawInstance$id === void 0 ? void 0 : _rawInstance$id.toString(),
+    chain,
+    collectionId,
+    owner: rawInstance.owner || owner,
+    originAsset: undefined,
+    name: metadata.name || `#${rawInstance.id}`,
+    image: (0, _utils2.baseParseIPFSUrl)(image),
+    externalUrl: rawInstance.external_app_url || undefined,
+    rarity,
+    description: metadata.description || undefined,
+    properties: hasProperties ? properties : null,
+    type: normalizedType === 'ERC721' ? _types._AssetType.ERC721 : _types._AssetType.ERC721,
+    // currently only support ERC721
+    rmrk_ver: undefined,
+    onChainOption: undefined,
+    assetHubType: undefined
+  };
+}
+function mapSdkToCollection(raw, chain) {
+  var _raw$token_instances;
+  const token = raw.token || {};
+  return {
+    // must-have
+    collectionId: token.address_hash,
+    chain,
+    originAsset: undefined,
+    // optional
+    collectionName: token.name || token.symbol || 'Unknown Collection',
+    image: token.icon_url || undefined,
+    itemCount: Number(raw.amount) || ((_raw$token_instances = raw.token_instances) === null || _raw$token_instances === void 0 ? void 0 : _raw$token_instances.length) || 0,
+    externalUrl: undefined
+  };
+}
+class NftService {
+  inProgress = new Set();
+  constructor(state) {
+    this.state = state;
+  }
+  async fetchEvmCollectionsWithPreview(addresses) {
+    for (const address of addresses) {
+      const type = (0, _keyring.getKeypairTypeByAddress)(address);
+      const typeValid = [..._types2.EthereumKeypairTypes].includes(type);
+      if (typeValid) {
+        if (this.inProgress.has(address)) {
+          console.log(`[NftService] ${address} already running`);
+          continue;
+        }
+        this.inProgress.add(address);
+        try {
+          const nftDetectionApi = _subwalletServicesSdk.default.nftDetectionApi;
+          if (!(nftDetectionApi !== null && nftDetectionApi !== void 0 && nftDetectionApi.getEvmNftCollectionsByAddress)) {
+            console.warn('[NftService] NftDetectionApi not available');
+            continue;
+          }
+          const rawData = await nftDetectionApi.getEvmNftCollectionsByAddress(address);
+          const allItems = [];
+          const allCollections = [];
+          for (const [chain, collections] of Object.entries(rawData)) {
+            if (!Array.isArray(collections)) {
+              continue;
+            }
+            for (const col of collections) {
+              const mappedCollection = mapSdkToCollection(col, chain);
+              allCollections.push(mappedCollection);
+              if (Array.isArray(col.token_instances)) {
+                const items = col.token_instances.map(inst => mapSdkToNftItem(inst, chain, mappedCollection.collectionId, address)).filter(i => Boolean(i));
+                allItems.push(...items);
+              }
+            }
+          }
+          await this.state.handleDetectedNftCollections(allCollections);
+          await this.state.handleDetectedNfts(address, allItems);
+        } catch (err) {
+          console.warn(`[NftService] detect error for ${address}`, err);
+        } finally {
+          this.inProgress.delete(address);
+        }
+      }
+    }
+  }
+  async getFullNftInstancesByCollection(request) {
+    const {
+      chainInfo,
+      contractAddress,
+      owners
+    } = request;
+    const chainId = (0, _utils._getEvmChainId)(chainInfo);
+    if (!contractAddress || !owners || !chainId) {
+      console.warn('[NftService] missing params for getFullNftInstancesByCollection');
+      return false;
+    }
+    try {
+      const nftDetectionApi = _subwalletServicesSdk.default.nftDetectionApi;
+      if (!(nftDetectionApi !== null && nftDetectionApi !== void 0 && nftDetectionApi.getAllNftInstances)) {
+        console.warn('[NftService] getAllNftInstances not available');
+        return false;
+      }
+      const ownerList = Array.isArray(owners) ? owners : [owners];
+      for (const eachOwner of ownerList) {
+        try {
+          const instances = await nftDetectionApi.getAllNftInstances(contractAddress, eachOwner, chainId.toString());
+          if (!Array.isArray(instances)) {
+            continue;
+          }
+          console.log('FOR TESTER (before)', instances);
+          const nftList = instances.map(inst => mapSdkToNftItem(inst, chainInfo.slug, contractAddress, eachOwner)).filter(i => Boolean(i));
+          console.log('FOR TESTER (after)', nftList);
+          await this.state.handleDetectedNfts(eachOwner, nftList);
+        } catch (innerErr) {
+          console.warn(`[NftService] getAllNftInstances failed for ${eachOwner}`, innerErr);
+        }
+      }
+      return true;
+    } catch (err) {
+      console.error(`[NftDetectionService] getFullNftInstancesByCollection error for ${contractAddress}`, err);
+      return false;
+    }
+  }
+}
+exports.default = NftService;

package/cjs/services/transaction-service/index.js

@@ -134,7 +134,7 @@ class TransactionService {
     // Check account signing transaction
 
     (0, _transfer.checkSigningAccountForTransaction)(validationResponse, chainInfoMap);
-    const nativeTokenAvailable = await this.state.balanceService.getTransferableBalance(address, chain, nativeTokenInfo.slug, extrinsicType);
+    const nativeTokenAvailable = await this.state.balanceService.getBalanceByType(address, chain, nativeTokenInfo.slug, transactionInput.balanceType, extrinsicType);
 
     // Check available balance against transaction fee
     (0, _transfer.checkBalanceWithTransactionFee)(validationResponse, transactionInput, nativeTokenInfo, nativeTokenAvailable);

package/cjs/types/balance/index.js

@@ -1 +1,26 @@
-"use strict";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BalanceType = void 0;
+// Copyright 2019-2022 @subwallet/extension-koni-ui authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+let BalanceType;
+/**
+ * Balance info of a token on an address
+ * @property {string} address - Address
+ * @property {string} tokenSlug - Slug of token
+ * @property {APIItemState} state - State of information
+ * @property {number} [timestamp] - Time to get information
+ * @property {string} free - Transferable balance
+ * @property {string} locked - Locked balance, cannot be transferred, locked here is only meaningful in the context of token transfer
+ * @property {metadata} [metadata] - Could be anything, supposed to be generic to handle various contexts
+ */
+exports.BalanceType = BalanceType;
+(function (BalanceType) {
+  BalanceType["TRANSFERABLE"] = "transferable";
+  BalanceType["TOTAL"] = "total";
+  BalanceType["TOTAL_MINUS_RESERVED"] = "totalMinusReserved";
+  BalanceType["KEEP_ALIVE"] = "keepAlive";
+})(BalanceType || (exports.BalanceType = BalanceType = {}));

package/cjs/utils/index.js

@@ -632,13 +632,36 @@ const stripUrl = url => {
 };
 exports.stripUrl = stripUrl;
 const baseParseIPFSUrl = (input, customDomain) => {
-  const selectedDomain = customDomain || (0, _config.getRandomIpfsGateway)();
   if (!input || input.length === 0) {
     return undefined;
   }
-  if (isUrl(input)) {
+
+  // Case 1: Return as-is for inline data URLs (e.g. base64-encoded images)
+  if (input.startsWith('data:')) {
     return input;
   }
+  const selectedDomain = customDomain || (0, _config.getRandomIpfsGateway)();
+
+  // Case 2: Replace Pinata private gateways with a public IPFS gateway
+  // ==== EX: https://ikzttp.mypinata.cloud/ipfs/QmYDvPAXtiJg7s8JdRBSLWdgSphQdac8j1YuQNNxcGE1hg/9586.png
+  // Case 2b: Blockscout IPFS debug gateway -> rewrite to public gateway
+  // ==== EX: http://ipfs-debug.node.blockscout.com/ipfs/QmX2qHy1o27KgmHJSG2wKj2qLiv1gMCJCTn4nxzEVtTdgF
+  // Case 2c: http://ipfs.node.blockscout.com/ipfs/QmeTETrnJcG3iowfT3tXtz2jKmyeYbeag3AeYfDk5pBjGg
+
+  const privateGatewayPattern = /https?:\/\/([^/]*pinata\.cloud|[^/]*\.node\.blockscout\.com)\/ipfs\//;
+  if (privateGatewayPattern.test(input)) {
+    return input.replace(privateGatewayPattern, selectedDomain);
+  }
+
+  // Case 3: Handle NFT.storage subdomain links (e.g. https://<cid>.ipfs.nftstorage.link/...)
+  // Always redirect to selectedDomain to avoid SSL version/cipher mismatch errors
+  // ==== EX: https://bafybeias6as7k66hkghst3w4jwk6x5dkfk56oglqh44x6jmok6n7kcvg7m.ipfs.nftstorage.link/0.gif?ext=gif
+  const nftStorageMatch = input.match(/^https?:\/\/([a-zA-Z0-9]+)\.ipfs\.nftstorage\.link\/(.*)$/);
+  if (nftStorageMatch) {
+    const cid = nftStorageMatch[1];
+    const pathAndQuery = nftStorageMatch[2] || '';
+    return `${selectedDomain}${cid}/${pathAndQuery}`;
+  }
   if (isUrl(input) || input.includes('https://') || input.includes('http')) {
     return input;
   }

package/cjs/utils/setup-api-sdk.js

@@ -19,9 +19,4 @@ function setupApiSDK() {
     platform: _environment.TARGET_ENV,
     chainListVersion: CHAIN_LIST_VERSION
   });
-
-  // Custom the price history API with other different base URL
-  _subwalletServicesSdk.default.priceHistoryApi.updateConfig({
-    baseUrl: _constants.BACKEND_PRICE_HISTORY_URL
-  });
 }

package/constants/environment.d.ts

@@ -1,5 +1,4 @@
 export declare const APP_VERSION: string;
 export declare const isProductionMode: boolean;
 export declare const BACKEND_API_URL: string;
-export declare const BACKEND_PRICE_HISTORY_URL: string;
 export declare const SW_EXTERNAL_SERVICES_API: string;

package/constants/environment.js

@@ -6,5 +6,4 @@ const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 export const APP_VERSION = process.env.PKG_VERSION || '';
 export const isProductionMode = PRODUCTION_BRANCHES.indexOf(branchName) > -1;
 export const BACKEND_API_URL = process.env.SUBWALLET_API || (isProductionMode ? 'https://sw-services.subwallet.app/api' : 'https://be-dev.subwallet.app/api');
-export const BACKEND_PRICE_HISTORY_URL = process.env.SUBWALLET_PRICE_HISTORY_API || (isProductionMode ? 'https://price-history.subwallet.app/api' : 'https://price-history-dev.subwallet.app/api');
 export const SW_EXTERNAL_SERVICES_API = process.env.SW_EXTERNAL_SERVICES_API || (isProductionMode ? 'https://external-services.subwallet.app' : 'https://external-services-dev.subwallet.app');

package/constants/index.d.ts

@@ -15,6 +15,7 @@ export declare const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 90000;
 export declare const CRON_REFRESH_HISTORY_INTERVAL = 900000;
 export declare const CRON_GET_API_MAP_STATUS = 10000;
 export declare const CRON_REFRESH_CHAIN_STAKING_METADATA = 90000;
+export declare const CRON_NFT_DETECT_INTERVAL = 7500000;
 export declare const CRON_REFRESH_CHAIN_NOMINATOR_METADATA = 1800000;
 export declare const CRON_RECOVER_HISTORY_INTERVAL = 30000;
 export declare const CRON_SYNC_MANTA_PAY = 300000;

package/constants/index.js

@@ -17,6 +17,7 @@ export const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 90000;
 export const CRON_REFRESH_HISTORY_INTERVAL = 900000;
 export const CRON_GET_API_MAP_STATUS = 10000;
 export const CRON_REFRESH_CHAIN_STAKING_METADATA = 90000;
+export const CRON_NFT_DETECT_INTERVAL = 7500000;
 export const CRON_REFRESH_CHAIN_NOMINATOR_METADATA = 1800000;
 export const CRON_RECOVER_HISTORY_INTERVAL = 30000;
 export const CRON_SYNC_MANTA_PAY = 300000;

package/core/substrate/system-pallet.d.ts

@@ -5,3 +5,4 @@ export declare function _canAccountBeReaped(accountInfo: FrameSystemAccountInfo)
 export declare function _isAccountActive(accountInfo: FrameSystemAccountInfo): boolean;
 export declare function _getSystemPalletTotalBalance(accountInfo: FrameSystemAccountInfo): bigint;
 export declare function _getAppliedExistentialDepositWithExtrinsicType(accountInfo: FrameSystemAccountInfo, existentialDeposit: string, extrinsicType?: ExtrinsicType): bigint;
+export declare function _getSystemPalletReservedBalance(accountInfo: FrameSystemAccountInfo): bigint;

package/core/substrate/system-pallet.js

@@ -64,4 +64,7 @@ function _getSystemPalletTransferableV1(accountInfo, existentialDeposit, strictM
 }
 function _getSystemPalletTotalBalanceV1(accountInfo) {
   return BigInt(accountInfo.data.free) + BigInt(accountInfo.data.reserved);
+}
+export function _getSystemPalletReservedBalance(accountInfo) {
+  return BigInt(accountInfo.data.reserved);
 }

package/core/substrate/types.d.ts

@@ -18,6 +18,20 @@ export declare type FrameSystemAccountInfoV1 = {
         feeFrozen: number;
     };
 };
+export interface FrameBalancesLocksInfo {
+    id: string | Record<string, unknown>;
+    amount: string | number | bigint;
+    reasons?: string;
+}
+export interface FrameBalancesHoldsInfo {
+    id: string | Record<string, unknown>;
+    amount: string | number | bigint;
+    reason?: string;
+}
+export interface FrameBalancesFreezesInfo {
+    id: string | Record<string, unknown>;
+    amount: string;
+}
 export declare type FrameSystemAccountInfo = FrameSystemAccountInfoV1 | FrameSystemAccountInfoV2;
 export declare type OrmlTokensAccountData = {
     free: number;

package/koni/api/nft/rari/index.js

@@ -6,7 +6,7 @@ const options = {
   method: 'GET',
   headers: {
     accept: 'application/json',
-    'X-API-KEY': 'ed9df6bf-7eba-4ca2-8a42-9006706be064'
+    'X-API-KEY': 'e5c3b30b-f241-47f6-88b7-7859837ff17c'
   }
 };
 export class RariNftApi extends BaseNftApi {

package/koni/background/cron.d.ts

@@ -29,6 +29,7 @@ export declare class KoniCron {
     refreshNft: (address: string, apiMap: ApiMap, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>) => () => void;
     resetNft: (newAddress: string) => void;
     checkNetworkAvailable: (serviceInfo: ServiceInfo) => boolean;
+    detectEvmCollectionNft: (address: string) => () => void;
     reloadNft(): Promise<boolean>;
     reloadStaking(): Promise<boolean>;
     private needUpdateNft;

package/koni/background/cron.js

@@ -1,7 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { CRON_REFRESH_CHAIN_STAKING_METADATA, CRON_REFRESH_MKT_CAMPAIGN_INTERVAL, CRON_REFRESH_NFT_INTERVAL, CRON_SYNC_MANTA_PAY } from '@subwallet/extension-base/constants';
+import { CRON_NFT_DETECT_INTERVAL, CRON_REFRESH_CHAIN_STAKING_METADATA, CRON_REFRESH_MKT_CAMPAIGN_INTERVAL, CRON_REFRESH_NFT_INTERVAL, CRON_SYNC_MANTA_PAY } from '@subwallet/extension-base/constants';
 import { _isChainSupportEvmNft, _isChainSupportNativeNft, _isChainSupportWasmNft } from '@subwallet/extension-base/services/chain-service/utils';
 import { waitTimeout } from '@subwallet/extension-base/utils';
 import { Subject } from 'rxjs';
@@ -88,6 +88,7 @@ export class KoniCron {
       // NFT
       (commonReload || needUpdateNft) && this.resetNft(address);
       (commonReload || needUpdateNft) && this.removeCron('refreshNft');
+      (commonReload || needUpdateNft) && this.removeCron('detectNft');
       commonReload && this.removeCron('refreshPoolingStakingReward');
       if (mktCampaignNeedReload) {
         this.removeCron('fetchMktCampaignData');
@@ -103,6 +104,7 @@ export class KoniCron {
       if (this.checkNetworkAvailable(serviceInfo)) {
         // only add cron jobs if there's at least 1 active network
         (commonReload || needUpdateNft) && this.addCron('refreshNft', this.refreshNft(address, serviceInfo.chainApiMap, this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), CRON_REFRESH_NFT_INTERVAL);
+        (commonReload || needUpdateNft) && this.addCron('detectNft', this.detectEvmCollectionNft(address), CRON_NFT_DETECT_INTERVAL);
         reloadMantaPay && this.addCron('syncMantaPay', this.syncMantaPay, CRON_SYNC_MANTA_PAY);
       }
     };
@@ -115,6 +117,7 @@ export class KoniCron {
     if (Object.keys(this.state.getSubstrateApiMap()).length !== 0 || Object.keys(this.state.getEvmApiMap()).length !== 0) {
       this.resetNft(currentAccountInfo.proxyId);
       this.addCron('refreshNft', this.refreshNft(currentAccountInfo.proxyId, this.state.getApiMap(), this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), CRON_REFRESH_NFT_INTERVAL);
+      this.addCron('detectNft', this.detectEvmCollectionNft(currentAccountInfo.proxyId), CRON_NFT_DETECT_INTERVAL);
       // this.addCron('refreshStakingReward', this.refreshStakingReward(currentAccountInfo.address), CRON_REFRESH_STAKING_REWARD_INTERVAL);
       this.addCron('syncMantaPay', this.syncMantaPay, CRON_SYNC_MANTA_PAY);
     }
@@ -164,12 +167,25 @@ export class KoniCron {
   checkNetworkAvailable = serviceInfo => {
     return Object.keys(serviceInfo.chainApiMap.substrate).length > 0 || Object.keys(serviceInfo.chainApiMap.evm).length > 0;
   };
+  detectEvmCollectionNft = address => {
+    return () => {
+      let addresses = [];
+      addresses = this.state.keyringService.context.getDecodedAddresses();
+      if (!addresses.length) {
+        console.warn('[Cron] No decoded addresses found for ALL_ACCOUNT_KEY');
+        return;
+      }
+      this.state.nftDetectionService.fetchEvmCollectionsWithPreview(addresses).catch(err => console.warn(`[Cron] NFT detection failed for ${address}:`, err));
+    };
+  };
   async reloadNft() {
     const address = this.state.keyringService.context.currentAccount.proxyId;
     const serviceInfo = this.state.getServiceInfo();
     this.resetNft(address);
     this.removeCron('refreshNft');
+    this.removeCron('detectNft');
     this.addCron('refreshNft', this.refreshNft(address, serviceInfo.chainApiMap, this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), CRON_REFRESH_NFT_INTERVAL);
+    this.addCron('detectNft', this.detectEvmCollectionNft(address), CRON_NFT_DETECT_INTERVAL);
     await waitTimeout(1800);
     return true;
   }

package/koni/background/handlers/Extension.d.ts

@@ -116,6 +116,7 @@ export default class KoniExtension {
     private subscribeNftCollection;
     private getNft;
     private subscribeNft;
+    private handleGetNftFullList;
     private getStakingReward;
     private subscribeStakingReward;
     private getStaking;
@@ -145,10 +146,12 @@ export default class KoniExtension {
     private deleteCustomAsset;
     private validateCustomAsset;
     private getAddressTransferableBalance;
+    private getAddressAvailableBalanceByType;
     private getAddressTotalBalance;
     private subscribeMaxTransferable;
     private subscribeTransferableWhenConfirmation;
     private subscribeAddressTransferableBalance;
+    private subscribeAddressAvailableBalanceByType;
     private substrateNftSubmitTransaction;
     private enableChains;
     private accountsCreateExternalV2;

package/koni/background/handlers/Extension.js

@@ -47,7 +47,7 @@ import { DEFAULT_AUTO_LOCK_TIME } from '@subwallet/extension-base/services/setti
 import { isProposalExpired, isSupportWalletConnectChain, isSupportWalletConnectNamespace } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { AccountsStore } from '@subwallet/extension-base/stores';
-import { AccountChainType, AccountSignMode, BasicTxErrorType, BasicTxWarningCode, CommonStepType, EarningProcessType, ProcessType, StakingTxErrorType, StepStatus, SwapFeeType, YieldPoolType, YieldStepType } from '@subwallet/extension-base/types';
+import { AccountChainType, AccountSignMode, BalanceType, BasicTxErrorType, BasicTxWarningCode, CommonStepType, EarningProcessType, ProcessType, StakingTxErrorType, StepStatus, SwapFeeType, YieldPoolType, YieldStepType } from '@subwallet/extension-base/types';
 import { _analyzeAddress, calculateMaxTransferable, combineAllAccountProxy, combineBitcoinFee, createPromiseHandler, createTransactionFromRLP, detectTransferTxType, filterUneconomicalUtxos, getAccountSignMode, getSizeInfo, getTransferableBitcoinUtxos, isSameAddress, isSubstrateEcdsaLedgerAssetSupported, MODULE_SUPPORT, reformatAddress, signatureToHex, transformAccounts, transformAddresses, uniqueStringArray } from '@subwallet/extension-base/utils';
 import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
@@ -1144,6 +1144,9 @@ export default class KoniExtension {
     });
     return this.getNft();
   }
+  async handleGetNftFullList(request) {
+    return this.#koniState.nftDetectionService.getFullNftInstancesByCollection(request);
+  }
   getStakingReward() {
     return new Promise((resolve, reject) => {
       this.#koniState.getStakingReward(rs => {
@@ -2033,20 +2036,40 @@ export default class KoniExtension {
     var _data$metadata;
     const evmApi = this.#koniState.getEvmApi(data.originChain);
     const contractAddress = (_data$metadata = data.metadata) === null || _data$metadata === void 0 ? void 0 : _data$metadata.contractAddress;
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     const tokenContract = new evmApi.api.eth.Contract(_ERC721_ABI, contractAddress);
     try {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-      await tokenContract.methods.tokenOfOwnerByIndex('0xB7fdD27a8Df011816205a6e3cAA097DC4D8C2C5d', 1).call();
-      return true;
-    } catch (err) {
-      const error = err;
-      if (error.message.includes('index out of bounds')) {
-        return true;
-      } else {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      const supports1155 = await tokenContract.methods.supportsInterface('0xd9b67a26').call().catch(() => false);
+      if (supports1155) {
         return false;
       }
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+      const supports721 = await tokenContract.methods.supportsInterface('0x80ac58cd').call().catch(() => false);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+      const supportsMetadata = await tokenContract.methods.supportsInterface('0x5b5e139f').call().catch(() => false);
+      if (supports721 || supportsMetadata) {
+        return true;
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      if (tokenContract.methods.ownerOf) {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          await tokenContract.methods.ownerOf(1).call();
+          return true;
+        } catch (err) {
+          var _err$message, _err$message2;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          if ((_err$message = err.message) !== null && _err$message !== void 0 && _err$message.includes('nonexistent token') || (_err$message2 = err.message) !== null && _err$message2 !== void 0 && _err$message2.includes('invalid token ID')) {
+            return true;
+          }
+        }
+      }
+      return false;
+    } catch (err) {
+      const error = err;
+      return error.message.includes('index out of bounds');
     }
   }
   async upsertCustomToken(data) {
@@ -2102,6 +2125,21 @@ export default class KoniExtension {
     }
     return await this.#koniState.balanceService.getTransferableBalance(address, networkKey, token, extrinsicType);
   }
+  async getAddressAvailableBalanceByType({
+    address,
+    balanceType,
+    extrinsicType,
+    networkKey,
+    token
+  }) {
+    if (token && _MANTA_ZK_CHAIN_GROUP.includes(networkKey)) {
+      const tokenInfo = this.#koniState.chainService.getAssetBySlug(token);
+      if (tokenInfo.symbol.startsWith(_ZK_ASSET_PREFIX)) {
+        return await this.#koniState.getMantaPayZkBalance(address, tokenInfo);
+      }
+    }
+    return await this.#koniState.balanceService.getBalanceByType(address, networkKey, token, balanceType, extrinsicType);
+  }
   async getAddressTotalBalance({
     address,
     extrinsicType,
@@ -2173,7 +2211,7 @@ export default class KoniExtension {
     });
     const [unsubBalance, freeBalance] = await (async () => {
       try {
-        return await this.#koniState.balanceService.subscribeBalance(address, chain, token, 'transferable', extrinsicType, data => {
+        return await this.#koniState.balanceService.subscribeBalance(address, chain, token, BalanceType.TRANSFERABLE, extrinsicType, data => {
           freeBalanceSubject.next(data); // Must be called after subscription
         });
       } catch (e) {
@@ -2311,7 +2349,7 @@ export default class KoniExtension {
         convertData(freeBalance, fee, _feeOptions, feeCustom).then(cb).catch(console.error);
       }
     });
-    const [unsubBalance, freeBalance] = await this.#koniState.balanceService.subscribeBalance(address, chain, token, 'transferable', ExtrinsicType.TRANSFER_BALANCE, data => {
+    const [unsubBalance, freeBalance] = await this.#koniState.balanceService.subscribeBalance(address, chain, token, BalanceType.TRANSFERABLE, ExtrinsicType.TRANSFER_BALANCE, data => {
       freeBalanceSubject.next(data); // Must be called after subscription
     });
 
@@ -2354,6 +2392,31 @@ export default class KoniExtension {
     });
     return convertData(currentFreeBalance);
   }
+  async subscribeAddressAvailableBalanceByType({
+    address,
+    balanceType,
+    extrinsicType,
+    networkKey,
+    token
+  }, id, port) {
+    const cb = createSubscription(id, port);
+    const convertData = data => {
+      return {
+        ...data,
+        id
+      };
+    };
+    const _cb = data => {
+      // eslint-disable-next-line node/no-callback-literal
+      cb(convertData(data));
+    };
+    const [unsub, currentFreeBalance] = await this.#koniState.balanceService.subscribeBalanceByType(address, networkKey, token, balanceType, extrinsicType, _cb);
+    this.createUnsubscriptionHandle(id, unsub);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return convertData(currentFreeBalance);
+  }
   async substrateNftSubmitTransaction(inputData) {
     const {
       params,
@@ -3799,6 +3862,10 @@ export default class KoniExtension {
         });
       }
     }
+    let balanceTypeForPool = BalanceType.TRANSFERABLE;
+    if (!!poolHandler && [YieldPoolType.NATIVE_STAKING, YieldPoolType.NOMINATION_POOL].includes(poolHandler.type)) {
+      balanceTypeForPool = BalanceType.TOTAL_MINUS_RESERVED;
+    }
     return await this.#koniState.transactionService.handleTransaction({
       address,
       chain: txChain,
@@ -3810,6 +3877,7 @@ export default class KoniExtension {
       chainType,
       resolveOnDone: !isLastStep,
       transferNativeAmount,
+      balanceType: balanceTypeForPool,
       skipFeeValidation: isMintingStep && isPoolSupportAlternativeFee,
       errorOnTimeOut,
       ...this.createPassConfirmationParams(isPassConfirmation),
@@ -4807,6 +4875,8 @@ export default class KoniExtension {
         return await this.getNftCollection();
       case 'pri(nftCollection.getSubscription)':
         return await this.subscribeNftCollection(id, port);
+      case 'pri(nft.getFullList)':
+        return await this.handleGetNftFullList(request);
       case 'pri(staking.getStaking)':
         return this.getStaking();
       case 'pri(staking.getSubscription)':
@@ -5015,6 +5085,10 @@ export default class KoniExtension {
         return this.getAddressTransferableBalance(request);
       case 'pri(freeBalance.subscribe)':
         return this.subscribeAddressTransferableBalance(request, id, port);
+      case 'pri(availableBalance.getBalanceByType)':
+        return this.getAddressAvailableBalanceByType(request);
+      case 'pri(availableBalance.subscribeBalanceByType)':
+        return this.subscribeAddressAvailableBalanceByType(request, id, port);
       case 'pri(subscription.cancel)':
         return this.cancelSubscription(request);
       case 'pri(chainService.recoverSubstrateApi)':

package/koni/background/handlers/State.d.ts

@@ -19,6 +19,7 @@ import { KeyringService } from '@subwallet/extension-base/services/keyring-servi
 import MigrationService from '@subwallet/extension-base/services/migration-service';
 import MintCampaignService from '@subwallet/extension-base/services/mint-campaign-service';
 import MktCampaignService from '@subwallet/extension-base/services/mkt-campaign-service';
+import NftService from '@subwallet/extension-base/services/nft-service';
 import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
 import { PriceService } from '@subwallet/extension-base/services/price-service';
 import RequestService from '@subwallet/extension-base/services/request-service';
@@ -73,6 +74,7 @@ export default class KoniState {
     readonly mintCampaignService: MintCampaignService;
     readonly campaignService: CampaignService;
     readonly mktCampaignService: MktCampaignService;
+    readonly nftDetectionService: NftService;
     readonly buyService: BuyService;
     readonly earningService: EarningService;
     readonly feeService: FeeService;
@@ -133,6 +135,8 @@ export default class KoniState {
     resetNft(newAddress: string): void;
     updateNftData(network: string, nftData: NftItem, address: string, callback?: (nftData: NftItem) => void): void;
     deleteNftCollection(chain: string, collectionId: string): Promise<void>;
+    handleDetectedNfts(address: string, nftItems: NftItem[]): Promise<void>;
+    handleDetectedNftCollections(collections: NftCollection[]): Promise<void>;
     cleanUpNfts(chain: string, owner: string, collectionId: string[], nftIds: string[], ownNothing?: boolean): void;
     getNft(): Promise<NftJson | undefined>;
     subscribeNft(): Subject<NftJson>;