@covalenthq/client-sdk 0.1.2 → 0.1.3

package/dist/services/NftService.js

@@ -0,0 +1,981 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NftService = exports.Response = void 0;
+const backoff_1 = require("../util/backoff");
+const ApiHelpers_1 = require("../util/ApiHelpers");
+class ChainCollectionResponse {
+    constructor(data) {
+        this.updated_at = data.updated_at;
+        this.chain_id = data.chain_id;
+        this.chain_name = data.chain_name;
+        this.items = data.items && data.items !== null ? data.items.map((itemData) => new ChainCollectionItem(itemData)) : null;
+        this.pagination = data.pagination && data.pagination !== null ? new Pagination(data.pagination) : null;
+    }
+}
+class ChainCollectionItem {
+    constructor(data) {
+        this.contract_address = data.contract_address;
+        this.contract_name = data.contract_name;
+        this.is_spam = data.is_spam;
+        this.token_total_supply = data.token_total_supply;
+        this.cached_metadata_count = data.cached_metadata_count;
+        this.cached_asset_count = data.cached_asset_count;
+        this.last_scraped_at = data.last_scraped_at;
+    }
+}
+class Pagination {
+    constructor(data) {
+        this.has_more = data.has_more;
+        this.page_number = data.page_number;
+        this.page_size = data.page_size;
+        this.total_count = data.total_count;
+    }
+}
+class NftAddressBalanceNftResponse {
+    constructor(data) {
+        this.address = data.address;
+        this.updated_at = data.updated_at;
+        this.items = data.items && data.items !== null ? data.items.map((itemData) => new NftTokenContractBalanceItem(itemData)) : null;
+    }
+}
+class NftTokenContractBalanceItem {
+    constructor(data) {
+        this.contract_name = data.contract_name;
+        this.contract_ticker_symbol = data.contract_ticker_symbol;
+        this.contract_address = data.contract_address;
+        this.supports_erc = data.supports_erc;
+        this.is_spam = data.is_spam;
+        this.last_transfered_at = data.last_transfered_at;
+        this.balance = data.balance !== null ? BigInt(data.balance) : null;
+        this.balance24h = data.balance24h;
+        this.type = data.type;
+        this.nft_data = data.nft_data && data.nft_data !== null ? data.nft_data.map((itemData) => new NftData(itemData)) : null;
+    }
+}
+class NftData {
+    constructor(data) {
+        this.token_id = data.token_id !== null ? BigInt(data.token_id) : null;
+        this.token_url = data.token_url;
+        this.original_owner = data.original_owner;
+        this.asset_cached = data.asset_cached;
+        this.image_cached = data.image_cached;
+        this.external_data = data.external_data && data.external_data !== null ? new NftExternalData(data.external_data) : null;
+    }
+}
+class NftExternalData {
+    constructor(data) {
+        this.name = data.name;
+        this.description = data.description;
+        this.asset_url = data.asset_url;
+        this.asset_file_extension = data.asset_file_extension;
+        this.asset_mime_type = data.asset_mime_type;
+        this.asset_size_bytes = data.asset_size_bytes;
+        this.image = data.image;
+        this.image_256 = data.image_256;
+        this.image_512 = data.image_512;
+        this.image_1024 = data.image_1024;
+        this.animation_url = data.animation_url;
+        this.external_url = data.external_url;
+        this.attributes = data.attributes && data.attributes !== null ? data.attributes.map((itemData) => new NftCollectionAttribute(itemData)) : null;
+    }
+}
+class NftCollectionAttribute {
+    constructor(data) {
+        this.trait_type = data.trait_type;
+        this.value = data.value;
+    }
+}
+class NftMetadataResponse {
+    constructor(data) {
+        this.updated_at = data.updated_at;
+        this.items = data.items && data.items !== null ? data.items.map((itemData) => new NftTokenContract(itemData)) : null;
+        this.pagination = data.pagination && data.pagination !== null ? new Pagination(data.pagination) : null;
+    }
+}
+class NftTokenContract {
+    constructor(data) {
+        this.contract_name = data.contract_name;
+        this.contract_ticker_symbol = data.contract_ticker_symbol;
+        this.contract_address = data.contract_address;
+        this.is_spam = data.is_spam;
+        this.type = data.type;
+        this.nft_data = data.nft_data && data.nft_data !== null ? new NftData(data.nft_data) : null;
+    }
+}
+class NftTransactionsResponse {
+    constructor(data) {
+        this.updated_at = data.updated_at;
+        this.chain_id = data.chain_id;
+        this.chain_name = data.chain_name;
+        this.items = data.items && data.items !== null ? data.items.map((itemData) => new NftTransaction(itemData)) : null;
+    }
+}
+class NftTransaction {
+    constructor(data) {
+        this.contract_decimals = data.contract_decimals;
+        this.contract_name = data.contract_name;
+        this.contract_ticker_symbol = data.contract_ticker_symbol;
+        this.logo_url = data.logo_url;
+        this.contract_address = data.contract_address;
+        this.supports_erc = data.supports_erc;
+        this.is_spam = data.is_spam;
+        this.nft_transactions = data.nft_transactions && data.nft_transactions !== null ? data.nft_transactions.map((itemData) => new NftTransactionItem(itemData)) : null;
+    }
+}
+class NftTransactionItem {
+    constructor(data) {
+        this.block_signed_at = data.block_signed_at;
+        this.block_height = data.block_height;
+        this.tx_hash = data.tx_hash;
+        this.tx_offset = data.tx_offset;
+        this.successful = data.successful;
+        this.from_address = data.from_address;
+        this.from_address_label = data.from_address_label;
+        this.to_address = data.to_address;
+        this.to_address_label = data.to_address_label;
+        this.value = data.value !== null ? BigInt(data.value) : null;
+        this.value_quote = data.value_quote;
+        this.pretty_value_quote = data.pretty_value_quote;
+        this.gas_offered = data.gas_offered;
+        this.gas_spent = data.gas_spent;
+        this.gas_price = data.gas_price;
+        this.fees_paid = data.fees_paid !== null ? BigInt(data.fees_paid) : null;
+        this.gas_quote = data.gas_quote;
+        this.pretty_gas_quote = data.pretty_gas_quote;
+        this.gas_quote_rate = data.gas_quote_rate;
+        this.log_events = data.log_events && data.log_events !== null ? data.log_events.map((itemData) => new LogEvent(itemData)) : null;
+    }
+}
+class LogEvent {
+    constructor(data) {
+        this.block_signed_at = data.block_signed_at;
+        this.block_height = data.block_height;
+        this.tx_offset = data.tx_offset;
+        this.log_offset = data.log_offset;
+        this.tx_hash = data.tx_hash;
+        this.raw_log_topics = data.raw_log_topics;
+        this.sender_contract_decimals = data.sender_contract_decimals;
+        this.sender_name = data.sender_name;
+        this.sender_contract_ticker_symbol = data.sender_contract_ticker_symbol;
+        this.sender_address = data.sender_address;
+        this.sender_address_label = data.sender_address_label;
+        this.sender_logo_url = data.sender_logo_url;
+        this.raw_log_data = data.raw_log_data;
+        this.decoded = data.decoded && data.decoded !== null ? new DecodedItem(data.decoded) : null;
+    }
+}
+class DecodedItem {
+    constructor(data) {
+        this.name = data.name;
+        this.signature = data.signature;
+        this.params = data.params && data.params !== null ? data.params.map((itemData) => new Param(itemData)) : null;
+    }
+}
+class Param {
+    constructor(data) {
+        this.name = data.name;
+        this.type = data.type;
+        this.indexed = data.indexed;
+        this.decoded = data.decoded;
+        this.value = data.value;
+    }
+}
+class NftCollectionTraitsResponse {
+    constructor(data) {
+        this.updated_at = data.updated_at;
+        this.items = data.items && data.items !== null ? data.items.map((itemData) => new NftTrait(itemData)) : null;
+    }
+}
+class NftTrait {
+    constructor(data) {
+        this.name = data.name;
+    }
+}
+class NftCollectionAttributesForTraitResponse {
+    constructor(data) {
+        this.updated_at = data.updated_at;
+        this.items = data.items && data.items !== null ? data.items.map((itemData) => new NftSummaryAttribute(itemData)) : null;
+    }
+}
+class NftSummaryAttribute {
+    constructor(data) {
+        this.trait_type = data.trait_type;
+        this.unique_values = data.unique_values;
+        this.values = data.values && data.values !== null ? data.values.map((itemData) => new NftAttribute(itemData)) : null;
+    }
+}
+class NftAttribute {
+    constructor(data) {
+        this.value = data.value;
+        this.count = data.count;
+    }
+}
+class NftCollectionTraitSummaryResponse {
+    constructor(data) {
+        this.updated_at = data.updated_at;
+        this.items = data.items && data.items !== null ? data.items.map((itemData) => new NftTraitSummary(itemData)) : null;
+    }
+}
+class NftTraitSummary {
+    constructor(data) {
+        this.name = data.name;
+        this.value_type = data.value_type;
+        this.value_numeric = data.value_numeric && data.value_numeric !== null ? new NftTraitNumeric(data.value_numeric) : null;
+        this.value_string = data.value_string && data.value_string !== null ? new NftTraitString(data.value_string) : null;
+        this.attributes = data.attributes && data.attributes !== null ? data.attributes.map((itemData) => new NftSummaryAttribute(itemData)) : null;
+    }
+}
+class NftTraitNumeric {
+    constructor(data) {
+        this.min = data.min;
+        this.max = data.max;
+    }
+}
+class NftTraitString {
+    constructor(data) {
+        this.value = data.value;
+        this.token_count = data.token_count;
+        this.trait_percentage = data.trait_percentage;
+    }
+}
+class NftOwnershipForCollectionResponse {
+    constructor(data) {
+        this.updated_at = data.updated_at;
+        this.address = data.address;
+        this.collection = data.collection;
+        this.is_spam = data.is_spam;
+        this.items = data.items && data.items !== null ? data.items.map((itemData) => new NftOwnershipForCollectionItem(itemData)) : null;
+    }
+}
+class NftOwnershipForCollectionItem {
+    constructor(data) {
+        this.contract_name = data.contract_name;
+        this.contract_ticker_symbol = data.contract_ticker_symbol;
+        this.contract_address = data.contract_address;
+        this.token_id = data.token_id !== null ? BigInt(data.token_id) : null;
+        this.supports_erc = data.supports_erc;
+        this.last_transfered_at = data.last_transfered_at;
+        this.balance = data.balance !== null ? BigInt(data.balance) : null;
+        this.balance24h = data.balance24h;
+        this.type = data.type;
+        this.nft_data = data.nft_data && data.nft_data !== null ? new NftData(data.nft_data) : null;
+    }
+}
+/**
+ * NFT APIs
+ *
+ */
+class Response {
+}
+exports.Response = Response;
+class NftService {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {number} pageSize - Number of items on a page.
+     * @param {number} pageNumber - 0-indexed page number to begin pagination.
+     * @param {boolean} noSpam - If `true`, the suspected spam tokens are removed. Supports `eth-mainnet` and `matic-mainnet`.
+     *
+     */
+    async getChainCollections(chainName, pageSize, pageNumber, noSpam) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                if (pageSize !== undefined) {
+                    urlParams.append("page-size", pageSize.toString());
+                }
+                if (pageNumber !== undefined) {
+                    urlParams.append("page-number", pageNumber.toString());
+                }
+                if (noSpam !== undefined) {
+                    urlParams.append("no-spam", noSpam.toString());
+                }
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/nft/collections/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new ChainCollectionResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} walletAddress - The requested address. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     * @param {boolean} noSpam - If `true`, the suspected spam tokens are removed. Supports `eth-mainnet` and `matic-mainnet`.
+     * @param {boolean} noNftAssetMetadata - If `true`, the response shape is limited to a list of collections and token ids, omitting metadata and asset information. Helpful for faster response times and wallets holding a large number of NFTs.
+     * @param {boolean} withUncached - By defaut, this endpoint only works on chains where we've cached the assets and the metadata. When set to `true`, the API will fetch metadata from upstream servers even if it's not cached - the downside being that the upstream server can block or rate limit the call and therefore resulting in time outs or slow response times on the Covalent side.
+     *
+     */
+    async getNftsForAddress(chainName, walletAddress, noSpam, noNftAssetMetadata, withUncached) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                if (noSpam !== undefined) {
+                    urlParams.append("no-spam", noSpam.toString());
+                }
+                if (noNftAssetMetadata !== undefined) {
+                    urlParams.append("no-nft-asset-metadata", noNftAssetMetadata.toString());
+                }
+                if (withUncached !== undefined) {
+                    urlParams.append("with-uncached", withUncached.toString());
+                }
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/address/${walletAddress}/balances_nft/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftAddressBalanceNftResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} contractAddress - The requested NFT contract. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     * @param {boolean} noMetadata - Omit metadata.
+     * @param {number} pageSize - Number of items on a page.
+     * @param {number} pageNumber - 0-indexed page number to begin pagination.
+     * @param {string} traitsFilter - Filters NFTs based on a specific trait. If this filter is used, the API will return all NFTs with the specified trait. Accepts comma-separated values, is case-sensitive, and requires proper URL encoding.
+     * @param {string} valuesFilter - Filters NFTs based on a specific trait value. If this filter is used, the API will return all NFTs with the specified trait value. If used with "traits-filter", only NFTs matching both filters will be returned. Accepts comma-separated values, is case-sensitive, and requires proper URL encoding.
+     * @param {boolean} withUncached - By defaut, this endpoint only works on chains where we've cached the assets and the metadata. When set to `true`, the API will fetch metadata from upstream servers even if it's not cached - the downside being that the upstream server can block or rate limit the call and therefore resulting in time outs or slow response times on the Covalent side.
+     *
+     */
+    async getTokenIdsForContractWithMetadata(chainName, contractAddress, noMetadata, pageSize, pageNumber, traitsFilter, valuesFilter, withUncached) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                if (noMetadata !== undefined) {
+                    urlParams.append("no-metadata", noMetadata.toString());
+                }
+                if (pageSize !== undefined) {
+                    urlParams.append("page-size", pageSize.toString());
+                }
+                if (pageNumber !== undefined) {
+                    urlParams.append("page-number", pageNumber.toString());
+                }
+                if (traitsFilter !== undefined) {
+                    urlParams.append("traits-filter", traitsFilter.toString());
+                }
+                if (valuesFilter !== undefined) {
+                    urlParams.append("values-filter", valuesFilter.toString());
+                }
+                if (withUncached !== undefined) {
+                    urlParams.append("with-uncached", withUncached.toString());
+                }
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/nft/${contractAddress}/metadata/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftMetadataResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} contractAddress - The requested NFT contract. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     * @param {boolean} noMetadata - Omit metadata.
+     * @param {boolean} withUncached - By defaut, this endpoint only works on chains where we've cached the assets and the metadata. When set to `true`, the API will fetch metadata from upstream servers even if it's not cached - the downside being that the upstream server can block or rate limit the call and therefore resulting in time outs or slow response times on the Covalent side.
+     * @param {string} tokenId - The requested token ID.
+     *
+     */
+    async getNftMetadataForGivenTokenIDForContract(chainName, contractAddress, tokenId, noMetadata, withUncached) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                if (noMetadata !== undefined) {
+                    urlParams.append("no-metadata", noMetadata.toString());
+                }
+                if (withUncached !== undefined) {
+                    urlParams.append("with-uncached", withUncached.toString());
+                }
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/nft/${contractAddress}/metadata/${tokenId}/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftMetadataResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} contractAddress - The requested NFT contract address. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     * @param {string} tokenId - The requested token ID.
+     * @param {boolean} noSpam - If `true`, the suspected spam tokens are removed. Supports `eth-mainnet` and `matic-mainnet`.
+     *
+     */
+    async getNftTransactionsForContractTokenId(chainName, contractAddress, tokenId, noSpam) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                if (noSpam !== undefined) {
+                    urlParams.append("no-spam", noSpam.toString());
+                }
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/tokens/${contractAddress}/nft_transactions/${tokenId}/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftTransactionsResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} collectionContract - The requested collection address. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     *
+     */
+    async getTraitsForCollection(chainName, collectionContract) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/nft/${collectionContract}/traits/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftCollectionTraitsResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} collectionContract - The requested collection address. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     * @param {string} trait - The requested trait.
+     *
+     */
+    async getAttributesForTraitInCollection(chainName, collectionContract, trait) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/nft/${collectionContract}/traits/${trait}/attributes/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftCollectionAttributesForTraitResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} collectionContract - The requested collection address. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     *
+     */
+    async getCollectionTraitsSummary(chainName, collectionContract) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/nft/${collectionContract}/traits_summary/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftCollectionTraitSummaryResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} walletAddress - The requested address. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     * @param {string} collectionContract - The requested collection address.
+     *
+     */
+    async checkOwnershipInNft(chainName, walletAddress, collectionContract) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/address/${walletAddress}/collection/${collectionContract}/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftOwnershipForCollectionResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} walletAddress - The requested address. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     * @param {string} collectionContract - The requested collection address. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     * @param {string} tokenId - The requested token ID.
+     *
+     */
+    async checkOwnershipInNftForSpecificTokenId(chainName, walletAddress, collectionContract, tokenId) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/address/${walletAddress}/collection/${collectionContract}/token/${tokenId}/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftOwnershipForCollectionResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+    /**
+     *
+     * @param {string} chainName - The chain name eg: `eth-mainnet`.
+     * @param {string} contractAddress - The requested NFT contract. Passing in an `ENS`, `RNS`, `Lens Handle`, or an `Unstoppable Domain` resolves automatically.
+     * @param {string} tokenId - The requested token ID.
+     *
+     */
+    async getNftExternalMetadataForContract(chainName, contractAddress, tokenId) {
+        let success = false;
+        let data;
+        let response;
+        const backoff = new backoff_1.ExponentialBackoff();
+        while (!success) {
+            try {
+                const urlParams = new URLSearchParams();
+                response = await fetch(`https://api.covalenthq.com/v1/${chainName}/tokens/${contractAddress}/nft_metadata/${tokenId}/?${urlParams}`, {
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`
+                    }
+                });
+                data = await response.json();
+                if (data.error && data.error_code === 429) {
+                    try {
+                        await backoff.backOff();
+                    }
+                    catch (error) {
+                        (0, ApiHelpers_1.checkAndModifyResponse)(data);
+                        success = true;
+                        return {
+                            data: null,
+                            error: data.error,
+                            error_code: data ? data.error_code : response.status,
+                            error_message: data ? data.error_message : "401 Authorization Required"
+                        };
+                    }
+                }
+                else {
+                    const dataClass = new NftMetadataResponse(data.data);
+                    (0, ApiHelpers_1.checkAndModifyResponse)(dataClass);
+                    success = true;
+                    return {
+                        data: dataClass,
+                        error: data.error,
+                        error_code: data ? data.error_code : response.status,
+                        error_message: data ? data.error_message : "401 Authorization Required"
+                    };
+                }
+            }
+            catch (error) {
+                success = true;
+                return {
+                    data: null,
+                    error: true,
+                    error_code: data ? data.error_code : response.status,
+                    error_message: data ? data.error_message : "401 Authorization Required"
+                };
+            }
+        }
+    }
+}
+exports.NftService = NftService;
+//# sourceMappingURL=NftService.js.map