@subwallet/extension-base 0.8.4-0 → 1.0.1

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

@@ -0,0 +1,252 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { RMRK_VER } from '@subwallet/extension-base/background/KoniTypes';
+import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
+import { isUrl, reformatAddress } from '@subwallet/extension-base/utils';
+import fetch from 'cross-fetch';
+import { getRandomIpfsGateway, SINGULAR_V1_COLLECTION_ENDPOINT, SINGULAR_V1_ENDPOINT, SINGULAR_V2_COLLECTION_ENDPOINT, SINGULAR_V2_ENDPOINT } from "../config.js";
+var RMRK_SOURCE;
+(function (RMRK_SOURCE) {
+  RMRK_SOURCE["BIRD_KANARIA"] = "bird_kanaria";
+  RMRK_SOURCE["KANARIA"] = "kanaria";
+  RMRK_SOURCE["SINGULAR_V1"] = "singular_v1";
+  RMRK_SOURCE["SINGULAR_V2"] = "singular_v2";
+})(RMRK_SOURCE || (RMRK_SOURCE = {}));
+const KANBIRD_KEYWORD = 'KANBIRD';
+export class RmrkNftApi extends BaseNftApi {
+  constructor(addresses, chain) {
+    super(chain, null, addresses);
+  }
+  parseUrl(input) {
+    if (!input || input.length === 0) {
+      return undefined;
+    }
+    if (isUrl(input) || input.includes('https://') || input.includes('http')) {
+      return input;
+    }
+    if (!input.includes('ipfs://ipfs/')) {
+      return getRandomIpfsGateway() + input;
+    }
+    return getRandomIpfsGateway() + input.split('ipfs://ipfs/')[1];
+  }
+  async getMetadata(metadataUrl) {
+    let url = metadataUrl;
+    if (!isUrl(metadataUrl)) {
+      url = this.parseUrl(metadataUrl);
+      if (!url || url.length === 0) {
+        return undefined;
+      }
+    }
+    return await fetch(url, {
+      method: 'GET'
+    }).then(res => res.json());
+  }
+  async getAllByAccount(account) {
+    const fetchUrls = [{
+      url: SINGULAR_V1_ENDPOINT + account,
+      source: RMRK_SOURCE.SINGULAR_V1
+    }, {
+      url: SINGULAR_V2_ENDPOINT + account,
+      source: RMRK_SOURCE.SINGULAR_V2
+    }];
+    let data = [];
+    await Promise.all(fetchUrls.map(async ({
+      source,
+      url
+    }) => {
+      let _data = await fetch(url, {
+        method: 'GET'
+      }).then(res => res.json());
+      _data = _data.map(item => {
+        let nftSource = source;
+        if (item.collectionId.includes(KANBIRD_KEYWORD)) {
+          nftSource = RMRK_SOURCE.BIRD_KANARIA;
+        }
+        return {
+          ...item,
+          source: nftSource
+        };
+      });
+      data = data.concat(_data);
+    }));
+    const nfts = [];
+    await Promise.all(data.map(async item => {
+      const primaryResource = item.primaryResource ? item.primaryResource : null;
+      const metadataUri = primaryResource && primaryResource.metadata ? primaryResource.metadata : item.metadata;
+      const nftMetadata = await this.getMetadata(metadataUri);
+      if (item.source === RMRK_SOURCE.BIRD_KANARIA) {
+        nfts.push({
+          ...item,
+          metadata: nftMetadata,
+          owner: account
+        });
+      } else if (item.source === RMRK_SOURCE.KANARIA) {
+        nfts.push({
+          ...item,
+          metadata: {
+            ...nftMetadata,
+            image: this.parseUrl(nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.image)
+          },
+          owner: account
+        });
+      } else if (item.source === RMRK_SOURCE.SINGULAR_V1) {
+        nfts.push({
+          ...item,
+          metadata: {
+            description: nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.description,
+            name: nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.name,
+            attributes: nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.attributes,
+            animation_url: this.parseUrl(nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.animation_url),
+            image: this.parseUrl(nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.image)
+          },
+          owner: account
+        });
+      } else if (item.source === RMRK_SOURCE.SINGULAR_V2) {
+        const id = item.id;
+        if (!id.toLowerCase().includes(KANBIRD_KEYWORD)) {
+          // excludes kanaria bird, already handled above
+          nfts.push({
+            ...item,
+            metadata: {
+              description: nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.description,
+              name: nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.name,
+              attributes: nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.attributes,
+              properties: nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.properties,
+              animation_url: this.parseUrl(nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.animation_url),
+              image: this.parseUrl(nftMetadata === null || nftMetadata === void 0 ? void 0 : nftMetadata.mediaUri)
+            },
+            owner: account
+          });
+        }
+      }
+    }));
+    return nfts;
+  }
+  async handleNft(address, params) {
+    // const start = performance.now();
+
+    let allNfts = [];
+    const allCollections = [];
+    try {
+      const kusamaAddress = reformatAddress(address, 2);
+      allNfts = await this.getAllByAccount(kusamaAddress);
+      if (allNfts.length <= 0) {
+        return;
+      }
+      const collectionInfoUrl = [];
+      for (const item of allNfts) {
+        var _item$metadata, _item$metadata2, _item$metadata3;
+        const parsedItem = {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          id: item === null || item === void 0 ? void 0 : item.id,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          name: item === null || item === void 0 ? void 0 : (_item$metadata = item.metadata) === null || _item$metadata === void 0 ? void 0 : _item$metadata.name,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-argument
+          image: this.parseUrl(item.image ? item.image : item.metadata.image ? item.metadata.image : item.metadata.animation_url),
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          description: item === null || item === void 0 ? void 0 : (_item$metadata2 = item.metadata) === null || _item$metadata2 === void 0 ? void 0 : _item$metadata2.description,
+          externalUrl: item === null || item === void 0 ? void 0 : item.external_url,
+          rarity: item === null || item === void 0 ? void 0 : item.metadata_rarity,
+          collectionId: item === null || item === void 0 ? void 0 : item.collectionId,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          properties: item === null || item === void 0 ? void 0 : (_item$metadata3 = item.metadata) === null || _item$metadata3 === void 0 ? void 0 : _item$metadata3.properties,
+          chain: this.chain,
+          rmrk_ver: item.source && item.source === RMRK_SOURCE.SINGULAR_V1 ? RMRK_VER.VER_1 : RMRK_VER.VER_2,
+          owner: item.owner
+        };
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        params.updateItem(this.chain, parsedItem, address);
+        let url = '';
+        if (item.source === RMRK_SOURCE.SINGULAR_V1) {
+          url = SINGULAR_V1_COLLECTION_ENDPOINT + item.collectionId;
+        } else {
+          url = SINGULAR_V2_COLLECTION_ENDPOINT + item.collectionId;
+        }
+        if (!collectionInfoUrl.includes(url)) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          allCollections.push({
+            chain: '',
+            collectionId: item.collectionId
+          });
+          collectionInfoUrl.push(url.replace(' ', '%20'));
+        }
+      }
+      const allCollectionMetaUrl = [];
+      await Promise.all(collectionInfoUrl.map(async url => {
+        try {
+          const data = await fetch(url, {
+            method: 'GET'
+          }).then(resp => resp.json());
+          const result = data[0];
+          if (result && 'metadata' in result) {
+            allCollectionMetaUrl.push({
+              url: this.parseUrl(result === null || result === void 0 ? void 0 : result.metadata),
+              id: result === null || result === void 0 ? void 0 : result.id
+            });
+          }
+          if (data.length > 0) {
+            return result;
+          } else {
+            return {};
+          }
+        } catch (e) {
+          console.error('error fetching collection info', url);
+          return {};
+        }
+      }));
+      const allCollectionMeta = {};
+      await Promise.all(allCollectionMetaUrl.map(async item => {
+        let data = {};
+        try {
+          if (item.url) {
+            data = await fetch(item === null || item === void 0 ? void 0 : item.url, {
+              method: 'GET'
+            }).then(resp => resp.json());
+          }
+          if ('mediaUri' in data) {
+            // rmrk v2.0
+            // @ts-ignore
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            allCollectionMeta[item === null || item === void 0 ? void 0 : item.id] = {
+              ...data,
+              image: data.mediaUri
+            };
+          } else {
+            allCollectionMeta[item === null || item === void 0 ? void 0 : item.id] = {
+              ...data
+            };
+          }
+        } catch (e) {
+          console.error('error parsing JSON for RMRK ', item.url, e);
+        }
+      }));
+      allCollections.forEach(item => {
+        const parsedCollection = {
+          collectionId: item.collectionId,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          collectionName: allCollectionMeta[item.collectionId] ? allCollectionMeta[item.collectionId].name : null,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          image: allCollectionMeta[item.collectionId] ? this.parseUrl(allCollectionMeta[item.collectionId].image) : null,
+          chain: this.chain
+        };
+        params.updateCollection(this.chain, parsedCollection);
+        // params.updateReady(true);
+      });
+    } catch (e) {
+      console.error('Failed to fetch rmrk nft', e);
+    }
+  }
+  async handleNfts(params) {
+    await Promise.all(this.addresses.map(address => this.handleNft(address, params)));
+  }
+  async fetchNfts(params) {
+    try {
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+}

package/koni/api/nft/statemine_nft/index.d.ts

@@ -0,0 +1,18 @@
+import { BaseNftApi, HandleNftParams } from '@subwallet/extension-base/koni/api/nft/nft';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export default class StatemineNftApi extends BaseNftApi {
+    constructor(api: _SubstrateApi | null, addresses: string[], chain: string);
+    private getMetadata;
+    /**
+     * Retrieve id of NFTs
+     *
+     * @returns the array of NFT Ids
+     * @param addresses
+     */
+    private getNfts;
+    private getTokenDetails;
+    private getCollectionDetail;
+    handleNft(address: string, params: HandleNftParams): Promise<void>;
+    handleNfts(params: HandleNftParams): Promise<void>;
+    fetchNfts(params: HandleNftParams): Promise<number>;
+}

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

@@ -0,0 +1,136 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BaseNftApi } from '@subwallet/extension-base/koni/api/nft/nft';
+import { isUrl } from '@subwallet/extension-base/utils';
+import fetch from 'cross-fetch';
+export default class StatemineNftApi extends BaseNftApi {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(api, addresses, chain) {
+    super(chain, api, addresses);
+  }
+  getMetadata(metadataUrl) {
+    let url = metadataUrl;
+    if (!isUrl(metadataUrl)) {
+      url = this.parseUrl(metadataUrl);
+      if (!url || url.length === 0) {
+        return undefined;
+      }
+    }
+    return fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }).then(res => res.json());
+  }
+
+  /**
+   * Retrieve id of NFTs
+   *
+   * @returns the array of NFT Ids
+   * @param addresses
+   */
+  async getNfts(addresses) {
+    if (!this.substrateApi) {
+      return [];
+    }
+    const assetIds = [];
+    await Promise.all(addresses.map(async address => {
+      // @ts-ignore
+      const resp = await this.substrateApi.api.query.uniques.account.keys(address);
+      if (resp) {
+        for (const key of resp) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          const data = key.toHuman();
+          assetIds.push({
+            classId: data[1],
+            tokenId: this.parseTokenId(data[2])
+          });
+        }
+      }
+    }));
+    return assetIds;
+  }
+  async getTokenDetails(assetId) {
+    if (!this.substrateApi) {
+      return null;
+    }
+    const {
+      classId,
+      tokenId
+    } = assetId;
+    const metadataNft = (await this.substrateApi.api.query.uniques.instanceMetadataOf(this.parseTokenId(classId), this.parseTokenId(tokenId))).toHuman();
+    if (!(metadataNft !== null && metadataNft !== void 0 && metadataNft.data)) {
+      return null;
+    }
+
+    // @ts-ignore
+    return this.getMetadata(metadataNft === null || metadataNft === void 0 ? void 0 : metadataNft.data);
+  }
+  async getCollectionDetail(collectionId) {
+    if (!this.substrateApi) {
+      return null;
+    }
+    const collectionMetadata = (await this.substrateApi.api.query.uniques.classMetadataOf(collectionId)).toHuman();
+    if (!(collectionMetadata !== null && collectionMetadata !== void 0 && collectionMetadata.data)) {
+      return null;
+    }
+
+    // @ts-ignore
+    return this.getMetadata(collectionMetadata === null || collectionMetadata === void 0 ? void 0 : collectionMetadata.data);
+  }
+  async handleNft(address, params) {
+    // const start = performance.now();
+
+    const assetIds = await this.getNfts([address]);
+    try {
+      if (!assetIds || assetIds.length === 0) {
+        return;
+      }
+      const collectionNftIds = {};
+      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];
+        }
+        const [tokenInfo, collectionMeta] = await Promise.all([this.getTokenDetails(assetId), this.getCollectionDetail(parseInt(parsedClassId))]);
+        const parsedNft = {
+          id: parsedTokenId,
+          name: tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.name,
+          description: tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.description,
+          image: tokenInfo && tokenInfo.image ? this.parseUrl(tokenInfo === null || tokenInfo === void 0 ? void 0 : tokenInfo.image) : undefined,
+          collectionId: this.parseTokenId(parsedClassId),
+          chain: this.chain,
+          owner: address
+        };
+        params.updateItem(this.chain, parsedNft, address);
+        const parsedCollection = {
+          collectionId: parsedClassId,
+          chain: this.chain,
+          collectionName: collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.name,
+          image: collectionMeta && collectionMeta.image ? this.parseUrl(collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.image) : undefined
+        };
+        params.updateCollection(this.chain, parsedCollection);
+        // params.updateReady(true);
+      }));
+    } catch (e) {
+      console.error('Failed to fetch statemine nft', e);
+    }
+  }
+  async handleNfts(params) {
+    await Promise.all(this.addresses.map(address => this.handleNft(address, params)));
+  }
+  async fetchNfts(params) {
+    try {
+      await this.connect();
+      await this.handleNfts(params);
+    } catch (e) {
+      return 0;
+    }
+    return 1;
+  }
+}

package/koni/api/nft/transfer.d.ts

@@ -0,0 +1,8 @@
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function isRecipientSelf(currentAddress: string, recipientAddress: string): boolean;
+export declare function acalaGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
+export declare function rmrkGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
+export declare function uniqueGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
+export declare function quartzGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
+export declare function statemineGetExtrinsic(substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;
+export declare function getNftTransferExtrinsic(networkKey: string, substrateApi: _SubstrateApi, senderAddress: string, recipientAddress: string, params: Record<string, any>): import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult> | null;

package/koni/api/nft/transfer.js

@@ -0,0 +1,90 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME } from '@subwallet/extension-base/koni/api/nft/config';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+export function isRecipientSelf(currentAddress, recipientAddress) {
+  return reformatAddress(currentAddress, 1) === reformatAddress(recipientAddress, 1);
+}
+export function acalaGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
+  try {
+    const itemId = params.itemId;
+    const collectionId = params.collectionId;
+    return substrateApi.api.tx.nft.transfer(recipientAddress, [collectionId, itemId]);
+  } catch (e) {
+    console.error('error handling acala transfer nft', e);
+    return null;
+  }
+}
+export function rmrkGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
+  try {
+    const remark = params.remark;
+    if (!remark) {
+      return null;
+    }
+    const parsedRemark = remark.concat(recipientAddress.replace(/\\s/g, ''));
+    return substrateApi.api.tx.system.remark(parsedRemark);
+  } catch (e) {
+    console.error('error handling rmrk transfer nft', e);
+    return null;
+  }
+}
+export function uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
+  try {
+    const itemId = params.itemId;
+    const collectionId = params.collectionId;
+    return substrateApi.api.tx.nft.transfer({
+      Substrate: recipientAddress
+    }, collectionId, itemId, 1);
+  } catch (e) {
+    console.error('error handling unique transfer nft', e);
+    return null;
+  }
+}
+export function quartzGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
+  try {
+    const itemId = params.itemId;
+    const collectionId = params.collectionId;
+    return substrateApi.api.tx.unique.transfer({
+      Substrate: recipientAddress
+    }, collectionId, itemId, 1);
+  } catch (e) {
+    console.error('error handling quartz transfer nft', e);
+    return null;
+  }
+}
+export function statemineGetExtrinsic(substrateApi, senderAddress, recipientAddress, params) {
+  try {
+    const itemId = params.itemId;
+    const collectionId = params.collectionId;
+    return substrateApi.api.tx.uniques.transfer(collectionId, itemId, recipientAddress);
+  } catch (e) {
+    console.error('error handling statemine transfer nft', e);
+    return null;
+  }
+}
+export function getNftTransferExtrinsic(networkKey, substrateApi, senderAddress, recipientAddress, params) {
+  switch (networkKey) {
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.acala:
+      return acalaGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.karura:
+      return acalaGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.kusama:
+      return rmrkGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.uniqueNft:
+      return uniqueGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.quartz:
+      return quartzGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.opal:
+      return quartzGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.statemine:
+      return statemineGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.statemint:
+      return statemineGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.bitcountry:
+      return acalaGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+    case SUPPORTED_TRANSFER_SUBSTRATE_CHAIN_NAME.pioneer:
+      return acalaGetExtrinsic(substrateApi, senderAddress, recipientAddress, params);
+  }
+  return null;
+}

package/koni/api/nft/unique_nft/index.d.ts

@@ -0,0 +1,54 @@
+import { BaseNftApi, HandleNftParams } from '@subwallet/extension-base/koni/api/nft/nft';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+interface Collection {
+    SchemaVersion: string;
+    OffchainSchema: string;
+    ConstOnChainSchema: string;
+    TokenPrefix: string;
+    Description: number[];
+    Name: number[];
+}
+export default class UniqueNftApi extends BaseNftApi {
+    constructor(api: _SubstrateApi | null, addresses: string[], chain: string);
+    getCollectionCount(): Promise<number>;
+    /**
+      * Retrieve address of NFTs
+      *
+      * @param collectionId: Id of the collection
+      * @param owner: address of account
+      * @returns the array of NFTs
+      */
+    getAddressTokens(collectionId: number, owner: string): Promise<any>;
+    /**
+     * Retrieve NFT image URL according to the collection offchain schema
+     *
+     * @param collection
+     * @param tokenId: Token ID
+     * @returns the URL of the token image
+     */
+    getNftImageUrl(collection: Collection, tokenId: string): string | undefined;
+    /**
+     * Retrieve and deserialize properties
+     *
+     *
+     * @param collection
+     * @param tokenId: Token ID
+     * @param locale: Output locale (default is "en")
+     * @param collectionId
+     * @returns tokenData: Token data object
+     */
+    getNftData(collection: Collection, tokenId: string, locale: string | undefined, collectionId: number): Promise<{
+        owner: string;
+        prefix: string;
+        collectionName: string;
+        collectionDescription: string;
+        properties: {
+            [k: string]: any;
+        } | null;
+        image: string;
+    } | undefined>;
+    handleNft(address: string, params: HandleNftParams): Promise<void>;
+    handleNfts(params: HandleNftParams): Promise<void>;
+    fetchNfts(params: HandleNftParams): Promise<number>;
+}
+export {};