@inco/js 0.2.15 → 0.2.17

package/dist/esm/schema.js

@@ -0,0 +1,15 @@
+import { Schema } from 'effect';
+// parse takes an effect Schema object and parses an unknown value into that schema, if parsing fails an error is thrown
+// only fields specified in the schema will be present in the parsed object.
+export function parse(schema, obj, options) {
+    return Schema.decodeUnknownSync(schema)(obj, options);
+}
+// parseJson takes an effect Schema object and parses a JSON string into that schema, if parsing fails an error is thrown
+// only fields specified in the schema will be present in the parsed object.
+export function parseJson(schema, json, options) {
+    if (typeof json !== 'string') {
+        json = json.toString();
+    }
+    return Schema.decodeUnknownSync(Schema.parseJson(schema))(json, options);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NjaGVtYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBR2hDLHdIQUF3SDtBQUN4SCw0RUFBNEU7QUFDNUUsTUFBTSxVQUFVLEtBQUssQ0FBTyxNQUEyQixFQUFFLEdBQVksRUFBRSxPQUFzQjtJQUMzRixPQUFPLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDeEQsQ0FBQztBQUVELHlIQUF5SDtBQUN6SCw0RUFBNEU7QUFDNUUsTUFBTSxVQUFVLFNBQVMsQ0FBTyxNQUEyQixFQUFFLElBQXlCLEVBQUUsT0FBc0I7SUFDNUcsSUFBSSxPQUFPLElBQUksS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUM3QixJQUFJLEdBQUcsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3pCLENBQUM7SUFDRCxPQUFPLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQzNFLENBQUMifQ==

package/dist/esm/viem.d.ts

@@ -0,0 +1,427 @@
+import { Chainish } from './chain.js';
+export declare const chains: {
+    sepolia: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Etherscan";
+                readonly url: "https://sepolia.etherscan.io";
+                readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+            };
+        };
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 751532;
+            };
+            readonly ensRegistry: {
+                readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+            };
+            readonly ensUniversalResolver: {
+                readonly address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC";
+                readonly blockCreated: 5317080;
+            };
+        };
+        id: 11155111;
+        name: "Sepolia";
+        nativeCurrency: {
+            readonly name: "Sepolia Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://sepolia.drpc.org"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    };
+    baseSepolia: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Basescan";
+                readonly url: "https://sepolia.basescan.org";
+                readonly apiUrl: "https://api-sepolia.basescan.org/api";
+            };
+        };
+        contracts: {
+            readonly disputeGameFactory: {
+                readonly 11155111: {
+                    readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 11155111: {
+                    readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
+                };
+            };
+            readonly portal: {
+                readonly 11155111: {
+                    readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
+                    readonly blockCreated: 4446677;
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 11155111: {
+                    readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
+                    readonly blockCreated: 4446677;
+                };
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 1059647;
+            };
+            readonly gasPriceOracle: {
+                readonly address: "0x420000000000000000000000000000000000000F";
+            };
+            readonly l1Block: {
+                readonly address: "0x4200000000000000000000000000000000000015";
+            };
+            readonly l2CrossDomainMessenger: {
+                readonly address: "0x4200000000000000000000000000000000000007";
+            };
+            readonly l2Erc721Bridge: {
+                readonly address: "0x4200000000000000000000000000000000000014";
+            };
+            readonly l2StandardBridge: {
+                readonly address: "0x4200000000000000000000000000000000000010";
+            };
+            readonly l2ToL1MessagePasser: {
+                readonly address: "0x4200000000000000000000000000000000000016";
+            };
+        };
+        id: 84532;
+        name: "Base Sepolia";
+        nativeCurrency: {
+            readonly name: "Sepolia Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://sepolia.base.org"];
+            };
+        };
+        sourceId: 11155111;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters: {
+            readonly block: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcBlock) => {
+                    baseFeePerGas: bigint | null;
+                    blobGasUsed: bigint;
+                    difficulty: bigint;
+                    excessBlobGas: bigint;
+                    extraData: import("viem").Hex;
+                    gasLimit: bigint;
+                    gasUsed: bigint;
+                    hash: `0x${string}` | null;
+                    logsBloom: `0x${string}` | null;
+                    miner: import("abitype").Address;
+                    mixHash: import("viem").Hash;
+                    nonce: `0x${string}` | null;
+                    number: bigint | null;
+                    parentBeaconBlockRoot?: `0x${string}` | undefined;
+                    parentHash: import("viem").Hash;
+                    receiptsRoot: import("viem").Hex;
+                    sealFields: import("viem").Hex[];
+                    sha3Uncles: import("viem").Hash;
+                    size: bigint;
+                    stateRoot: import("viem").Hash;
+                    timestamp: bigint;
+                    totalDifficulty: bigint | null;
+                    transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+                    transactionsRoot: import("viem").Hash;
+                    uncles: import("viem").Hash[];
+                    withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
+                    withdrawalsRoot?: `0x${string}` | undefined;
+                } & {};
+                type: "block";
+            };
+            readonly transaction: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("abitype").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: boolean;
+                    mint?: bigint | undefined | undefined;
+                    sourceHash: import("viem").Hex;
+                    type: "deposit";
+                } | {
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    v: bigint;
+                    to: import("abitype").Address | null;
+                    from: import("abitype").Address;
+                    gas: bigint;
+                    nonce: number;
+                    value: bigint;
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    accessList?: undefined | undefined;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId?: number | undefined;
+                    yParity?: undefined | undefined;
+                    type: "legacy";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("abitype").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip2930";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("abitype").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip1559";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("abitype").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes: readonly import("viem").Hex[];
+                    chainId: number;
+                    type: "eip4844";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas: bigint;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("abitype").Address | null;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList: import("viem").SignedAuthorizationList;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip7702";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                }) & {};
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                    blobGasPrice?: bigint | undefined;
+                    blobGasUsed?: bigint | undefined;
+                    blockHash: import("viem").Hash;
+                    blockNumber: bigint;
+                    contractAddress: import("abitype").Address | null | undefined;
+                    cumulativeGasUsed: bigint;
+                    effectiveGasPrice: bigint;
+                    from: import("abitype").Address;
+                    gasUsed: bigint;
+                    logs: import("viem").Log<bigint, number, false>[];
+                    logsBloom: import("viem").Hex;
+                    root?: `0x${string}` | undefined;
+                    status: "success" | "reverted";
+                    to: import("abitype").Address | null;
+                    transactionHash: import("viem").Hash;
+                    transactionIndex: number;
+                    type: import("viem").TransactionType;
+                    l1GasPrice: bigint | null;
+                    l1GasUsed: bigint | null;
+                    l1Fee: bigint | null;
+                    l1FeeScalar: number | null;
+                } & {};
+                type: "transactionReceipt";
+            };
+        };
+        serializers: {
+            readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+        };
+        readonly network: "base-sepolia";
+    };
+    monadTestnet: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Monad Testnet explorer";
+                readonly url: "https://testnet.monadexplorer.com";
+            };
+        };
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                readonly blockCreated: 251449;
+            };
+        };
+        id: 10143;
+        name: "Monad Testnet";
+        nativeCurrency: {
+            readonly name: "Testnet MON Token";
+            readonly symbol: "MON";
+            readonly decimals: 18;
+        };
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://testnet-rpc.monad.xyz"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    };
+    anvil: {
+        blockExplorers?: {
+            [key: string]: {
+                name: string;
+                url: string;
+                apiUrl?: string | undefined;
+            };
+            default: {
+                name: string;
+                url: string;
+                apiUrl?: string | undefined;
+            };
+        } | undefined | undefined;
+        contracts?: {
+            [x: string]: import("viem").ChainContract | {
+                [sourceId: number]: import("viem").ChainContract | undefined;
+            } | undefined;
+            ensRegistry?: import("viem").ChainContract | undefined;
+            ensUniversalResolver?: import("viem").ChainContract | undefined;
+            multicall3?: import("viem").ChainContract | undefined;
+            universalSignatureVerifier?: import("viem").ChainContract | undefined;
+        } | undefined;
+        id: 31337;
+        name: "Anvil";
+        nativeCurrency: {
+            readonly decimals: 18;
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+        };
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["http://127.0.0.1:8545"];
+                readonly webSocket: readonly ["ws://127.0.0.1:8545"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    };
+};
+type ChainName = keyof typeof chains;
+export type ViemChain = (typeof chains)[ChainName];
+export declare function getViemChain(chainish: Chainish): ViemChain;
+export {};

package/dist/esm/viem.js

@@ -0,0 +1,8 @@
+import { anvil, baseSepolia, monadTestnet, sepolia } from 'viem/chains';
+import { getSupportedChain } from './chain.js';
+export const chains = { sepolia, baseSepolia, monadTestnet, anvil };
+export function getViemChain(chainish) {
+    const { name } = getSupportedChain(chainish);
+    return chains[name];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmllbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92aWVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDeEUsT0FBTyxFQUFZLGlCQUFpQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRXpELE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxDQUFDO0FBTXBFLE1BQU0sVUFBVSxZQUFZLENBQUMsUUFBa0I7SUFDN0MsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLGlCQUFpQixDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQzdDLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ3RCLENBQUMifQ==

package/dist/types/attesteddecrypt/attested-decrypt.d.ts

@@ -0,0 +1,34 @@
+import type { Account, Chain, Transport, WalletClient } from 'viem';
+import { SupportedChainId } from '../chain.js';
+import { EciesScheme } from '../encryption/encryption.js';
+import type { KmsClient } from '../kms/client.js';
+import { AttestedDecryptor } from './types.js';
+/**
+ * Arguments for creating an attested decryptor.
+ */
+export interface IncoLiteAttestedDecryptorArgs {
+    /** The wallet used to interact with the blockchain and sign the decrypt request */
+    walletClient: WalletClient<Transport, Chain, Account>;
+    /** The KMS connect RPC endpoint or client instance */
+    kmsConnectRpcEndpointOrClient?: string | KmsClient;
+    /** The chain ID to use */
+    chainId: SupportedChainId;
+}
+/**
+ * Creates an attested decryptor that can decrypt handles with an attached attestation from the covalidator.
+ * @param args - The arguments for creating the decryptor
+ * @returns A function that can decrypt handles using attestation
+ * @throws {AttestedDecryptError} If the decryptor creation fails
+ *
+ * @todo Support multiple handles in a single request.
+ *
+ * @example
+ * ```typescript
+ * const decryptor = await incoLiteAttestedDecryptor({
+ *   walletClient,
+ *   chainId: sepolia,
+ * });
+ * const { plaintext, covalidatorSignature } = await decryptor({ handle: '0x...' });
+ * ```
+ */
+export declare function incoLiteAttestedDecryptor({ kmsConnectRpcEndpointOrClient, chainId, walletClient, }: IncoLiteAttestedDecryptorArgs): AttestedDecryptor<EciesScheme>;

package/dist/types/attesteddecrypt/index.d.ts

@@ -0,0 +1,2 @@
+export * from './attested-decrypt.js';
+export * from './types.js';

package/dist/types/attesteddecrypt/types.d.ts

@@ -0,0 +1,18 @@
+import { HexString } from '../binary.js';
+import { EncryptionScheme, PlaintextOf, SupportedFheType } from '../encryption/encryption.js';
+import type { BackoffConfig } from '../retry.js';
+/**
+ * Custom error class for attested decrypt operations.
+ */
+export declare class AttestedDecryptError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export type AttestedDecryptor<S extends EncryptionScheme> = <T extends SupportedFheType>(args: {
+    /** The handle to decrypt */
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig>;
+}) => Promise<{
+    plaintext: PlaintextOf<S, T>;
+    covalidatorSignature: Uint8Array;
+}>;

package/dist/types/binary.d.ts

@@ -0,0 +1,21 @@
+import { Schema } from 'effect';
+import { Hex } from 'viem';
+export declare const HexString: Schema.TemplateLiteral<`0x${string}`>;
+export type HexString = typeof HexString.Type;
+export type BytesIsh = string | Uint8Array;
+export declare function bytesToBigInt(byteArray: Uint8Array): bigint;
+export declare function bufferToBigInt(buffer: Buffer): bigint;
+export declare function bigintToBytes32(value: bigint): Bytes32;
+export declare function padLeft(bs: Uint8Array, n: number): Buffer;
+export declare function bytes32ToBigint(bs: BytesIsh): bigint;
+export declare function bytesFromHexString(hexString: string): Buffer;
+export declare function mustBeHex(value: string): Hex;
+export declare function normaliseToHex(value: string): Hex;
+export declare function bytesToHex(bs: Uint8Array): Hex;
+export declare const Bytes32: Schema.brand<Schema.filter<Schema.transformOrFail<Schema.Union<[typeof Schema.String, Schema.refine<object & Uint8Array<ArrayBufferLike>, Schema.Schema<object, object, never>>]>, Schema.TemplateLiteral<`0x${string}`>, never>>, "Bytes32">;
+export declare function asBytes32(x: BytesIsh): Bytes32;
+export type Bytes32 = typeof Bytes32.Type;
+export type Address = typeof Address.Type;
+export declare const Address: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
+export declare function parseAddress(address: string): Address;
+export declare function parseHex(hex: string): HexString;

package/dist/types/chain.d.ts

@@ -0,0 +1,22 @@
+export declare const supportedChains: {
+    readonly baseSepolia: 84532;
+    readonly sepolia: 11155111;
+    readonly monadTestnet: 10143;
+};
+export declare const fheSupportedChains: {
+    readonly baseSepolia: 84532;
+    readonly sepolia: 11155111;
+};
+type SupportedChains = typeof supportedChains;
+export type SupportedChainId = SupportedChains[keyof SupportedChains];
+export type SupportedChainName = keyof SupportedChains;
+export type SupportedChain = {
+    name: SupportedChainName;
+    id: SupportedChainId;
+};
+export type Numberish = number | bigint;
+export type Chainish = {
+    id: Numberish;
+} | Numberish | string;
+export declare function getSupportedChain(chainish: Chainish): SupportedChain;
+export {};