@subwallet/extension-base 1.3.78-0 → 1.3.80-0

package/cjs/services/earning-service/handlers/native-staking/tao.js

@@ -122,14 +122,17 @@ class BittensorCache {
   }
 }
 exports.BittensorCache = BittensorCache;
-const getAlphaToTaoRate = async (substrateApi, netuid) => {
-  const subnetInfo = (await substrateApi.api.call.subnetInfoRuntimeApi.getDynamicInfo(netuid)).toJSON();
-  if (!subnetInfo) {
+const getAlphaToTaoRate = async function (substrateApi, netuid) {
+  let priceScaleDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 9;
+  if (netuid === 0) {
     return '1';
   }
-  const taoIn = subnetInfo.taoIn ? new _bignumber.default(subnetInfo.taoIn) : new _bignumber.default(0);
-  const alphaIn = subnetInfo.alphaIn ? new _bignumber.default(subnetInfo.alphaIn) : new _bignumber.default(0);
-  return netuid === 0 || alphaIn.lte(0) ? '1' : taoIn.dividedBy(alphaIn).toString();
+  const [rawSubnetPrice, rawRootPrice] = await Promise.all([substrateApi.api.call.swapRuntimeApi.currentAlphaPrice(netuid), substrateApi.api.call.swapRuntimeApi.currentAlphaPrice(0)]);
+  const subnetPrice = new _bignumber.default(rawSubnetPrice.toString());
+  const defaultScale = new _bignumber.default(10).pow(priceScaleDecimals);
+  const rootPrice = new _bignumber.default(rawRootPrice.toString());
+  const priceScale = rootPrice.lte(0) ? defaultScale : rootPrice;
+  return subnetPrice.lte(0) ? '0' : subnetPrice.dividedBy(priceScale).toFixed();
 };
 exports.getAlphaToTaoRate = getAlphaToTaoRate;
 class TaoNativeStakingPoolHandler extends _basePara.default {
@@ -142,6 +145,9 @@ class TaoNativeStakingPoolHandler extends _basePara.default {
     claimReward: false,
     changeValidator: true
   };
+  getAlphaPriceScaleDecimals() {
+    return (0, _utils2._getAssetDecimals)(this.nativeToken);
+  }
   async getMinBond(netuid) {
     var _cachedPool$metadata2, _cachedPool$statistic, _cachedPool$statistic2, _onlinePool$metadata2, _onlinePool$statistic, _onlinePool$statistic2;
     // @ts-ignore
@@ -483,7 +489,7 @@ class TaoNativeStakingPoolHandler extends _basePara.default {
     const hotkey = selectedValidatorInfo.address;
     const netuid = (_subnetData$netuid = subnetData === null || subnetData === void 0 ? void 0 : subnetData.netuid) !== null && _subnetData$netuid !== void 0 ? _subnetData$netuid : 0;
     const slippage = (_subnetData$slippage = subnetData === null || subnetData === void 0 ? void 0 : subnetData.slippage) !== null && _subnetData$slippage !== void 0 ? _subnetData$slippage : DEFAULT_BITTENSOR_SLIPPAGE;
-    const alphaToTaoPrice = new _bignumber.default(await getAlphaToTaoRate(this.substrateApi, netuid));
+    const alphaToTaoPrice = new _bignumber.default(await getAlphaToTaoRate(this.substrateApi, netuid, this.getAlphaPriceScaleDecimals()));
     const limitPrice = alphaToTaoPrice.multipliedBy(10 ** (0, _utils2._getAssetDecimals)(this.nativeToken)).multipliedBy(1 + slippage);
     const BNlimitPrice = new _bignumber.default(limitPrice.integerValue(_bignumber.default.ROUND_CEIL).toFixed());
     const extrinsic = chainApi.api.tx.subtensorModule.addStakeLimit(hotkey, netuid, binaryAmount.toFixed(), BNlimitPrice.toFixed(), false);
@@ -527,7 +533,7 @@ class TaoNativeStakingPoolHandler extends _basePara.default {
       return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
     }
     const binaryAmount = new _bignumber.default(amount);
-    const alphaToTaoPrice = new _bignumber.default(await getAlphaToTaoRate(this.substrateApi, netuid));
+    const alphaToTaoPrice = new _bignumber.default(await getAlphaToTaoRate(this.substrateApi, netuid, this.getAlphaPriceScaleDecimals()));
     const limitPrice = alphaToTaoPrice.multipliedBy(10 ** (0, _utils2._getAssetDecimals)(this.nativeToken)).multipliedBy(1 - slippage);
     const BNlimitPrice = new _bignumber.default(limitPrice.integerValue(_bignumber.default.ROUND_CEIL).toFixed());
     const extrinsic = apiPromise.api.tx.subtensorModule.removeStakeLimit(selectedTarget, netuid, binaryAmount.toFixed(), BNlimitPrice.toFixed(), false);
@@ -543,7 +549,7 @@ class TaoNativeStakingPoolHandler extends _basePara.default {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS)];
     }
     const netuid = (_poolInfo$metadata$su = poolInfo.metadata.subnetData) === null || _poolInfo$metadata$su === void 0 ? void 0 : _poolInfo$metadata$su.netuid;
-    const alphaToTaoPrice = new _bignumber.default(await getAlphaToTaoRate(this.substrateApi, netuid || 0));
+    const alphaToTaoPrice = new _bignumber.default(await getAlphaToTaoRate(this.substrateApi, netuid || 0, this.getAlphaPriceScaleDecimals()));
     const minDelegatorStake = await this.getMinBond(netuid);
     const minUnstake = minDelegatorStake.dividedBy(alphaToTaoPrice);
     if (new _bignumber.default(amount).lt(minUnstake)) {
@@ -583,7 +589,7 @@ class TaoNativeStakingPoolHandler extends _basePara.default {
     if (originValidator === destValidator) {
       return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('bg.EARNING.services.service.earning.nativeStaking.tao.fromValidatorSameAsTo')));
     }
-    const alphaToTaoPrice = new _bignumber.default(await getAlphaToTaoRate(this.substrateApi, netuid));
+    const alphaToTaoPrice = new _bignumber.default(await getAlphaToTaoRate(this.substrateApi, netuid, this.getAlphaPriceScaleDecimals()));
     const bnMinStake = await this.getMinBond(netuid);
     const minUnstake = bnMinStake.dividedBy(alphaToTaoPrice);
     const formattedMinUnstake = minUnstake.dividedBy(1000000).integerValue(_bignumber.default.ROUND_CEIL).dividedBy(1000);

package/cjs/services/earning-service/handlers/special.js

@@ -255,6 +255,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
           }
           const metadata = {
             sendingValue,
+            xcmDestinationFee,
             originTokenInfo: altInputTokenInfo,
             destinationTokenInfo: inputTokenInfo
           };
@@ -466,11 +467,13 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const {
       destinationTokenInfo,
       originTokenInfo,
-      sendingValue
+      sendingValue,
+      xcmDestinationFee
     } = metadata;
     const originChainInfo = this.state.getChainInfo(originTokenInfo.originChain);
     const originTokenSlug = (0, _utils3._getChainNativeTokenSlug)(originChainInfo);
     const substrateApi = this.state.getSubstrateApi(originChainInfo.slug);
+    const fromAddress = (0, _utils4._reformatAddressWithChain)(address, originChainInfo);
     const id = (0, _getId.getId)();
     const feeInfo = await this.state.feeService.subscribeChainFee(id, originChainInfo.slug, 'substrate');
     const xcmRequest = {
@@ -479,7 +482,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       recipient: address,
       sendingValue,
       substrateApi,
-      sender: address,
+      sender: fromAddress,
       originChain: originChainInfo,
       destinationChain: this.chainInfo,
       feeInfo
@@ -491,7 +494,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const xcmData = {
       originNetworkKey: originChainInfo.slug,
       destinationNetworkKey: destinationTokenInfo.originChain,
-      from: address,
+      from: fromAddress,
       to: address,
       value: sendingValue,
       tokenSlug: originTokenSlug,
@@ -504,7 +507,12 @@ class BaseSpecialStakingPoolHandler extends _base.default {
       txData: xcmData,
       transferNativeAmount: sendingValue,
       chainType: _KoniTypes.ChainType.SUBSTRATE,
-      xcmStepFee
+      xcmStepFee,
+      xcmDestinationFee: xcmDestinationFee ? {
+        decimals: (0, _utils3._getAssetDecimals)(destinationTokenInfo),
+        symbol: (0, _utils3._getAssetSymbol)(destinationTokenInfo),
+        value: xcmDestinationFee
+      } : undefined
     };
   }
   handleYieldJoin(data, path, currentStep) {

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

@@ -4,175 +4,244 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-var _types = require("@subwallet/chain-list/types");
+exports.NftService = void 0;
+var _types = require("@subwallet/extension-base/services/base/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"));
+var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
+var _rxjs = require("rxjs");
+var _multiChainNftFetcher = require("./multi-chain-nft-fetcher");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-/**
- * NFT detection service
- * Responsible for managing NFT detection jobs per address
- */
+const INITIAL_NFT_STATE = {
+  nftData: {
+    total: 0,
+    nftList: []
+  },
+  nftCollections: []
+};
 
-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();
+// HIGH PRIORITY – no lazy
+const IMMEDIATE_EVENTS = ['account.updateCurrent', 'account.add', 'account.remove'];
 
-  // 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
-  };
-}
+// LOW PRIORITY – lazy
+const LAZY_EVENTS = ['asset.updateState', 'chain.add'];
 class NftService {
-  inProgress = new Set();
+  NFT_INTERVAL_TIME = 2 * 60 * 60 * 1000; // 2 hours
+
+  nftStateSubject = new _rxjs.BehaviorSubject(INITIAL_NFT_STATE);
+  nftState$ = this.nftStateSubject.asObservable();
+  isReloading = false;
+  startPromiseHandler = (0, _utils2.createPromiseHandler)();
+  stopPromiseHandler = (0, _utils2.createPromiseHandler)();
+  status = _types.ServiceStatus.NOT_INITIALIZED;
+  get isStarted() {
+    return this.status === _types.ServiceStatus.STARTED;
+  }
   constructor(state) {
     this.state = state;
+    this.multiChainFetcher = new _multiChainNftFetcher.MultiChainNftFetcher(state);
+  }
+  async init() {
+    this.status = _types.ServiceStatus.INITIALIZING;
+    await this.state.eventService.waitKeyringReady;
+    await this.state.eventService.waitChainReady;
+    await this.loadCachedData();
+    this.status = _types.ServiceStatus.INITIALIZED;
+    this.state.eventService.onLazy(this.handleEvents.bind(this));
+  }
+  async loadCachedData() {
+    const [nftData, collections] = await Promise.all([this.state.getNft(), this.state.getNftCollection()]);
+    this.nftStateSubject.next({
+      nftData: nftData || {
+        total: 0,
+        nftList: []
+      },
+      nftCollections: collections || []
+    });
+  }
+  async start() {
+    if (this.status === _types.ServiceStatus.STOPPING) {
+      await this.waitForStopped();
+    }
+    if (this.isStarted || this.status === _types.ServiceStatus.STARTING) {
+      return this.waitForStarted();
+    }
+    this.status = _types.ServiceStatus.STARTING;
+    await this.refreshNftData();
+    this.status = _types.ServiceStatus.STARTED;
+    this.startPromiseHandler.resolve();
+    this.startScanNft();
+  }
+  async stop() {
+    if (this.status === _types.ServiceStatus.STARTING) {
+      await this.waitForStarted();
+    }
+    if (this.status === _types.ServiceStatus.STOPPED || this.status === _types.ServiceStatus.STOPPING) {
+      return this.waitForStopped();
+    }
+    this.status = _types.ServiceStatus.STOPPING;
+    this.stopScanNft();
+    this.stopPromiseHandler.resolve();
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+  checkIfNftUpdateNeeded(events, eventTypes) {
+    if (!eventTypes.includes('chain.updateState')) {
+      return false;
+    }
+    const updatedChains = this.extractUpdatedChains(events);
+    return this.hasNftSupportedChainUpdate(updatedChains);
+  }
+  extractUpdatedChains(events) {
+    return events.filter(event => event.type === 'chain.updateState').map(event => event.data[0]);
+  }
+  hasNftSupportedChainUpdate(updatedChains) {
+    if (updatedChains.length === 0) {
+      return false;
+    }
+    const chainInfoMap = this.state.getServiceInfo().chainInfoMap;
+    return updatedChains.some(chainSlug => {
+      const chainInfo = chainInfoMap[chainSlug];
+      return this.isChainNftSupported(chainInfo);
+    });
+  }
+  isChainNftSupported(chainInfo) {
+    return (0, _utils._isChainSupportNativeNft)(chainInfo) || (0, _utils._isChainSupportEvmNft)(chainInfo) || (0, _utils._isChainSupportWasmNft)(chainInfo);
+  }
+  handleImmediateRefresh(address) {
+    this.state.resetNft(address);
+    this.refreshNftData().catch(console.error);
   }
-  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);
-        }
+  scheduleLazyRefresh(delay) {
+    (0, _utils2.addLazy)('nft.refresh', () => {
+      if (!this.isReloading && this.isStarted) {
+        this.refreshNftData().catch(console.error);
       }
+    }, delay, undefined, true);
+  }
+  handleEvents(events, eventTypes) {
+    const LAZY_REFRESH_DELAY = 1800;
+    const address = this.state.keyringService.context.currentAccount.proxyId;
+    const hasImmediateEvent = IMMEDIATE_EVENTS.some(event => eventTypes.includes(event));
+    const hasLazyEvent = LAZY_EVENTS.some(event => eventTypes.includes(event));
+    const needsNftUpdate = this.checkIfNftUpdateNeeded(events, eventTypes);
+    if (hasImmediateEvent || needsNftUpdate) {
+      this.handleImmediateRefresh(address);
+      return;
+    }
+    if (hasLazyEvent) {
+      this.scheduleLazyRefresh(LAZY_REFRESH_DELAY);
     }
   }
-  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');
+  async fetchFullListNftOfACollection(request) {
+    if (this.isReloading) {
       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);
-        }
-      }
+      const result = await this.multiChainFetcher.fetchFullListNftOfACollection(request);
+
+      // Persist DB
+      this.persistNftData({
+        items: result.items,
+        collections: result.collections
+      });
       return true;
-    } catch (err) {
-      console.error(`[NftDetectionService] getFullNftInstancesByCollection error for ${contractAddress}`, err);
+    } catch (e) {
+      console.error('[NftServiceV2] fetchFullListNftOfaCollection failed', e);
       return false;
     }
   }
+  async fetchNftDetail(request) {
+    if (this.isReloading) {
+      return null;
+    }
+    try {
+      const result = await this.multiChainFetcher.fetchNftDetail(request);
+      return result.items[0];
+    } catch (e) {
+      console.error('[NftServiceV2] fetchNftDetail failed', e);
+      return null;
+    }
+  }
+  startScanNft() {
+    this.stopScanNft();
+    const scanNft = () => {
+      if (!this.isStarted || this.isReloading) {
+        return;
+      }
+      this.refreshNftData().catch(console.error);
+    };
+    this._intervalFetchNft = setInterval(scanNft, this.NFT_INTERVAL_TIME);
+  }
+  stopScanNft() {
+    this._intervalFetchNft && clearInterval(this._intervalFetchNft);
+    this._intervalFetchNft = undefined;
+  }
+  persistNftData(result) {
+    try {
+      for (const item of result.items) {
+        const sender = _uiKeyring.default.getPair(item.owner);
+        this.state.updateNftData(item.chain, item, sender.address || item.owner);
+      }
+      for (const col of result.collections) {
+        this.state.setNftCollection(col.chain, col);
+      }
+    } catch (error) {
+      console.error('[NftServiceV2] Persist failed:', error);
+    }
+  }
+  async refreshNftData() {
+    if (this.isReloading) {
+      return;
+    }
+    this.isReloading = true;
+    try {
+      const addresses = this.state.keyringService.context.getDecodedAddresses();
+      const activeChains = Object.keys(this.state.getActiveChainInfoMap());
+      if (addresses.length === 0 || activeChains.length === 0) {
+        this.nftStateSubject.next(INITIAL_NFT_STATE);
+        return;
+      }
+      const result = await this.multiChainFetcher.fetch(addresses, activeChains);
+      this.persistNftData(result);
+      this.nftStateSubject.next({
+        nftData: {
+          total: result.items.length,
+          nftList: result.items
+        },
+        nftCollections: result.collections
+      });
+    } catch (error) {
+      console.error('[NftService] Refresh failed:', error);
+      this.nftStateSubject.next({
+        ...this.nftStateSubject.getValue()
+      });
+    } finally {
+      this.isReloading = false;
+    }
+  }
+
+  /** Subscribe NFT state */
+  subscribeNftItem() {
+    return this.nftState$;
+  }
+  subscribeNftCollection() {
+    const getChains = () => this.state.activeChainSlugs;
+    return this.state.dbService.stores.nftCollection.subscribeNftCollection(getChains);
+  }
+
+  // TODO: Move NFT reset logic to this function after migration is complete
+  async forceReload() {
+    this.isReloading = true;
+    await (0, _utils2.waitTimeout)(1800);
+    this.isReloading = false;
+    await this.refreshNftData().catch(console.error);
+  }
 }
-exports.default = NftService;
+exports.NftService = NftService;

package/cjs/services/nft-service/multi-chain-nft-fetcher.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MultiChainNftFetcher = void 0;
+var _registry = require("@subwallet/extension-base/services/nft-service/nft-handlers/registry");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MultiChainNftFetcher {
+  constructor(state) {
+    this.state = state;
+  }
+  handlerCache = new Map();
+  getOrCreate(chain, desc) {
+    const key = `${chain}:${desc.id}`;
+    let handler = this.handlerCache.get(key);
+    if (!handler) {
+      handler = desc.create(chain, this.state);
+      this.handlerCache.set(key, handler);
+    }
+    return handler;
+  }
+  getHandlersForChain(chainSlug) {
+    const chainInfo = this.state.chainService.getChainInfoByKey(chainSlug);
+    if (!chainInfo) {
+      return [];
+    }
+    return _registry.NFT_HANDLER_REGISTRY.filter(d => d.supports(chainInfo)).map(d => this.getOrCreate(chainSlug, d));
+  }
+  async fetch(addresses, chainSlugs) {
+    const allItems = [];
+    const allCollections = [];
+    const tasks = [];
+    for (const chain of chainSlugs) {
+      const handlers = this.getHandlersForChain(chain);
+      if (handlers.length === 0) {
+        console.warn(`[NftFetcher] No handler for chain: ${chain}`);
+        continue;
+      }
+      for (const handler of handlers) {
+        const handlerAddresses = handler.filterAddresses(addresses);
+        const task = handler.fetchPreview(handlerAddresses).then(result => {
+          allItems.push(...result.items);
+          allCollections.push(...result.collections);
+        }).catch(err => {
+          console.error(`[NftFetcher] Handler failed on ${chain}: handler.id`, err);
+        });
+        tasks.push(task);
+      }
+    }
+    await Promise.all(tasks);
+
+    // DEDUPLICATE
+    // Todo: Move logic DEDUPLICATE to each handler
+    const seenItemIds = new Set();
+    const seenCollectionKeys = new Set();
+    const uniqueItems = [];
+    const uniqueCollections = [];
+    for (const item of allItems) {
+      if (!seenItemIds.has(item.id)) {
+        seenItemIds.add(item.id);
+        uniqueItems.push(item);
+      }
+    }
+    for (const col of allCollections) {
+      const key = `${col.chain}:${col.collectionId}`;
+      if (!seenCollectionKeys.has(key)) {
+        seenCollectionKeys.add(key);
+        uniqueCollections.push(col);
+      }
+    }
+    return {
+      items: uniqueItems,
+      collections: uniqueCollections
+    };
+  }
+  async fetchFullListNftOfACollection(request) {
+    const {
+      chainInfo,
+      collectionId,
+      owners,
+      tokenIds
+    } = request;
+    const items = [];
+    const collections = [];
+    const handlers = this.getHandlersForChain(chainInfo.slug);
+    for (const handler of handlers) {
+      // Todo: Improve the full-list fetch feature
+      // if (!handler.supportsFetchFullNftList) {
+      //   continue;
+      // }
+
+      const handlerOwners = handler.filterAddresses(owners);
+      try {
+        const result = await handler.fetchFullListNftOfACollection({
+          collectionId: collectionId,
+          owners: handlerOwners,
+          tokenIds: tokenIds,
+          chainInfo
+        });
+        items.push(...result.items);
+        collections.push(...result.collections);
+      } catch (e) {
+        console.error('[NftFetcher] fetchCollection failed', e);
+      }
+    }
+    return {
+      items,
+      collections
+    };
+  }
+  async fetchNftDetail(request) {
+    const {
+      chainSlug,
+      collectionId,
+      tokenId
+    } = request;
+    const items = [];
+    const collections = [];
+    const handlers = this.getHandlersForChain(chainSlug);
+    for (const handler of handlers) {
+      // Todo: Improve the detail nft fetch feature
+      // if (!handler.supportsFetchFullNftList) {
+      //   continue;
+      // }
+
+      try {
+        return await handler.fetchNftDetail({
+          collectionId: collectionId,
+          tokenId: tokenId,
+          chainSlug
+        });
+      } catch (e) {
+        console.error('[NftFetcher] fetchCollection failed', e);
+      }
+    }
+    return {
+      items,
+      collections
+    };
+  }
+}
+exports.MultiChainNftFetcher = MultiChainNftFetcher;