@quicknode/sdk 1.0.0 → 1.1.0

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

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

@@ -0,0 +1,125 @@
+import { __decorate, __metadata } from 'tslib';
+import { DEFAULT_CHAIN } from '../utils/constants.js';
+import { transactionsBySearchValidator } from '../types/transactions/getBySearch.js';
+import { transactionsByHashValidator } from '../types/transactions/getByHash.js';
+import { CodegenEthMainnetTransactionsByWalletAddressDocument, CodegenPolygonMainnetTransactionsByWalletAddressDocument, CodegenEthSepoliaTransactionsByWalletAddressDocument, CodegenEthMainnetTransactionsByWalletENSDocument, CodegenPolygonMainnetTransactionsByWalletENSDocument, CodegenEthSepoliaTransactionsByWalletENSDocument, CodegenEthMainnetTransactionsBySearchDocument, CodegenPolygonMainnetTransactionsBySearchDocument, CodegenEthSepoliaTransactionsBySearchDocument, CodegenEthMainnetTransactionsByHashDocument, CodegenPolygonMainnetTransactionsByHashDocument, CodegenEthSepoliaTransactionsByHashDocument } 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';
+import { balancesByWalletAddressValidator } from '../types/tokens/getBalancesByWalletAddress.js';
+
+class TransactionsController {
+    constructor(client, defaultChain = DEFAULT_CHAIN) {
+        this.client = client;
+        this.defaultChain = defaultChain;
+    }
+    async getByWallet(variables) {
+        const { address, ...allVariables } = variables;
+        let queryResult;
+        if (isValidENSAddress(address)) {
+            queryResult = await this.getByWalletENS({
+                ensName: address,
+                ...allVariables,
+            });
+        }
+        else {
+            queryResult = await this.getByWalletAddress({
+                address,
+                ...allVariables,
+            });
+        }
+        if (!queryResult?.transactions?.length) {
+            // Address can still be valid address, but not have any transactions
+            const address = queryResult?.address || '';
+            const ensName = queryResult?.ensName || '';
+            return {
+                address: address,
+                ensName: ensName,
+                results: [],
+                pageInfo: emptyPageInfo,
+            };
+        }
+        const formattedResult = formatQueryResult(queryResult, 'transactions', 'transactionsPageInfo');
+        return formattedResult;
+    }
+    async getByWalletAddress(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetTransactionsByWalletAddressDocument,
+            polygon: CodegenPolygonMainnetTransactionsByWalletAddressDocument,
+            ethereumSepolia: CodegenEthSepoliaTransactionsByWalletAddressDocument,
+        };
+        const { data: { [userChain]: { walletByAddress }, }, } = await this.client.query({
+            variables: queryVariables,
+            query: query[userChain],
+        });
+        return walletByAddress;
+    }
+    async getByWalletENS(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetTransactionsByWalletENSDocument,
+            polygon: CodegenPolygonMainnetTransactionsByWalletENSDocument,
+            ethereumSepolia: CodegenEthSepoliaTransactionsByWalletENSDocument,
+        };
+        const { data: { [userChain]: { walletByENS }, }, } = await this.client.query({
+            variables: queryVariables,
+            query: query[userChain],
+        });
+        return walletByENS;
+    }
+    async getAll(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetTransactionsBySearchDocument,
+            polygon: CodegenPolygonMainnetTransactionsBySearchDocument,
+            ethereumSepolia: CodegenEthSepoliaTransactionsBySearchDocument,
+        };
+        const { data: { [userChain]: transactions }, } = await this.client.query({
+            variables: queryVariables,
+            query: query[userChain],
+        });
+        const formattedResult = formatQueryResult(transactions, 'transactions', 'transactionsPageInfo');
+        return formattedResult;
+    }
+    async getByHash(variables) {
+        const { chain, ...queryVariables } = variables;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetTransactionsByHashDocument,
+            polygon: CodegenPolygonMainnetTransactionsByHashDocument,
+            ethereumSepolia: CodegenEthSepoliaTransactionsByHashDocument,
+        };
+        const { data: { [userChain]: transaction }, } = await this.client.query({
+            variables: queryVariables,
+            query: query[userChain],
+        });
+        if (transaction?.transaction)
+            return transaction;
+        return { transaction: null };
+    }
+}
+__decorate([
+    ValidateInput(balancesByWalletAddressValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TransactionsController.prototype, "getByWallet", null);
+__decorate([
+    ValidateInput(transactionsBySearchValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TransactionsController.prototype, "getAll", null);
+__decorate([
+    ValidateInput(transactionsByHashValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TransactionsController.prototype, "getByHash", null);
+
+export { TransactionsController };

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

@@ -0,0 +1,55 @@
+import { __decorate, __metadata } from 'tslib';
+import { DEFAULT_CHAIN } from '../utils/constants.js';
+import { gasPricesValidator } from '../types/utils/gasPrices.js';
+import { CodegenEthMainnetGasPricesDocument, CodegenPolygonMainnetGasPricesDocument, CodegenEthSepoliaGasPricesDocument } from '../graphql/generatedTypes.js';
+import { weiToGwei } from '../utils/helpers.js';
+import { ValidateInput } from '../../lib/validation/ValidateInput.js';
+
+class UtilsController {
+    constructor(client, defaultChain = DEFAULT_CHAIN) {
+        this.client = client;
+        this.defaultChain = defaultChain;
+    }
+    async getGasPrices(variables) {
+        const { chain, ...queryVariables } = variables;
+        const returnInGwei = variables.returnInGwei || false;
+        const userChain = chain || this.defaultChain;
+        const query = {
+            ethereum: CodegenEthMainnetGasPricesDocument,
+            polygon: CodegenPolygonMainnetGasPricesDocument,
+            ethereumSepolia: CodegenEthSepoliaGasPricesDocument,
+        };
+        const { data: { [userChain]: { gasPrices }, }, } = await this.client.query({
+            query: query[userChain],
+            variables: queryVariables,
+        });
+        if (Array.isArray(gasPrices) && gasPrices.length > 0) {
+            if (returnInGwei) {
+                const fieldsToTransform = [
+                    'total',
+                    'average',
+                    'ceiling',
+                    'floor',
+                    'median',
+                ];
+                const modifiedGasPrices = gasPrices.map((gasPrice) => {
+                    fieldsToTransform.map((field) => {
+                        gasPrice[field] = weiToGwei(gasPrice[field]);
+                    });
+                    return gasPrice;
+                });
+                return { gasPrices: modifiedGasPrices };
+            }
+            return { gasPrices };
+        }
+        return { gasPrices: [] };
+    }
+}
+__decorate([
+    ValidateInput(gasPricesValidator),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], UtilsController.prototype, "getGasPrices", null);
+
+export { UtilsController };

package/esm/src/api/graphql/customUrqlClient.js

@@ -0,0 +1,23 @@
+import { removeNodesAndEdges } from '../utils/removeNodesAndEdges.js';
+
+class CustomUrqlClient {
+    constructor(urqlClient) {
+        this.urqlClient = urqlClient;
+    }
+    async query(options) {
+        const { query, variables, ...additionalOptions } = options;
+        const result = await this.urqlClient.query(query, variables, additionalOptions);
+        const { error } = result;
+        if (error) {
+            console.error(error.stack);
+            throw error;
+        }
+        return {
+            ...result,
+            data: result?.data &&
+                removeNodesAndEdges(result.data),
+        };
+    }
+}
+
+export { CustomUrqlClient };