@quicknode/sdk 1.0.0 → 1.1.1

package/esm/src/api/index.js

@@ -0,0 +1,2 @@
+import { API } from './api.js';
+export { API as default } from './api.js';

package/esm/src/api/types/chains.js

@@ -0,0 +1,7 @@
+const supportedChains = [
+    'ethereum',
+    'polygon',
+    'ethereumSepolia',
+];
+
+export { supportedChains };

package/esm/src/api/types/contracts/getContractDetails.js

@@ -0,0 +1,12 @@
+import { isEvmAddress, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+// Using zod for runtime validation
+const contractDetailsValidator = z
+    .object({
+    contractAddress: isEvmAddress,
+})
+    .merge(supportedChainInput)
+    .strict();
+
+export { contractDetailsValidator };

package/esm/src/api/types/events/getAll.js

@@ -0,0 +1,7 @@
+import { baseEventsInput, supportedChainInput } from '../../../lib/validation/validators.js';
+
+const allEventsValidator = baseEventsInput
+    .merge(supportedChainInput)
+    .strict();
+
+export { allEventsValidator };

package/esm/src/api/types/events/getByContract.js

@@ -0,0 +1,12 @@
+import { isEvmAddress, baseEventsInput, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const contractEventsValidator = z
+    .object({
+    contractAddress: isEvmAddress,
+})
+    .merge(baseEventsInput)
+    .merge(supportedChainInput)
+    .strict();
+
+export { contractEventsValidator };

package/esm/src/api/types/nfts/getByContractAddress.js

@@ -0,0 +1,10 @@
+import { isEvmAddress, paginationParams, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const nftsByContractAddressValidator = z
+    .object({ contractAddress: isEvmAddress })
+    .merge(paginationParams)
+    .merge(supportedChainInput)
+    .strict();
+
+export { nftsByContractAddressValidator };

package/esm/src/api/types/nfts/getByWalletAddress.js

@@ -0,0 +1,18 @@
+import { isENSAddress, isEvmAddress, contractTokensFilter, paginationParams, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const walletByAddressValidator = z
+    .object({
+    address: z.union([isENSAddress, isEvmAddress]),
+    filter: z
+        .object({
+        contractTokens: contractTokensFilter,
+    })
+        .strict()
+        .optional(),
+})
+    .merge(paginationParams)
+    .merge(supportedChainInput)
+    .strict();
+
+export { walletByAddressValidator };

package/esm/src/api/types/nfts/getCollectionDetails.js

@@ -0,0 +1,11 @@
+import { isEvmAddress, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const nftCollectionDetailsValidator = z
+    .object({
+    contractAddress: isEvmAddress,
+})
+    .merge(supportedChainInput)
+    .strict();
+
+export { nftCollectionDetailsValidator };

package/esm/src/api/types/nfts/getCollectionEvents.js

@@ -0,0 +1,12 @@
+import { isEvmAddress, baseEventsInput, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const collectionEventsValidator = z
+    .object({
+    contractAddress: isEvmAddress,
+})
+    .merge(baseEventsInput)
+    .merge(supportedChainInput)
+    .strict();
+
+export { collectionEventsValidator };

package/esm/src/api/types/nfts/getNFTDetails.js

@@ -0,0 +1,9 @@
+import { isEvmAddress, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const nftDetailsValidator = z
+    .object({ contractAddress: isEvmAddress, tokenId: z.string() })
+    .merge(supportedChainInput)
+    .strict();
+
+export { nftDetailsValidator };

package/esm/src/api/types/nfts/getNFTEvents.js

@@ -0,0 +1,13 @@
+import { isEvmAddress, baseEventsInput, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const nftEventsValidator = z
+    .object({
+    contractAddress: isEvmAddress,
+    tokenId: z.string(),
+})
+    .merge(baseEventsInput)
+    .merge(supportedChainInput)
+    .strict();
+
+export { nftEventsValidator };

package/esm/src/api/types/nfts/getTrendingCollections.js

@@ -0,0 +1,7 @@
+import { paginationParams, supportedChainInput } from '../../../lib/validation/validators.js';
+
+const nftTrendingCollectionsValidator = paginationParams
+    .merge(supportedChainInput)
+    .strict();
+
+export { nftTrendingCollectionsValidator };

package/esm/src/api/types/nfts/verifyOwnershipByAddress.js

@@ -0,0 +1,12 @@
+import { isENSAddress, isEvmAddress, contractTokensFilter, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const verifyOwnershipValidator = z
+    .object({
+    address: z.union([isENSAddress, isEvmAddress]),
+    nfts: contractTokensFilter,
+})
+    .merge(supportedChainInput)
+    .strict();
+
+export { verifyOwnershipValidator };

package/esm/src/api/types/tokens/getBalancesByWalletAddress.js

@@ -0,0 +1,12 @@
+import { isENSAddress, isEvmAddress, paginationParams, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const balancesByWalletAddressValidator = z
+    .object({
+    address: z.union([isENSAddress, isEvmAddress]),
+})
+    .merge(paginationParams)
+    .merge(supportedChainInput)
+    .strict();
+
+export { balancesByWalletAddressValidator };

package/esm/src/api/types/transactions/getByHash.js

@@ -0,0 +1,11 @@
+import { isEvmTransactionHash, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const transactionsByHashValidator = z
+    .object({
+    hash: isEvmTransactionHash,
+})
+    .merge(supportedChainInput)
+    .strict();
+
+export { transactionsByHashValidator };

package/esm/src/api/types/transactions/getBySearch.js

@@ -0,0 +1,7 @@
+import { baseTransactionsInput, supportedChainInput } from '../../../lib/validation/validators.js';
+
+const transactionsBySearchValidator = baseTransactionsInput
+    .merge(supportedChainInput)
+    .strict();
+
+export { transactionsBySearchValidator };

package/esm/src/api/types/utils/gasPrices.js

@@ -0,0 +1,12 @@
+import { gasPriceFilters, supportedChainInput } from '../../../lib/validation/validators.js';
+import { z } from 'zod';
+
+const gasPricesValidator = z
+    .object({
+    returnInGwei: z.boolean().nullish(),
+    filter: gasPriceFilters.nullish(),
+})
+    .merge(supportedChainInput)
+    .strict();
+
+export { gasPricesValidator };

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

@@ -0,0 +1,3 @@
+const DEFAULT_CHAIN = 'ethereum';
+
+export { DEFAULT_CHAIN };

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

@@ -0,0 +1,11 @@
+const emptyPageInfo = {
+    endCursor: null,
+    hasNextPage: false,
+    hasPreviousPage: false,
+    startCursor: null,
+};
+function weiToGwei(wei) {
+    return +(wei / 1e9).toFixed(2);
+}
+
+export { emptyPageInfo, weiToGwei };

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

@@ -0,0 +1,21 @@
+/**
+ * https://eips.ethereum.org/EIPS/eip-137#name-syntax
+ *
+ * explanation of the regex pattern:
+ * ^  Matches the start of the string
+ * (?=.{3,255}$) Lookahead assertion for the length of the string (3 to 255 characters)
+ * [\p{L}\p{N}\p{Pd}\p{M}\p{S}\u{1F300}-\u{1F6FF}]+  Matches one or more Unicode letter, number, punctuation, symbol, or character in the specified emoji range
+ * (\.[\p{L}\p{N}\p{Pd}\p{M}\p{S}\u{1F300}-\u{1F6FF}]+)*  Matches zero or more occurrences of a dot followed by one or more Unicode characters
+ * \.(?:eth|xyz|art)  Matches a dot followed by either 'eth', 'xyz', or 'art'
+ * $  Matches the end of the string
+ *
+ */
+function isValidENSAddress(ensAddress) {
+    const allowedTLDs = ['eth', 'xyz', 'art'];
+    const unicodeAndEmojis = '[\\p{L}\\p{N}\\p{Pd}\\p{M}\\p{S}\\u{1F300}-\\u{1F6FF}]';
+    const regexPattern = `^(?=.{3,255}$)${unicodeAndEmojis}+(\\.${unicodeAndEmojis}+)*\\.(?:${allowedTLDs.join('|')})$`;
+    const regex = new RegExp(regexPattern, 'mu');
+    return regex.test(ensAddress);
+}
+
+export { isValidENSAddress };

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

@@ -0,0 +1,24 @@
+// Formats the query result with the edges and nodes removed into what we want to return to the user
+function formatQueryResult(queryResult, resultsKey, // Key that the actual results are in
+paginationKey, // Key that the pagination info is in
+resultsKeyToRemove, // Key that the results are nested under to remove for each entry
+additionalModification) {
+    const additionaProperties = Object.fromEntries(Object.entries(queryResult).filter(([key]) => key !== resultsKey && key !== paginationKey));
+    let trimmedResults = queryResult[resultsKey];
+    if (resultsKeyToRemove) {
+        trimmedResults = trimmedResults.map((result) => result[resultsKeyToRemove] || {});
+    }
+    const formattedResultBase = {
+        results: trimmedResults,
+        pageInfo: queryResult[paginationKey],
+    };
+    let result = {
+        ...formattedResultBase,
+        ...additionaProperties,
+    };
+    if (additionalModification)
+        result = additionalModification(result);
+    return result;
+}
+
+export { formatQueryResult };

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

@@ -0,0 +1,51 @@
+function isConnection(object) {
+    return (typeof object === 'object' &&
+        !!object &&
+        ('edges' in object ||
+            'total' in object ||
+            'pageInfo' in object ||
+            'breadcrumbs' in object));
+}
+function removeNodesAndEdges(data) {
+    const keys = Object.keys(data);
+    const output = {};
+    keys.forEach((key) => {
+        const value = data[key];
+        if (typeof value === 'string' ||
+            typeof value === 'boolean' ||
+            typeof value === 'number' ||
+            value === null ||
+            value === undefined) {
+            return (output[key] = value);
+        }
+        if (Array.isArray(value)) {
+            // An array can just be an array of strings and not edges and nodes
+            if (value.every((val) => typeof val === 'string')) {
+                return (output[key] = value);
+            }
+            return (output[key] = value.map((item) => removeNodesAndEdges(item)));
+        }
+        if (isConnection(value)) {
+            if (value.breadcrumbs)
+                output[`${key}Breadcrumbs`] = value.breadcrumbs;
+            if (value.total)
+                output[`${key}Total`] = value.total;
+            if (value.viewport)
+                output[`${key}Viewport`] = value.viewport;
+            if (value.pageInfo) {
+                const { ...pageInfoRest } = value.pageInfo;
+                output[`${key}PageInfo`] = pageInfoRest;
+            }
+            return (output[key] = value.edges?.map((item) => {
+                if (item.node) {
+                    return removeNodesAndEdges(item.node);
+                }
+                return item;
+            }));
+        }
+        return (output[key] = removeNodesAndEdges(value));
+    });
+    return output;
+}
+
+export { removeNodesAndEdges };

package/esm/src/client/client.js

@@ -0,0 +1,9 @@
+import { API } from '../api/api.js';
+import { Core } from '../core/core.js';
+
+const QuickNode = {
+    API: API,
+    Core: Core,
+};
+
+export { QuickNode as default };

package/esm/src/client/index.js

@@ -0,0 +1,2 @@
+import QuickNode from './client.js';
+export { default } from './client.js';

package/esm/src/core/addOns/nftTokenV2/actions.js

@@ -0,0 +1,107 @@
+import { formatErrors } from '../../../lib/validation/ValidateInput.js';
+import { checkAddOnEnabled } from '../shared/helpers.js';
+import { qnFetchNFTInputSchema } from './types/qn_fetchNFTs.js';
+import { qnFetchNFTCollectionDetailsInputSchema } from './types/qn_fetchNFTCollectionDetails.js';
+import { qnFetchNFTsByCollectionInputSchema } from './types/qn_fetchNFTsByCollection.js';
+import { qnGetTransfersByNFTInputSchema } from './types/qn_getTransfersByNFT.js';
+import { qnVerifyNFTsOwnerInputSchema } from './types/qn_verifyNFTsOwner.js';
+import { qnGetTokenMetadataByCAInputSchema } from './types/qn_getTokenMetadataByContractAddress.js';
+import { qnGetTokenMetadataBySymbolInputSchema } from './types/qn_getTokenMetadataBySymbol.js';
+import { qnGetTransactionsByAddressInputSchema } from './types/qn_getTransactionsByAddress.js';
+import { qnGetWalletTokenBalanceInputSchema } from './types/qn_getWalletTokenBalance.js';
+import { qnGetWalletTokenTransactionsInputSchema } from './types/qn_getWalletTokenTransactions.js';
+
+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;
+    },
+});
+
+export { nftAndTokenActions };

package/esm/src/core/addOns/nftTokenV2/types/qn_fetchNFTCollectionDetails.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { isEvmAddress } from '../../../../lib/validation/validators.js';
+
+const qnFetchNFTCollectionDetailsInputSchema = z
+    .object({
+    contracts: z.array(isEvmAddress),
+})
+    .strict();
+
+export { qnFetchNFTCollectionDetailsInputSchema };

package/esm/src/core/addOns/nftTokenV2/types/qn_fetchNFTs.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { isEvmAddress, rpcPaginationParams } from '../../../../lib/validation/validators.js';
+
+const qnFetchNFTInputSchema = z
+    .object({
+    wallet: isEvmAddress,
+    contracts: z.array(isEvmAddress).nullish(),
+    omitFields: z.array(z.string()).nullish(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+export { qnFetchNFTInputSchema };

package/esm/src/core/addOns/nftTokenV2/types/qn_fetchNFTsByCollection.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { isEvmAddress, rpcPaginationParams } from '../../../../lib/validation/validators.js';
+
+const qnFetchNFTsByCollectionInputSchema = z
+    .object({
+    collection: isEvmAddress,
+    tokens: z.array(z.string()).nullish(),
+    omitFields: z.array(z.string()).nullish(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+export { qnFetchNFTsByCollectionInputSchema };

package/esm/src/core/addOns/nftTokenV2/types/qn_getTokenMetadataByContractAddress.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { isEvmAddress } from '../../../../lib/validation/validators.js';
+
+const qnGetTokenMetadataByCAInputSchema = z
+    .object({
+    contract: isEvmAddress,
+})
+    .strict();
+
+export { qnGetTokenMetadataByCAInputSchema };

package/esm/src/core/addOns/nftTokenV2/types/qn_getTokenMetadataBySymbol.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { rpcPaginationParams } from '../../../../lib/validation/validators.js';
+
+const qnGetTokenMetadataBySymbolInputSchema = z
+    .object({
+    symbol: z.string(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+export { qnGetTokenMetadataBySymbolInputSchema };

package/esm/src/core/addOns/nftTokenV2/types/qn_getTransactionsByAddress.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { isEvmAddress, rpcPaginationParams } from '../../../../lib/validation/validators.js';
+
+const qnGetTransactionsByAddressInputSchema = z
+    .object({
+    address: isEvmAddress,
+    fromBlock: z.number().positive().nullish(),
+    toBlock: 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' });
+
+export { qnGetTransactionsByAddressInputSchema };

package/esm/src/core/addOns/nftTokenV2/types/qn_getTransfersByNFT.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { isEvmAddress, rpcPaginationParams } from '../../../../lib/validation/validators.js';
+
+const qnGetTransfersByNFTInputSchema = z
+    .object({
+    collection: isEvmAddress,
+    collectionTokenId: z.string(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+export { qnGetTransfersByNFTInputSchema };

package/esm/src/core/addOns/nftTokenV2/types/qn_getWalletTokenBalance.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { isEvmAddress, rpcPaginationParams } from '../../../../lib/validation/validators.js';
+
+const qnGetWalletTokenBalanceInputSchema = z
+    .object({
+    wallet: isEvmAddress,
+    contracts: z.array(isEvmAddress).nullish(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+export { qnGetWalletTokenBalanceInputSchema };

package/esm/src/core/addOns/nftTokenV2/types/qn_getWalletTokenTransactions.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { isEvmAddress, rpcPaginationParams } from '../../../../lib/validation/validators.js';
+
+const qnGetWalletTokenTransactionsInputSchema = z
+    .object({
+    address: isEvmAddress,
+    contract: isEvmAddress,
+    fromBlock: z.number().positive().nullish(),
+    toBlock: z.number().positive().nullish(),
+})
+    .merge(rpcPaginationParams)
+    .strict();
+
+export { qnGetWalletTokenTransactionsInputSchema };

package/esm/src/core/addOns/nftTokenV2/types/qn_verifyNFTsOwner.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { isEvmAddress } from '../../../../lib/validation/validators.js';
+
+const qnVerifyNFTsOwnerInputSchema = z
+    .object({
+    wallet: isEvmAddress,
+    contracts: z.array(z.string()), // TODO: make this enforce the address:id format
+})
+    .strict();
+
+export { qnVerifyNFTsOwnerInputSchema };

package/esm/src/core/addOns/shared/helpers.js

@@ -0,0 +1,10 @@
+// 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`);
+    }
+}
+
+export { checkAddOnEnabled };

package/esm/src/core/chains.js

@@ -0,0 +1,60 @@
+import { QNInvalidEndpointUrl } from '../lib/errors/QNInvalidEnpointUrl.js';
+import { QNChainNotSupported } from '../lib/errors/QNChainNotSupported.js';
+import { arbitrum, arbitrumGoerli, avalanche, avalancheFuji, baseGoerli, bsc, bscTestnet, celo, fantom, gnosis, goerli, harmonyOne, mainnet, optimism, optimismGoerli, polygon, polygonMumbai, polygonZkEvm, polygonZkEvmTestnet, sepolia } from 'viem/chains';
+
+const ETH_MAINNET_NETWORK = 'ethereum-mainnet';
+const qnChainToViemChain = {
+    'arbitrum-mainnet': arbitrum,
+    'arbitrum-goerli': arbitrumGoerli,
+    'avalanche-mainnet': avalanche,
+    'avalanche-testnet': avalancheFuji,
+    'base-goerli': baseGoerli,
+    ['bsc']: bsc,
+    'bsc-testnet': bscTestnet,
+    'celo-mainnet': celo,
+    ['fantom']: fantom,
+    ['xdai']: gnosis,
+    ['gnosis']: gnosis,
+    'ethereum-goerli': goerli,
+    'harmony-mainnet': harmonyOne,
+    [ETH_MAINNET_NETWORK]: mainnet,
+    ['optimism']: optimism,
+    'optimism-goerli': optimismGoerli,
+    ['matic']: polygon,
+    ['polygon']: polygon,
+    'matic-testnet': polygonMumbai,
+    'zkevm-mainnet': polygonZkEvm,
+    'zkevm-testnet': polygonZkEvmTestnet,
+    'ethereum-sepolia': 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);
+}
+
+export { deriveChainFromUrl };