@coinbase/cdp-sdk 1.1.2 → 1.3.0

package/types/misc.ts

@@ -0,0 +1,44 @@
+// Adapted from viem (https://github.com/wevm/viem)
+
+export type Hex = `0x${string}`;
+export type Hash = `0x${string}`;
+export type Address = `0x${string}`;
+
+export type AccessList = readonly {
+  address: Address;
+  storageKeys: readonly Hex[];
+}[];
+
+export type TransactionRequestEIP1559 = {
+  /** The address of the contract or account to send the transaction to. */
+  to: Address;
+  /** The amount of ETH, in wei, to send with the transaction. */
+  value?: bigint | undefined;
+  /** The data to send with the transaction; only used for contract calls. */
+  data?: Hex | undefined;
+  /** The amount of gas to use for the transaction. */
+  gas?: bigint | undefined;
+  /**
+   * The nonce to use for the transaction.
+   * If not provided, the API will assign a nonce to the transaction based on the current state of the account.
+   */
+  nonce?: number | undefined;
+  /**
+   * The maximum fee per gas to use for the transaction.
+   * If not provided, the API will estimate a value based on current network conditions.
+   */
+  maxFeePerGas?: bigint | undefined;
+  /**
+   * The maximum priority fee per gas to use for the transaction.
+   * If not provided, the API will estimate a value based on current network conditions.
+   */
+  maxPriorityFeePerGas?: bigint | undefined;
+  /** The access list to use for the transaction. */
+  accessList?: AccessList | undefined;
+  /** (Ignored) The value of the `chainId` field in the transaction is ignored. */
+  chainId?: number | undefined;
+  /** (Ignored) Ignored in favor of the account address that is sending the transaction. */
+  from?: Address | undefined;
+  /** (Ignored) The transaction type is always `eip1559`. */
+  type?: "eip1559" | undefined;
+};

package/types/multicall.ts

@@ -0,0 +1,29 @@
+// Adapted from viem (https://github.com/wevm/viem)
+import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+} from "./contract.js";
+import type { Abi, AbiStateMutability } from "abitype";
+
+// infer contract parameters from `unknown`
+export type GetMulticallContractParameters<
+  contract,
+  mutability extends AbiStateMutability,
+> = contract extends { abi: infer abi extends Abi } // 1. Check if `abi` is const-asserted or defined inline
+  ? // 1a. Check if `functionName` is valid for `abi`
+    contract extends {
+      functionName: infer functionName extends ContractFunctionName<abi, mutability>;
+    }
+    ? // 1aa. Check if `args` is valid for `abi` and `functionName`
+      contract extends {
+        args: infer args extends ContractFunctionArgs<abi, mutability, functionName>;
+      }
+      ? ContractFunctionParameters<abi, mutability, functionName, args> // `args` valid, pass through
+      : ContractFunctionParameters<abi, mutability, functionName> // invalid `args`
+    : // 1b. `functionName` is invalid, check if `abi` is declared as `Abi`
+      Abi extends abi
+      ? ContractFunctionParameters // `abi` declared as `Abi`, unable to infer types further
+      : // `abi` is const-asserted or defined inline, infer types for `functionName` and `args`
+        ContractFunctionParameters<abi, mutability>
+  : ContractFunctionParameters<readonly unknown[]>; // invalid `contract['abi']`, set to `readonly unknown[]`

package/types/utils.ts

@@ -0,0 +1,288 @@
+/* eslint-disable */
+// Adapted from viem (https://github.com/wevm/viem)
+
+/**
+ * Filters out all members of {@link T} that are not {@link P}
+ *
+ * @param T - Items to filter
+ * @param P - Type to filter out
+ * @returns Filtered items
+ *
+ * @example
+ * type Result = Filter<['a', 'b', 'c'], 'b'>
+ * //   ^? type Result = ['a', 'c']
+ */
+export type Filter<
+  T extends readonly unknown[],
+  P,
+  Acc extends readonly unknown[] = [],
+> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]]
+  ? [F] extends [P]
+    ? Filter<Rest, P, [...Acc, F]>
+    : Filter<Rest, P, Acc>
+  : readonly [...Acc];
+
+/**
+ * @description Checks if {@link T} can be narrowed further than {@link U}
+ * @param T - Type to check
+ * @param U - Type to against
+ * @example
+ * type Result = IsNarrowable<'foo', string>
+ * //   ^? true
+ */
+export type IsNarrowable<T, U> =
+  IsNever<(T extends U ? true : false) & (U extends T ? false : true)> extends true ? false : true;
+
+/**
+ * @description Checks if {@link T} is `never`
+ * @param T - Type to check
+ * @example
+ * type Result = IsNever<never>
+ * //   ^? type Result = true
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+
+/** Removes `readonly` from all properties of an object. */
+export type Mutable<type extends object> = {
+  -readonly [key in keyof type]: type[key];
+};
+
+/**
+ * @description Evaluates boolean "or" condition for {@link T} properties.
+ * @param T - Type to check
+ *
+ * @example
+ * type Result = Or<[false, true, false]>
+ * //   ^? type Result = true
+ *
+ * @example
+ * type Result = Or<[false, false, false]>
+ * //   ^? type Result = false
+ */
+export type Or<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Tail]
+  ? Head extends true
+    ? true
+    : Or<Tail>
+  : false;
+
+/**
+ * @description Checks if {@link T} is `undefined`
+ * @param T - Type to check
+ * @example
+ * type Result = IsUndefined<undefined>
+ * //   ^? type Result = true
+ */
+export type IsUndefined<T> = [undefined] extends [T] ? true : false;
+
+export type MaybePromise<T> = T | Promise<T>;
+
+/**
+ * @description Makes attributes on the type T required if required is true.
+ *
+ * @example
+ * MaybeRequired<{ a: string, b?: number }, true>
+ * => { a: string, b: number }
+ *
+ * MaybeRequired<{ a: string, b?: number }, false>
+ * => { a: string, b?: number }
+ */
+export type MaybeRequired<T, required extends boolean> = required extends true
+  ? ExactRequired<T>
+  : T;
+
+/**
+ * @description Assigns the properties of U onto T.
+ *
+ * @example
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * => { a: undefined, b: number, c: boolean }
+ */
+export type Assign<T, U> = Assign_<T, U> & U;
+type Assign_<T, U> = {
+  [K in keyof T as K extends keyof U ? (U[K] extends void ? never : K) : K]: K extends keyof U
+    ? U[K]
+    : T[K];
+};
+
+// TODO: Remove when peer dep `typescript@>=4.5` (NoInfer is native)
+export type NoInfer<type> = [type][type extends any ? 0 : never];
+
+/**
+ * @description Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * NoUndefined<string | undefined>
+ * => string
+ *
+ * @internal
+ */
+export type NoUndefined<T> = T extends undefined ? never : T;
+
+/** Strict version of built-in Omit type */
+export type Omit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>;
+
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * => { a?: string, b: number }
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & ExactPartial<Pick<T, K>>;
+
+/**
+ * @description Combines members of an intersection into a readable type.
+ *
+ * @see {@link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg}
+ * @example
+ * Prettify<{ a: string } & { b: string } & { c: number, d: bigint }>
+ * => { a: string, b: string, c: number, d: bigint }
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+/** @internal */
+export type Evaluate<type> = {
+  [key in keyof type]: type[key];
+} & {};
+
+/**
+ * @description Creates a type that is T with the required keys K.
+ *
+ * @example
+ * RequiredBy<{ a?: string, b: number }, 'a'>
+ * => { a: string, b: number }
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & ExactRequired<Pick<T, K>>;
+
+/**
+ * @description Returns truthy if `array` contains `value`.
+ *
+ * @example
+ * Some<[1, 2, 3], 2>
+ * => true
+ */
+export type Some<array extends readonly unknown[], value> = array extends readonly [
+  value,
+  ...unknown[],
+]
+  ? true
+  : array extends readonly [unknown, ...infer rest]
+    ? Some<rest, value>
+    : false;
+
+/**
+ * @description Creates a type that extracts the values of T.
+ *
+ * @example
+ * ValueOf<{ a: string, b: number }>
+ * => string | number
+ *
+ * @internal
+ */
+export type ValueOf<T> = T[keyof T];
+
+export type UnionToTuple<
+  union,
+  ///
+  last = LastInUnion<union>,
+> = [union] extends [never] ? [] : [...UnionToTuple<Exclude<union, last>>, last];
+type LastInUnion<U> =
+  UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer l) => 0
+    ? l
+    : never;
+type UnionToIntersection<union> = (union extends unknown ? (arg: union) => 0 : never) extends (
+  arg: infer i,
+) => 0
+  ? i
+  : never;
+
+export type IsUnion<
+  union,
+  ///
+  union2 = union,
+> = union extends union2 ? ([union2] extends [union] ? false : true) : never;
+
+export type MaybePartial<type, enabled extends boolean | undefined> = enabled extends true
+  ? Prettify<ExactPartial<type>>
+  : type;
+
+export type ExactPartial<type> = {
+  [key in keyof type]?: type[key] | undefined;
+};
+
+export type ExactRequired<type> = {
+  [P in keyof type]-?: Exclude<type[P], undefined>;
+};
+
+export type OneOf<
+  union extends object,
+  fallback extends object | undefined = undefined,
+  ///
+  keys extends KeyofUnion<union> = KeyofUnion<union>,
+> = union extends infer item
+  ? Prettify<
+      item & {
+        [key in Exclude<keys, keyof item>]?: fallback extends object
+          ? key extends keyof fallback
+            ? fallback[key]
+            : undefined
+          : undefined;
+      }
+    >
+  : never;
+type KeyofUnion<type> = type extends type ? keyof type : never;
+
+///////////////////////////////////////////////////////////////////////////
+// Loose types
+
+/**
+ * Loose version of {@link Omit}
+ *
+ * @internal
+ */
+export type LooseOmit<type, keys extends string> = Pick<type, Exclude<keyof type, keys>>;
+
+///////////////////////////////////////////////////////////////////////////
+// Union types
+
+export type UnionEvaluate<type> = type extends object ? Prettify<type> : type;
+
+export type UnionLooseOmit<type, keys extends string> = type extends any
+  ? LooseOmit<type, keys>
+  : never;
+
+/**
+ * @description Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { b: number } | { b: undefined, c: number }
+ */
+export type UnionOmit<type, keys extends keyof type> = type extends any ? Omit<type, keys> : never;
+
+/**
+ * @description Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { b: number } | { b: undefined, c: number }
+ */
+export type UnionPick<type, keys extends keyof type> = type extends any ? Pick<type, keys> : never;
+
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any ? PartialBy<T, K> : never;
+
+/**
+ * @description Creates a type that is T with the required keys K.
+ *
+ * @example
+ * RequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
+ * => { a: string, b: number } | { a: string, c?: number }
+ */
+export type UnionRequiredBy<T, K extends keyof T> = T extends any ? RequiredBy<T, K> : never;

package/utils/wait.ts

@@ -0,0 +1,52 @@
+import { TimeoutError } from "../errors.js";
+
+/**
+ * Options for the wait function
+ */
+export type WaitOptions = {
+  /** Interval between retries in seconds. Defaults to 0.2 */
+  intervalSeconds?: number;
+  /** Maximum time to wait before timing out in seconds. Defaults to 10 */
+  timeoutSeconds?: number;
+};
+
+/**
+ * Polls a resource until a terminal condition is met or timeout occurs.
+ *
+ * @param reload - Function that fetches the latest state of the resource
+ * @param isTerminal - Function that determines if the current state is terminal
+ * @param transform - Function that transforms the resource into a new type
+ * @param options - Configuration options for polling behavior
+ * @returns The resource in its terminal state
+ * @throws {TimeoutError} If the operation exceeds the timeout duration
+ *
+ * @example
+ * const result = await wait(
+ *   () => fetchOrderStatus(orderId),
+ *   (status) => status === 'completed',
+ *   (status) => status === 'completed' ? { status } : undefined,
+ *   { timeoutSeconds: 30 }
+ * );
+ */
+export async function wait<T, K = T>(
+  reload: () => Promise<T>,
+  isTerminal: (obj: T) => boolean,
+  transform: (obj: T) => K = (obj: T) => obj as unknown as K,
+  options: WaitOptions = {},
+): Promise<K> {
+  const { intervalSeconds = 0.2, timeoutSeconds = 10 } = options;
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeoutSeconds * 1000) {
+    const updatedObject = await reload();
+
+    if (isTerminal(updatedObject)) {
+      return transform(updatedObject);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, intervalSeconds * 1000));
+  }
+  throw new TimeoutError(
+    `Operation has not reached a terminal state after ${timeoutSeconds} seconds and may still succeed. Retry with a longer timeout using the timeoutSeconds option.`,
+  );
+}

package/version.ts

@@ -0,0 +1 @@
+export const version = "1.3.0";

package/dist/auth/hooks/axios/index.d.ts

@@ -1 +0,0 @@
-export * from "./withAuth";

package/dist/auth/index.d.ts

@@ -1,4 +0,0 @@
-import * as axiosHooks from "./hooks/axios";
-export * from "./utils/http";
-export * from "./utils/jwt";
-export { axiosHooks };

package/dist/auth/utils/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./http";
-export * from "./jwt";

package/dist/client/evm/index.d.ts

@@ -1 +0,0 @@
-export { EvmClient } from "./evm";

package/dist/client/evm/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvmClient = void 0;
-var evm_1 = require("./evm");
-Object.defineProperty(exports, "EvmClient", { enumerable: true, get: function () { return evm_1.EvmClient; } });

package/dist/client/solana/index.d.ts

@@ -1 +0,0 @@
-export { SolanaClient } from "./solana";

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-import "./analytics";
-export { CdpClient } from "./client/cdp";
-export { EvmServerAccount, EvmSmartAccount } from "./accounts/types";

package/dist/openapi-client/cdpApiClient.js

@@ -1,146 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cdpApiClient = exports.configure = void 0;
-const axios_1 = __importStar(require("axios"));
-const axios_2 = require("../auth/hooks/axios");
-const errors_1 = require("./errors");
-const constants_1 = require("../constants");
-let axiosInstance;
-/**
- * Configures the CDP client with the given options.
- *
- * @param {CdpOptions} options - The CDP options.
- */
-const configure = (options) => {
-    axiosInstance = axios_1.default.create({
-        baseURL: options.basePath || "https://api.cdp.coinbase.com/platform",
-    });
-    axiosInstance = (0, axios_2.withAuth)(axiosInstance, {
-        apiKeyId: options.apiKeyId,
-        apiKeySecret: options.apiKeySecret,
-        source: options.source || "sdk-openapi-client",
-        sourceVersion: options.sourceVersion,
-        walletSecret: options.walletSecret,
-        expiresIn: options.expiresIn,
-        debug: options.debugging,
-    });
-};
-exports.configure = configure;
-/**
- * Adds an idempotency key to request config if provided
- *
- * @param config - The Axios request configuration.
- * @param idempotencyKey - The idempotency key.
- * @returns The Axios request configuration with the idempotency key.
- */
-const addIdempotencyKey = (config, idempotencyKey) => {
-    if (!idempotencyKey) {
-        return config;
-    }
-    return {
-        ...config,
-        headers: {
-            ...(config.headers || {}),
-            "X-Idempotency-Key": idempotencyKey,
-        },
-    };
-};
-/**
- * Mutates the given Axios request configuration to add the CDP API key signature
- * to the request headers.
- *
- * @param {AxiosRequestConfig} config - The Axios request configuration.
- * @param idempotencyKey - The idempotency key.
- * @returns {Promise<T>} A promise that resolves to the response data.
- * @throws {APIError} If the request fails.
- */
-const cdpApiClient = async (config, idempotencyKey) => {
-    validateCall(config);
-    // Add idempotency key to the request headers if provided
-    const configWithIdempotencyKey = addIdempotencyKey(config, idempotencyKey);
-    try {
-        const response = await axiosInstance(configWithIdempotencyKey);
-        return response.data;
-    }
-    catch (error) {
-        if (axios_1.default.isAxiosError(error) && error.response) {
-            if ((0, errors_1.isOpenAPIError)(error.response.data)) {
-                throw new errors_1.APIError(error.response.status, error.response.data.errorType, error.response.data.errorMessage, error.response.data.correlationId, error.response.data.errorLink);
-            }
-            else {
-                const statusCode = error.response.status;
-                switch (statusCode) {
-                    case 401:
-                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.unauthorized, "Unauthorized.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}#unauthorized`);
-                    case 404:
-                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.not_found, "API not found.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}#not_found`);
-                    case 502:
-                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.bad_gateway, "Bad gateway.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
-                    case 503:
-                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.service_unavailable, "Service unavailable. Please try again later.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
-                    default:
-                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.unexpected_error, "An unexpected error occurred.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
-                }
-            }
-        }
-        else if (axios_1.default.isAxiosError(error) && error.request) {
-            throw new errors_1.APIError(axios_1.HttpStatusCode.ServiceUnavailable, errors_1.HttpErrorType.service_unavailable, "Network error, unable to reach the service.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
-        }
-        else {
-            throw new errors_1.APIError(axios_1.HttpStatusCode.InternalServerError, errors_1.HttpErrorType.unexpected_error, error instanceof Error
-                ? error.message
-                : `An unexpected error occurred: ${JSON.stringify(error, Object.getOwnPropertyNames(error))}`, undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
-        }
-    }
-};
-exports.cdpApiClient = cdpApiClient;
-/**
- * Validates the call to the cdpApiClient.
- *
- * @param {AxiosRequestConfig} config - The Axios request configuration.
- * @throws {Error} If the call is not valid.
- */
-const validateCall = (config) => {
-    if (!axiosInstance.getUri() || axiosInstance.getUri() === "") {
-        throw new Error("CDP client URI not configured. Call configure() first.");
-    }
-    if (!config.url || config.url === "") {
-        throw new Error("AxiosRequestConfig URL is empty. This should never happen.");
-    }
-    if (!config.method || config.method === "") {
-        throw new Error("AxiosRequestConfig method is empty. This should never happen.");
-    }
-};

package/dist/openapi-client/generated/coinbaseDeveloperPlatformAPIs.schemas.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestSolanaFaucetBodyToken = exports.RequestEvmFaucetBodyToken = exports.RequestEvmFaucetBodyNetwork = exports.PrepareUserOperationBodyNetwork = exports.EvmUserOperationStatus = exports.EvmUserOperationNetwork = exports.ErrorType = void 0;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-exports.ErrorType = {
-    already_exists: 'already_exists',
-    faucet_limit_exceeded: 'faucet_limit_exceeded',
-    forbidden: 'forbidden',
-    idempotency_error: 'idempotency_error',
-    internal_server_error: 'internal_server_error',
-    invalid_request: 'invalid_request',
-    invalid_signature: 'invalid_signature',
-    malformed_transaction: 'malformed_transaction',
-    not_found: 'not_found',
-    rate_limit_exceeded: 'rate_limit_exceeded',
-    request_canceled: 'request_canceled',
-    timed_out: 'timed_out',
-    unauthorized: 'unauthorized',
-};
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-exports.EvmUserOperationNetwork = {
-    'base-sepolia': 'base-sepolia',
-    base: 'base',
-};
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-exports.EvmUserOperationStatus = {
-    pending: 'pending',
-    signed: 'signed',
-    broadcast: 'broadcast',
-    complete: 'complete',
-    failed: 'failed',
-};
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-exports.PrepareUserOperationBodyNetwork = {
-    'base-sepolia': 'base-sepolia',
-    base: 'base',
-};
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-exports.RequestEvmFaucetBodyNetwork = {
-    'base-sepolia': 'base-sepolia',
-    'ethereum-sepolia': 'ethereum-sepolia',
-};
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-exports.RequestEvmFaucetBodyToken = {
-    eth: 'eth',
-    usdc: 'usdc',
-    eurc: 'eurc',
-    cbbtc: 'cbbtc',
-};
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-exports.RequestSolanaFaucetBodyToken = {
-    sol: 'sol',
-    usdc: 'usdc',
-};