@quicknode/sdk 1.0.0 → 1.1.0

package/README.md

@@ -50,6 +50,8 @@ Full example app implementation [here](https://github.com/quiknode-labs/qn-oss/t
 
 Please see [the official QuickNode SDK documentation](https://www.quicknode.com/docs/quicknode-sdk/getting-started) for the full documentation of SDK functions.
 
+<br>
+
 ## Contributing corner
 
 ### Issues

package/cjs/index.js

@@ -7,10 +7,31 @@ var core = require('@urql/core');
 var exchangeGraphcache = require('@urql/exchange-graphcache');
 var tslib = require('tslib');
 var zod = require('zod');
+var viem = require('viem');
+var chains = require('viem/chains');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
 var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
+var viem__namespace = /*#__PURE__*/_interopNamespace(viem);
 
 function isConnection(object) {
     return (typeof object === 'object' &&
@@ -225,6 +246,12 @@ const contractTokensFilter = zod.z
 })
     .strict())
     .nonempty();
+const rpcPaginationParams = zod.z
+    .object({
+    perPage: zod.z.number().positive().nullish(),
+    page: zod.z.number().positive().nullish(),
+})
+    .strict();
 
 const walletByAddressValidator = zod.z
     .object({
@@ -375,6 +402,18 @@ class QNInputValidationError extends Error {
     }
 }
 
+class QNInvalidEndpointUrl extends Error {
+    constructor() {
+        super('Endpoint URL is not in a valid QuickNode URL format. Please check the URL and try again');
+    }
+}
+
+class QNChainNotSupported extends Error {
+    constructor(endpointUrl) {
+        super(`The chain for endpoint URL ${endpointUrl} is not currently supported by the QuickNode SDK.`);
+    }
+}
+
 function formatErrors(baseError) {
     const errorMessages = [];
     baseError.errors.forEach((error) => {
@@ -1088,7 +1127,7 @@ tslib.__decorate([
     tslib.__metadata("design:returntype", Promise)
 ], TransactionsController.prototype, "getByHash", null);
 
-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.0.0";var main="./cjs/index.js";var module$1="./esm/index.js";var types="./index.d.ts";var dependencies={"@urql/core":"^4.0.7","@urql/exchange-graphcache":"^6.0.4","cross-fetch":"^3.1.6",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$1={".":{"import":"./esm/index.js",require:"./cjs/index.js"}};var packageJson = {name:name,repository:repository,license:license,version:version,main:main,module:module$1,types:types,dependencies:dependencies,devDependencies:devDependencies,scripts:scripts,exports:exports$1};
+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$1="./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$1={".":{"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$1,types:types,sideEffects:sideEffects,dependencies:dependencies,devDependencies:devDependencies,scripts:scripts,exports:exports$1,typesVersions:typesVersions};
 
 class API {
     constructor({ graphApiKey, additionalHeaders, defaultChain, } = {}) {
@@ -1160,14 +1199,288 @@ class API {
     }
 }
 
+// We can't dynamically extend the viem client based on which add-ons are specified, which would
+// make the types fully align with the add-ons for the client, so instead we do run-time checks to
+// prevent calling add-ons not explicitly added in the config
+function checkAddOnEnabled(enabled, humanName, configName) {
+    if (!enabled) {
+        throw new Error(`${humanName} is not set as enabled. Please ensure the addon is enabled on your QuickNode endpoint and enable ${configName} in the Core configuration argument`);
+    }
+}
+
+const qnFetchNFTInputSchema = zod.z
+    .object({
+    wallet: isEvmAddress,
+    contracts: zod.z.array(isEvmAddress).nullish(),
+    omitFields: zod.z.array(zod.z.string()).nullish(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+const qnFetchNFTCollectionDetailsInputSchema = zod.z
+    .object({
+    contracts: zod.z.array(isEvmAddress),
+})
+    .strict();
+
+const qnFetchNFTsByCollectionInputSchema = zod.z
+    .object({
+    collection: isEvmAddress,
+    tokens: zod.z.array(zod.z.string()).nullish(),
+    omitFields: zod.z.array(zod.z.string()).nullish(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+const qnGetTransfersByNFTInputSchema = zod.z
+    .object({
+    collection: isEvmAddress,
+    collectionTokenId: zod.z.string(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+const qnVerifyNFTsOwnerInputSchema = zod.z
+    .object({
+    wallet: isEvmAddress,
+    contracts: zod.z.array(zod.z.string()), // TODO: make this enforce the address:id format
+})
+    .strict();
+
+const qnGetTokenMetadataByCAInputSchema = zod.z
+    .object({
+    contract: isEvmAddress,
+})
+    .strict();
+
+const qnGetTokenMetadataBySymbolInputSchema = zod.z
+    .object({
+    symbol: zod.z.string(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+const qnGetTransactionsByAddressInputSchema = zod.z
+    .object({
+    address: isEvmAddress,
+    fromBlock: zod.z.number().positive().nullish(),
+    toBlock: zod.z.number().positive().nullish(),
+})
+    .merge(rpcPaginationParams)
+    .strict()
+    .refine(({ fromBlock, toBlock }) => {
+    if (fromBlock && toBlock)
+        return fromBlock < toBlock;
+    return true;
+}, { message: 'fromBlock must be less than toBlock' });
+
+const qnGetWalletTokenBalanceInputSchema = zod.z
+    .object({
+    wallet: isEvmAddress,
+    contracts: zod.z.array(isEvmAddress).nullish(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+const qnGetWalletTokenTransactionsInputSchema = zod.z
+    .object({
+    address: isEvmAddress,
+    contract: isEvmAddress,
+    fromBlock: zod.z.number().positive().nullish(),
+    toBlock: zod.z.number().positive().nullish(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+function nftAndTokenValidator(config, schema, args) {
+    checkAddOnEnabled(config.addOns?.nftTokenV2 ?? false, 'NFT And Token RPC API V2', 'nftTokenV2');
+    // Uses zod to validate schema at runtime
+    const validation = schema.safeParse(args);
+    if (!validation.success) {
+        const formattedErrors = formatErrors(validation.error);
+        if (formattedErrors)
+            throw formattedErrors;
+    }
+}
+const nftAndTokenActions = (client, config) => ({
+    async qn_fetchNFTCollectionDetails(args) {
+        nftAndTokenValidator(config, qnFetchNFTCollectionDetailsInputSchema, args);
+        const response = await client.request({
+            method: 'qn_fetchNFTCollectionDetails',
+            params: [args],
+        });
+        return response;
+    },
+    async qn_fetchNFTs(args) {
+        nftAndTokenValidator(config, qnFetchNFTInputSchema, args);
+        const response = await client.request({
+            method: 'qn_fetchNFTs',
+            params: [args],
+        });
+        return response;
+    },
+    async qn_fetchNFTsByCollection(args) {
+        nftAndTokenValidator(config, qnFetchNFTsByCollectionInputSchema, args);
+        const response = await client.request({
+            method: 'qn_fetchNFTsByCollection',
+            params: [args],
+        });
+        return response;
+    },
+    async qn_getTransfersByNFT(args) {
+        nftAndTokenValidator(config, qnGetTransfersByNFTInputSchema, args);
+        const response = await client.request({
+            method: 'qn_getTransfersByNFT',
+            params: [args],
+        });
+        return response;
+    },
+    async qn_verifyNFTsOwner(args) {
+        nftAndTokenValidator(config, qnVerifyNFTsOwnerInputSchema, args);
+        const response = await client.request({
+            method: 'qn_verifyNFTsOwner',
+            params: [args],
+        });
+        return response;
+    },
+    async qn_getTokenMetadataByContractAddress(args) {
+        nftAndTokenValidator(config, qnGetTokenMetadataByCAInputSchema, args);
+        const response = await client.request({
+            method: 'qn_getTokenMetadataByContractAddress',
+            params: [args],
+        });
+        return response;
+    },
+    async qn_getTokenMetadataBySymbol(args) {
+        nftAndTokenValidator(config, qnGetTokenMetadataBySymbolInputSchema, args);
+        const response = await client.request({
+            method: 'qn_getTokenMetadataBySymbol',
+            params: [args],
+        });
+        return response;
+    },
+    async qn_getTransactionsByAddress(args) {
+        nftAndTokenValidator(config, qnGetTransactionsByAddressInputSchema, args);
+        const response = await client.request({
+            method: 'qn_getTransactionsByAddress',
+            params: [args],
+        });
+        return response;
+    },
+    async qn_getWalletTokenBalance(args) {
+        nftAndTokenValidator(config, qnGetWalletTokenBalanceInputSchema, args);
+        const response = await client.request({
+            method: 'qn_getWalletTokenBalance',
+            params: [args],
+        });
+        return response;
+    },
+    async qn_getWalletTokenTransactions(args) {
+        nftAndTokenValidator(config, qnGetWalletTokenTransactionsInputSchema, args);
+        const response = await client.request({
+            method: 'qn_getWalletTokenTransactions',
+            params: [args],
+        });
+        return response;
+    },
+});
+
+const ETH_MAINNET_NETWORK = 'ethereum-mainnet';
+const qnChainToViemChain = {
+    'arbitrum-mainnet': chains.arbitrum,
+    'arbitrum-goerli': chains.arbitrumGoerli,
+    'avalanche-mainnet': chains.avalanche,
+    'avalanche-testnet': chains.avalancheFuji,
+    'base-goerli': chains.baseGoerli,
+    ['bsc']: chains.bsc,
+    'bsc-testnet': chains.bscTestnet,
+    'celo-mainnet': chains.celo,
+    ['fantom']: chains.fantom,
+    ['xdai']: chains.gnosis,
+    ['gnosis']: chains.gnosis,
+    'ethereum-goerli': chains.goerli,
+    'harmony-mainnet': chains.harmonyOne,
+    [ETH_MAINNET_NETWORK]: chains.mainnet,
+    ['optimism']: chains.optimism,
+    'optimism-goerli': chains.optimismGoerli,
+    ['matic']: chains.polygon,
+    ['polygon']: chains.polygon,
+    'matic-testnet': chains.polygonMumbai,
+    'zkevm-mainnet': chains.polygonZkEvm,
+    'zkevm-testnet': chains.polygonZkEvmTestnet,
+    'ethereum-sepolia': chains.sepolia,
+};
+function chainNameFromEndpoint(endpointUrl) {
+    let hostnameParts;
+    try {
+        const parsedUrl = new URL(endpointUrl);
+        hostnameParts = parsedUrl.hostname.split('.');
+    }
+    catch (e) {
+        throw new QNInvalidEndpointUrl();
+    }
+    const quiknode = hostnameParts.at(-2);
+    const chainOrDiscover = hostnameParts.at(-3);
+    if (quiknode !== 'quiknode' || !chainOrDiscover)
+        throw new QNInvalidEndpointUrl();
+    const indexOfName = chainOrDiscover === 'discover' ? -4 : -3;
+    const lengthOfEthereum = chainOrDiscover === 'discover' ? 4 : 3;
+    if (hostnameParts.length === lengthOfEthereum)
+        return ETH_MAINNET_NETWORK;
+    const potentialChainName = hostnameParts.at(indexOfName);
+    if (potentialChainName)
+        return potentialChainName;
+    throw new QNInvalidEndpointUrl();
+}
+function deriveChainFromUrl(endpointUrl) {
+    const chainName = chainNameFromEndpoint(endpointUrl);
+    const viemChain = qnChainToViemChain[chainName];
+    if (viemChain)
+        return viemChain;
+    throw new QNChainNotSupported(endpointUrl);
+}
+
+function setupGlobalFetch() {
+    // Required for viem to work in node
+    if (!globalThis.fetch) {
+        globalThis.fetch = fetch__default["default"];
+        globalThis.Headers = fetch.Headers;
+        globalThis.Request = fetch.Request;
+        globalThis.Response = fetch.Response;
+    }
+}
+
+const buildQNActions = (config) => {
+    return (client) => ({
+        ...nftAndTokenActions(client, config),
+    });
+};
+class Core {
+    constructor({ endpointUrl, chain, config = {} }) {
+        setupGlobalFetch();
+        this.endpointUrl = endpointUrl;
+        const baseClient = viem.createClient({
+            chain: chain || deriveChainFromUrl(endpointUrl),
+            transport: viem.http(this.endpointUrl),
+        }).extend(viem.publicActions);
+        const qnClient = baseClient.extend(buildQNActions(config));
+        this.client = qnClient;
+    }
+}
+
 const QuickNode = {
     API: API,
+    Core: Core,
 };
 
 Object.defineProperty(exports, 'gql', {
     enumerable: true,
     get: function () { return core.gql; }
 });
+exports.viem = viem__namespace;
 exports.API = API;
+exports.Core = Core;
+exports.QNChainNotSupported = QNChainNotSupported;
 exports.QNInputValidationError = QNInputValidationError;
+exports.QNInvalidEndpointUrl = QNInvalidEndpointUrl;
 exports["default"] = QuickNode;

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 };