@quicknode/sdk 1.0.0-beta.1 → 1.1.0

package/esm/package.json

@@ -1,3 +1,4 @@
 {
-  "type": "module"
+  "type": "module",
+  "sideEffects": false
 }

package/esm/package.json.js

@@ -0,0 +1,3 @@
+var name="@quicknode/sdk";var repository={type:"git",url:"https://github.com/quiknode-labs/qn-oss.git",directory:"packages/libs/sdk"};var license="MIT";var version="1.1.0";var main="./cjs/index.js";var module="./esm/src/index.js";var types="./index.d.ts";var sideEffects=false;var dependencies={"@urql/core":"^4.0.7","@urql/exchange-graphcache":"^6.0.4","cross-fetch":"^3.1.6",viem:"^1.2.0",tslib:"^2.5.3",zod:"^3.21.4"};var devDependencies={"@graphql-codegen/cli":"4.0.1","@graphql-codegen/fragment-matcher":"^3.3.1","@graphql-codegen/introspection":"^3.0.1","@graphql-codegen/typed-document-node":"^4.0.1","@graphql-codegen/typescript":"2.8.0","@graphql-codegen/typescript-operations":"^2.5.5","@pollyjs/adapter-node-http":"^6.0.5","@pollyjs/core":"^6.0.5","@pollyjs/persister-fs":"^6.0.5","@types/jest":"^29.5.1","@types/mocha":"^10.0.1","@types/node":"^18.13.0","@types/supertest":"^2.0.12",dotenv:"^16.0.3","eslint-plugin-no-only-tests":"^3.1.0",graphql:"^16.6.0",supertest:"^6.3.3"};var scripts={codegen:"npx graphql-codegen --require dotenv/config"};var exports={".":{"import":"./esm/src/index.js",require:"./cjs/index.js"},"./api":{"import":"./esm/src/api/index.js","default":"./cjs/src/api/index.js",types:"./esm/src/api/index.d.ts"},"./core":{"import":"./esm/src/core/index.js","default":"./cjs/src/core/index.js",types:"./esm/src/core/index.d.ts"}};var typesVersions={"*":{api:["./esm/src/api/index.d.ts"],core:["./esm/src/core/index.d.ts"]}};var packageJson = {name:name,repository:repository,license:license,version:version,main:main,module:module,types:types,sideEffects:sideEffects,dependencies:dependencies,devDependencies:devDependencies,scripts:scripts,exports:exports,typesVersions:typesVersions};
+
+export { packageJson as default, dependencies, devDependencies, exports, license, main, module, name, repository, scripts, sideEffects, types, typesVersions, version };

package/esm/src/api/api.js

@@ -0,0 +1,85 @@
+import fetch from 'cross-fetch';
+import { CustomUrqlClient } from './graphql/customUrqlClient.js';
+import { Client, fetchExchange } from '@urql/core';
+import { cacheExchange } from '@urql/exchange-graphcache';
+import { NftsController } from './controllers/nfts.js';
+import { TokensController } from './controllers/tokens.js';
+import { UtilsController } from './controllers/utils.js';
+import { ContractsController } from './controllers/contracts.js';
+import { EventsController } from './controllers/events.js';
+import { DEFAULT_CHAIN } from './utils/constants.js';
+import schema from './graphql/schema.json.js';
+import { TransactionsController } from './controllers/transactions.js';
+import packageJson from '../../package.json.js';
+
+class API {
+    constructor({ graphApiKey, additionalHeaders, defaultChain, } = {}) {
+        if (!graphApiKey) {
+            console.warn('QuickNode SDK warning: no apiKey provided. Access with no apiKey is heavily rate limited and intended for development use only. For higher rate limits or production usage, create an account on https://www.quicknode.com/');
+        }
+        this.graphApiKey = graphApiKey;
+        this.additionalHeaders = additionalHeaders;
+        this.urqlClient = this.createUrqlClient();
+        this.customUrqlClient = new CustomUrqlClient(this.urqlClient);
+        this.defaultChain = defaultChain || DEFAULT_CHAIN;
+        this.nfts = new NftsController(this.customUrqlClient, this.defaultChain);
+        this.tokens = new TokensController(this.customUrqlClient, this.defaultChain);
+        this.utils = new UtilsController(this.customUrqlClient, this.defaultChain);
+        this.contracts = new ContractsController(this.customUrqlClient, this.defaultChain);
+        this.transactions = new TransactionsController(this.customUrqlClient, this.defaultChain);
+        this.events = new EventsController(this.customUrqlClient, this.defaultChain);
+        // Re-export the Urql client configured to use the Graph API for use with custom queries
+        this.graphApiClient = this.urqlClient;
+    }
+    createUrqlClient() {
+        const headers = { ...this.additionalHeaders };
+        if (this.graphApiKey)
+            headers['x-api-key'] = this.graphApiKey;
+        headers['x-quicknode-sdk'] = 'js-sdk';
+        headers['x-quicknode-sdk-version'] = packageJson?.version || 'n/a';
+        const useNftKey = (data) => `${data['contractAddress']}:${data['tokenId']}`;
+        const useAddressAsKey = (data) => `${data['address']}`;
+        const useTransactionHashAndIndex = (data) => `${data['transactionHash']}:${data['transferIndex']}`;
+        const urqlCache = cacheExchange({
+            schema,
+            keys: {
+                EVMSchemaType: () => null,
+                Collection: useAddressAsKey,
+                CollectionOHLCVChart: () => null,
+                Contract: useAddressAsKey,
+                ERC721NFT: useNftKey,
+                ERC721Collection: useAddressAsKey,
+                ERC1155NFT: useNftKey,
+                ERC1155Collection: useAddressAsKey,
+                GasPrice: () => null,
+                NFT: useNftKey,
+                NFTContract: useAddressAsKey,
+                TokenAttribute: () => null,
+                TokenContract: useAddressAsKey,
+                TokenEvent: useTransactionHashAndIndex,
+                TokenMintEvent: useTransactionHashAndIndex,
+                TokenBurnEvent: useTransactionHashAndIndex,
+                TokenSaleEvent: useTransactionHashAndIndex,
+                TokenSwapEvent: useTransactionHashAndIndex,
+                TokenTransferEvent: useTransactionHashAndIndex,
+                TokenUpload: () => null,
+                OpenSeaMetadata: () => null,
+                Transaction: (data) => `${data['hash']}`,
+                TrendingCollection: () => null,
+                Wallet: (data) => `${data['address']}`,
+                WalletNFT: () => null,
+                WalletTokenBalance: () => null,
+            },
+        });
+        const client = new Client({
+            fetch,
+            url: process.env['NX_GRAPHQL_API_URI'] ||
+                'https://api.quicknode.com/graphql',
+            exchanges: [urqlCache, fetchExchange],
+            fetchOptions: () => ({ headers }),
+        });
+        return client;
+    }
+}
+
+export { API };

package/esm/src/api/controllers/contracts.js

@@ -0,0 +1,36 @@
+import { __decorate, __metadata } from 'tslib';
+import { DEFAULT_CHAIN } from '../utils/constants.js';
+import { contractDetailsValidator } from '../types/contracts/getContractDetails.js';
+import { CodegenEthMainnetContractDetailsDocument, CodegenPolygonMainnetContractDetailsDocument, CodegenEthSepoliaContractDetailsDocument } from '../graphql/generatedTypes.js';
+import { ValidateInput } from '../../lib/validation/ValidateInput.js';
+
+class ContractsController {
+    constructor(client, defaultChain = DEFAULT_CHAIN) {
+        this.client = client;
+        this.defaultChain = defaultChain;
+    }
+    async getDetails(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetContractDetailsDocument,
+            polygon: CodegenPolygonMainnetContractDetailsDocument,
+            ethereumSepolia: CodegenEthSepoliaContractDetailsDocument,
+        };
+        const { data: { [userChain]: { contract }, }, } = await this.client.query({
+            variables: queryVariables,
+            query: query[userChain],
+        });
+        if (contract)
+            return { contract };
+        return { contract: null };
+    }
+}
+__decorate([
+    ValidateInput(contractDetailsValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], ContractsController.prototype, "getDetails", null);
+
+export { ContractsController };

package/esm/src/api/controllers/events.js

@@ -0,0 +1,121 @@
+import { __decorate, __metadata } from 'tslib';
+import { contractEventsValidator } from '../types/events/getByContract.js';
+import { collectionEventsValidator } from '../types/nfts/getCollectionEvents.js';
+import { nftEventsValidator } from '../types/nfts/getNFTEvents.js';
+import { allEventsValidator } from '../types/events/getAll.js';
+import { CodegenEthereumMainnetEventsByContractDocument, CodegenPolygonMainnetEventsByContractDocument, CodegenEthereumSepoliaEventsByContractDocument, CodegenEthMainnetEventsByCollectionDocument, CodegenPolygonMainnetEventsByCollectionDocument, CodegenEthSepoliaEventsByCollectionDocument, CodegenEthereumMainnetEventsByNftDocument, CodegenPolygonMainnetEventsByNftDocument, CodegenEthSepoliaEventsByNftDocument, CodegenEthereumMainnetEventsGetAllDocument, CodegenPolygonMainnetEventsGetAllDocument, CodegenEthereumSepoliaEventsGetAllDocument } from '../graphql/generatedTypes.js';
+import { formatQueryResult } from '../utils/postQueryFormatter.js';
+import { emptyPageInfo } from '../utils/helpers.js';
+import { DEFAULT_CHAIN } from '../utils/constants.js';
+import { ValidateInput } from '../../lib/validation/ValidateInput.js';
+
+class EventsController {
+    constructor(client, defaultChain = DEFAULT_CHAIN) {
+        this.client = client;
+        this.defaultChain = defaultChain;
+    }
+    async getByContract(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthereumMainnetEventsByContractDocument,
+            polygon: CodegenPolygonMainnetEventsByContractDocument,
+            ethereumSepolia: CodegenEthereumSepoliaEventsByContractDocument,
+        };
+        const { data: { [userChain]: { contract }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        if (!contract?.tokenEvents?.length) {
+            return {
+                results: [],
+                pageInfo: emptyPageInfo,
+            };
+        }
+        const formattedResult = formatQueryResult(contract, 'tokenEvents', 'tokenEventsPageInfo');
+        return formattedResult;
+    }
+    async getByNFTCollection(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetEventsByCollectionDocument,
+            polygon: CodegenPolygonMainnetEventsByCollectionDocument,
+            ethereumSepolia: CodegenEthSepoliaEventsByCollectionDocument,
+        };
+        const { data: { [userChain]: { collection }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        if (!collection?.tokenEvents?.length)
+            return { results: [], pageInfo: emptyPageInfo };
+        function removeKeyFields(results) {
+            const { address, ...newResults } = results;
+            return newResults;
+        }
+        const formattedResult = formatQueryResult(collection, 'tokenEvents', 'tokenEventsPageInfo', null, removeKeyFields);
+        return formattedResult;
+    }
+    async getByNFT(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthereumMainnetEventsByNftDocument,
+            polygon: CodegenPolygonMainnetEventsByNftDocument,
+            ethereumSepolia: CodegenEthSepoliaEventsByNftDocument,
+        };
+        const { data: { [userChain]: { nft }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        if (!nft?.tokenEvents?.length)
+            return { results: [], pageInfo: emptyPageInfo };
+        function removeKeyFields(results) {
+            const { contractAddress, tokenId, ...newResults } = results;
+            return newResults;
+        }
+        const formattedResult = formatQueryResult(nft, 'tokenEvents', 'tokenEventsPageInfo', null, removeKeyFields);
+        return formattedResult;
+    }
+    async getAll(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthereumMainnetEventsGetAllDocument,
+            polygon: CodegenPolygonMainnetEventsGetAllDocument,
+            ethereumSepolia: CodegenEthereumSepoliaEventsGetAllDocument,
+        };
+        const { data: { [userChain]: tokenEvents }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        const formattedResult = formatQueryResult(tokenEvents, 'tokenEvents', 'tokenEventsPageInfo');
+        return formattedResult;
+    }
+}
+__decorate([
+    ValidateInput(contractEventsValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EventsController.prototype, "getByContract", null);
+__decorate([
+    ValidateInput(collectionEventsValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EventsController.prototype, "getByNFTCollection", null);
+__decorate([
+    ValidateInput(nftEventsValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EventsController.prototype, "getByNFT", null);
+__decorate([
+    ValidateInput(allEventsValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EventsController.prototype, "getAll", null);
+
+export { EventsController };

package/esm/src/api/controllers/nfts.js

@@ -0,0 +1,244 @@
+import { __decorate, __metadata } from 'tslib';
+import { walletByAddressValidator } from '../types/nfts/getByWalletAddress.js';
+import { nftDetailsValidator } from '../types/nfts/getNFTDetails.js';
+import { nftCollectionDetailsValidator } from '../types/nfts/getCollectionDetails.js';
+import { nftTrendingCollectionsValidator } from '../types/nfts/getTrendingCollections.js';
+import { nftsByContractAddressValidator } from '../types/nfts/getByContractAddress.js';
+import { verifyOwnershipValidator } from '../types/nfts/verifyOwnershipByAddress.js';
+import { CodegenEthMainnetWalletNFTsByEnsDocument, CodegenPolygonMainnetWalletNFTsByEnsDocument, CodegenEthSepoliaWalletNFTsByEnsDocument, CodegenEthMainnetWalletNFTsByAddressDocument, CodegenPolygonMainnetWalletNFTsByAddressDocument, CodegenEthSepoliaWalletNFTsByAddressDocument, CodegenEthMainnetTrendingCollectionsDocument, CodegenPolygonMainnetTrendingCollectionsDocument, CodegenEthSepoliaTrendingCollectionsDocument, CodegenEthMainnetWalletNFTsByContractAddressDocument, CodegenPolygonMainnetNFTsByContractAddressDocument, CodegenEthSepoliaWalletNFTsByContractAddressDocument, CodegenEthMainnetNFTDetailsDocument, CodegenPolygonMainnetNFTDetailsDocument, CodegenEthSepoliaNFTDetailsDocument, CodegenEthMainnetNftCollectionDetailsDocument, CodegenPolygonMainnetNftCollectionDetailsDocument, CodegenEthSepoliaNftCollectionDetailsDocument, CodegenEthMainnetVerifyOwnershipByAddressDocument, CodegenPolygonMainnetVerifyOwnershipByAddressDocument, CodegenEthSepoliaVerifyOwnershipByAddressDocument, CodegenEthMainnetVerifyOwnershipByENSDocument, CodegenPolygonMainnetVerifyOwnershipByENSDocument, CodegenEthSepoliaVerifyOwnershipByENSDocument } from '../graphql/generatedTypes.js';
+import { formatQueryResult } from '../utils/postQueryFormatter.js';
+import { emptyPageInfo } from '../utils/helpers.js';
+import { DEFAULT_CHAIN } from '../utils/constants.js';
+import { isValidENSAddress } from '../utils/isValidENSAddress.js';
+import { ValidateInput } from '../../lib/validation/ValidateInput.js';
+
+class NftsController {
+    constructor(client, defaultChain = DEFAULT_CHAIN) {
+        this.client = client;
+        this.defaultChain = defaultChain;
+    }
+    async getByWallet(variables) {
+        const { address, ...allVariables } = variables;
+        if (isValidENSAddress(address)) {
+            return this.getByWalletENS({
+                ensName: address,
+                ...allVariables,
+            });
+        }
+        return this.getByWalletAddress({
+            address,
+            ...allVariables,
+        });
+    }
+    async getByWalletENS(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetWalletNFTsByEnsDocument,
+            polygon: CodegenPolygonMainnetWalletNFTsByEnsDocument,
+            ethereumSepolia: CodegenEthSepoliaWalletNFTsByEnsDocument,
+        };
+        const { data: { [userChain]: { walletByENS }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        if (!walletByENS?.walletNFTs?.length) {
+            // Address can still be valid ENS name, but not have any NFTs
+            const address = walletByENS?.address || '';
+            const ensName = walletByENS?.ensName || '';
+            return {
+                address: address,
+                ensName: ensName,
+                results: [],
+                pageInfo: emptyPageInfo,
+            };
+        }
+        const formattedResult = formatQueryResult(walletByENS, 'walletNFTs', 'walletNFTsPageInfo', 'nft');
+        return formattedResult;
+    }
+    async getByWalletAddress(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetWalletNFTsByAddressDocument,
+            polygon: CodegenPolygonMainnetWalletNFTsByAddressDocument,
+            ethereumSepolia: CodegenEthSepoliaWalletNFTsByAddressDocument,
+        };
+        const { data: { [userChain]: { walletByAddress }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        if (!walletByAddress?.walletNFTs?.length) {
+            const address = walletByAddress?.address || '';
+            const ensName = walletByAddress?.ensName || '';
+            return {
+                address: address,
+                ensName: ensName,
+                results: [],
+                pageInfo: emptyPageInfo,
+            };
+        }
+        const formattedResult = formatQueryResult(walletByAddress, 'walletNFTs', 'walletNFTsPageInfo', 'nft');
+        return formattedResult;
+    }
+    async getTrendingCollections(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetTrendingCollectionsDocument,
+            polygon: CodegenPolygonMainnetTrendingCollectionsDocument,
+            ethereumSepolia: CodegenEthSepoliaTrendingCollectionsDocument,
+        };
+        const { data: { [userChain]: trendingCollections }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        const formattedResult = formatQueryResult(trendingCollections, 'trendingCollections', 'trendingCollectionsPageInfo', 'collection');
+        return formattedResult;
+    }
+    async getByContractAddress(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetWalletNFTsByContractAddressDocument,
+            polygon: CodegenPolygonMainnetNFTsByContractAddressDocument,
+            ethereumSepolia: CodegenEthSepoliaWalletNFTsByContractAddressDocument,
+        };
+        const { data: { [userChain]: { collection }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        if (!collection?.nfts?.length) {
+            return {
+                standard: null,
+                results: [],
+                pageInfo: emptyPageInfo,
+            };
+        }
+        const setErcStandard = (results) => {
+            const standardMap = {
+                ERC1155Collection: 'ERC1155',
+                ERC721Collection: 'ERC721',
+            };
+            // Remove address too since it was only used as a key field
+            const { __typename, address, ...newResults } = results;
+            return {
+                ...newResults,
+                standard: standardMap[results['__typename']] || null,
+            };
+        };
+        const formattedResult = formatQueryResult(collection, 'nfts', 'nftsPageInfo', null, setErcStandard);
+        return formattedResult;
+    }
+    async getNFTDetails(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetNFTDetailsDocument,
+            polygon: CodegenPolygonMainnetNFTDetailsDocument,
+            ethereumSepolia: CodegenEthSepoliaNFTDetailsDocument,
+        };
+        const { data: { [userChain]: { nft }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        if (nft)
+            return { nft };
+        return { nft: null };
+    }
+    async getCollectionDetails(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetNftCollectionDetailsDocument,
+            polygon: CodegenPolygonMainnetNftCollectionDetailsDocument,
+            ethereumSepolia: CodegenEthSepoliaNftCollectionDetailsDocument,
+        };
+        const { data: { [userChain]: { collection }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        if (collection)
+            return { collection };
+        return { collection: null };
+    }
+    async verifyOwnership(variables) {
+        const { address, ...allVariables } = variables;
+        if (isValidENSAddress(address)) {
+            return this.verifyOwnershipByENS({
+                ensName: address,
+                ...allVariables,
+            });
+        }
+        return this.verifyOwnershipByAddress({
+            address,
+            ...allVariables,
+        });
+    }
+    async verifyOwnershipByAddress(variables) {
+        const { chain, address, nfts } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetVerifyOwnershipByAddressDocument,
+            polygon: CodegenPolygonMainnetVerifyOwnershipByAddressDocument,
+            ethereumSepolia: CodegenEthSepoliaVerifyOwnershipByAddressDocument,
+        };
+        const { data: { [userChain]: { walletByAddress }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: { address, filter: { contractTokens: nfts } },
+        });
+        return !!walletByAddress?.walletNFTs?.length;
+    }
+    async verifyOwnershipByENS(variables) {
+        const { chain, ensName, nfts } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetVerifyOwnershipByENSDocument,
+            polygon: CodegenPolygonMainnetVerifyOwnershipByENSDocument,
+            ethereumSepolia: CodegenEthSepoliaVerifyOwnershipByENSDocument,
+        };
+        const { data: { [userChain]: { walletByENS }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: { ensName, filter: { contractTokens: nfts } },
+        });
+        return !!walletByENS?.walletNFTs?.length;
+    }
+}
+__decorate([
+    ValidateInput(walletByAddressValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NftsController.prototype, "getByWallet", null);
+__decorate([
+    ValidateInput(nftTrendingCollectionsValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NftsController.prototype, "getTrendingCollections", null);
+__decorate([
+    ValidateInput(nftsByContractAddressValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NftsController.prototype, "getByContractAddress", null);
+__decorate([
+    ValidateInput(nftDetailsValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NftsController.prototype, "getNFTDetails", null);
+__decorate([
+    ValidateInput(nftCollectionDetailsValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NftsController.prototype, "getCollectionDetails", null);
+__decorate([
+    ValidateInput(verifyOwnershipValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NftsController.prototype, "verifyOwnership", null);
+
+export { NftsController };

package/esm/src/api/controllers/tokens.js

@@ -0,0 +1,98 @@
+import { __decorate, __metadata } from 'tslib';
+import { DEFAULT_CHAIN } from '../utils/constants.js';
+import { balancesByWalletAddressValidator } from '../types/tokens/getBalancesByWalletAddress.js';
+import { CodegenEthMainnetBalancesByWalletENSDocument, CodegenPolygonMainnetBalancesByWalletENSDocument, CodegenEthSepoliaBalancesByWalletENSDocument, CodegenEthMainnetBalancesByWalletAddressDocument, CodegenPolygonMainnetBalancesByWalletAddressDocument, CodegenEthSepoliaBalancesByWalletAddressDocument } from '../graphql/generatedTypes.js';
+import { emptyPageInfo } from '../utils/helpers.js';
+import { formatQueryResult } from '../utils/postQueryFormatter.js';
+import { isValidENSAddress } from '../utils/isValidENSAddress.js';
+import { ValidateInput } from '../../lib/validation/ValidateInput.js';
+
+class TokensController {
+    constructor(client, defaultChain = DEFAULT_CHAIN) {
+        this.client = client;
+        this.defaultChain = defaultChain;
+    }
+    async getBalancesByWallet(variables) {
+        const { address, ...allVariables } = variables;
+        if (isValidENSAddress(address)) {
+            return this.getBalancesByWalletENS({
+                ensName: address,
+                ...allVariables,
+            });
+        }
+        return this.getBalancesByWalletAddress({
+            address,
+            ...allVariables,
+        });
+    }
+    async getBalancesByWalletENS(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetBalancesByWalletENSDocument,
+            polygon: CodegenPolygonMainnetBalancesByWalletENSDocument,
+            ethereumSepolia: CodegenEthSepoliaBalancesByWalletENSDocument,
+        };
+        const { data: { [userChain]: { walletByENS }, }, } = await this.client.query({
+            variables: queryVariables,
+            query: query[userChain],
+        });
+        if (!walletByENS?.tokenBalances?.length) {
+            // Address can still be valid ENS name, but not have any balances
+            const address = walletByENS?.address || '';
+            const ensName = walletByENS?.ensName || '';
+            return {
+                address: address,
+                ensName: ensName,
+                results: [],
+                pageInfo: emptyPageInfo,
+            };
+        }
+        const formattedResult = formatQueryResult(walletByENS, 'tokenBalances', 'tokenBalancesPageInfo', null, this.flattenBalanceResponses // Remove the "contract" key and move info to balance result body
+        );
+        return formattedResult;
+    }
+    async getBalancesByWalletAddress(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetBalancesByWalletAddressDocument,
+            polygon: CodegenPolygonMainnetBalancesByWalletAddressDocument,
+            ethereumSepolia: CodegenEthSepoliaBalancesByWalletAddressDocument,
+        };
+        const { data: { [userChain]: { walletByAddress }, }, } = await this.client.query({
+            variables: queryVariables,
+            query: query[userChain],
+        });
+        if (!walletByAddress?.tokenBalances?.length) {
+            // Address can still be valid address, but not have any balances
+            const address = walletByAddress?.address || '';
+            const ensName = walletByAddress?.ensName || '';
+            return {
+                address: address,
+                ensName: ensName,
+                results: [],
+                pageInfo: emptyPageInfo,
+            };
+        }
+        const formattedResult = formatQueryResult(walletByAddress, 'tokenBalances', 'tokenBalancesPageInfo', null, this.flattenBalanceResponses // Remove the "contract" key and move info to balance result body
+        );
+        return formattedResult;
+    }
+    flattenBalanceResponses(response) {
+        const modifiedResults = response.results.map((result) => {
+            const { contract: { ...contractInfo }, ...balanceInfo } = result;
+            return { ...balanceInfo, ...contractInfo };
+        });
+        response.results = modifiedResults;
+        return response;
+    }
+}
+__decorate([
+    ValidateInput(balancesByWalletAddressValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TokensController.prototype, "getBalancesByWallet", null);
+
+export { TokensController };