@inco/js 0.8.0-devnet-29 → 0.8.0-devnet-31

package/dist/esm/viem.d.ts

@@ -1,7 +1,356 @@
-import { Chain } from 'viem';
+import { Account, Chain, PublicClient, Transport, WalletClient } from 'viem';
 import { Chainish } from './chain.js';
+export type ViemClient = WalletClient<Transport, Chain, Account> | PublicClient<Transport, Chain>;
 /** Map of supported chain short names to their viem chain objects. */
 export declare const chains: {
+    mainnet: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Etherscan";
+                readonly url: "https://etherscan.io";
+                readonly apiUrl: "https://api.etherscan.io/api";
+            };
+        };
+        blockTime: 12000;
+        contracts: {
+            readonly ensUniversalResolver: {
+                readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+                readonly blockCreated: 23085558;
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 14353601;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 1;
+        name: "Ethereum";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://eth.merkle.io"];
+            };
+        };
+        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;
+    };
+    base: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Basescan";
+                readonly url: "https://basescan.org";
+                readonly apiUrl: "https://api.basescan.org/api";
+            };
+        };
+        blockTime: 2000;
+        contracts: {
+            readonly disputeGameFactory: {
+                readonly 1: {
+                    readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 1: {
+                    readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
+                };
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 5022;
+            };
+            readonly portal: {
+                readonly 1: {
+                    readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
+                    readonly blockCreated: 17482143;
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 1: {
+                    readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
+                    readonly blockCreated: 17482143;
+                };
+            };
+            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";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 8453;
+        name: "Base";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://mainnet.base.org"];
+            };
+        };
+        sourceId: 1;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters: {
+            readonly block: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
+                    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("viem").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, action?: string | undefined) => ({
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").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;
+                    value: bigint;
+                    gas: bigint;
+                    to: import("viem").Address | null;
+                    from: import("viem").Address;
+                    nonce: number;
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    transactionIndex: number | null;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    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("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").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("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").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("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").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("viem").Address;
+                    gas: bigint;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    nonce: number;
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    to: import("viem").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, action?: string | undefined) => {
+                    blobGasPrice?: bigint | undefined;
+                    blobGasUsed?: bigint | undefined;
+                    blockHash: import("viem").Hash;
+                    blockNumber: bigint;
+                    contractAddress: import("viem").Address | null | undefined;
+                    cumulativeGasUsed: bigint;
+                    effectiveGasPrice: bigint;
+                    from: import("viem").Address;
+                    gasUsed: bigint;
+                    logs: import("viem").Log<bigint, number, false>[];
+                    logsBloom: import("viem").Hex;
+                    root?: `0x${string}` | undefined;
+                    status: "success" | "reverted";
+                    to: import("viem").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;
+        };
+    };
     sepolia: {
         blockExplorers: {
             readonly default: {

package/dist/esm/viem.js

@@ -1,7 +1,9 @@
-import { anvil, baseSepolia, monadTestnet, plasmaTestnet, sepolia, worldchainSepolia, } from 'viem/chains';
+import { anvil, base, baseSepolia, mainnet, monadTestnet, plasmaTestnet, sepolia, worldchainSepolia, } from 'viem/chains';
 import { getSupportedChain } from './chain.js';
 /** Map of supported chain short names to their viem chain objects. */
 export const chains = {
+    mainnet,
+    base,
     sepolia,
     baseSepolia,
     monadTestnet,
@@ -27,4 +29,4 @@ export function getViemChain(chainish) {
     }
     return chain;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmllbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92aWVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFDTCxLQUFLLEVBQ0wsV0FBVyxFQUNYLFlBQVksRUFDWixhQUFhLEVBQ2IsT0FBTyxFQUNQLGlCQUFpQixHQUNsQixNQUFNLGFBQWEsQ0FBQztBQUNyQixPQUFPLEVBQVksaUJBQWlCLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFekQsc0VBQXNFO0FBQ3RFLE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRztJQUNwQixPQUFPO0lBQ1AsV0FBVztJQUNYLFlBQVk7SUFDWixhQUFhO0lBQ2IsS0FBSztJQUNMLGlCQUFpQjtDQUNsQixDQUFDO0FBRUY7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxRQUFrQjtJQUM3QyxNQUFNLEVBQUUsSUFBSSxFQUFFLEdBQUcsaUJBQWlCLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDN0MsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzNCLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLElBQUksRUFBRSxDQUFDLENBQUM7SUFDdkQsQ0FBQztJQUNELE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmllbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92aWVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFDTCxLQUFLLEVBQ0wsSUFBSSxFQUNKLFdBQVcsRUFDWCxPQUFPLEVBQ1AsWUFBWSxFQUNaLGFBQWEsRUFDYixPQUFPLEVBQ1AsaUJBQWlCLEdBQ2xCLE1BQU0sYUFBYSxDQUFDO0FBQ3JCLE9BQU8sRUFBWSxpQkFBaUIsRUFBRSxNQUFNLFlBQVksQ0FBQztBQU16RCxzRUFBc0U7QUFDdEUsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHO0lBQ3BCLE9BQU87SUFDUCxJQUFJO0lBQ0osT0FBTztJQUNQLFdBQVc7SUFDWCxZQUFZO0lBQ1osYUFBYTtJQUNiLEtBQUs7SUFDTCxpQkFBaUI7Q0FDbEIsQ0FBQztBQUVGOzs7Ozs7Ozs7R0FTRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQUMsUUFBa0I7SUFDN0MsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLGlCQUFpQixDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQzdDLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUMzQixJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDWCxNQUFNLElBQUksS0FBSyxDQUFDLDZCQUE2QixJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMifQ==

package/dist/types/advancedacl/session-key.d.ts

@@ -42,8 +42,8 @@ export interface SessionKeyAttestedComputeArgs {
     rhsPlaintext: bigint | boolean;
     requesterArgData?: Hex | undefined;
     backoffConfig?: Partial<BackoffConfig> | undefined;
-    ethClient?: PublicClient<Transport, Chain> | WalletClient<Transport, Chain, Account> | undefined;
-    executorAddress?: HexString | undefined;
+    ethClient: PublicClient<Transport, Chain>;
+    executorAddress: HexString;
     reencryptPubKey?: Uint8Array | undefined;
     reencryptKeypair?: XwingKeypair | undefined;
 }
@@ -58,8 +58,8 @@ export interface SessionKeyAttestedDecryptArgs {
     backoffConfig?: Partial<BackoffConfig> | undefined;
     reencryptPubKey?: Uint8Array | undefined;
     reencryptKeypair?: XwingKeypair | undefined;
-    ethClient?: PublicClient<Transport, Chain> | WalletClient<Transport, Chain, Account> | undefined;
-    executorAddress?: HexString | undefined;
+    ethClient: PublicClient<Transport, Chain>;
+    executorAddress: HexString;
 }
 /**
  * Performs attested decrypts using a voucher-backed session key.

package/dist/types/attestedcompute/attested-compute.d.ts

@@ -8,7 +8,6 @@ import { type XwingKeypair } from '../lite/xwing.js';
 import type { BackoffConfig } from '../retry.js';
 import { AttestedComputeOP } from './types.js';
 export declare const ATTESTED_COMPUTE_DOMAIN_NAME = "IncoAttestedCompute";
-export declare const DEFAULT_ATTESTED_COMPUTE_DOMAIN_VERSION = "2";
 /**
  * Arguments for creating an attested compute.
  */

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

@@ -1,7 +1,8 @@
-import type { Account, Chain, PublicClient, Transport, WalletClient } from 'viem';
+import type { Account, Chain, Transport, WalletClient } from 'viem';
 import { type HexString } from '../binary.js';
 import { type SupportedChainId } from '../chain.js';
 import { EncryptionScheme, type SupportedFheType } from '../encryption/encryption.js';
+import { type HandleWithProof } from '../generated/es/inco/kms/lite/v1/types_pb.js';
 import { validateHandle } from '../handle.js';
 import { KmsQuorumClient } from '../kms/quorumClient.js';
 import type { XwingKeypair } from '../lite/xwing.js';
@@ -9,8 +10,6 @@ import type { BackoffConfig } from '../retry.js';
 import { type DecryptionAttestation, type EncryptedDecryptionAttestation } from './types.js';
 export { validateHandle };
 export declare const ATTESTED_DECRYPT_DOMAIN_NAME = "IncoAttestedDecrypt";
-export declare const DEFAULT_ATTESTED_DECRYPT_DOMAIN_VERSION = "2";
-export declare const TEST_RPC_URL = "UNUSED IN TEST";
 /**
  * Arguments for creating an attested decrypt request.
  */
@@ -58,5 +57,5 @@ export declare function attestedDecrypt({ handles, backoffConfig, walletClient,
     kmsQuorumClient: KmsQuorumClient;
     executorAddress: HexString;
 }): Promise<Array<EncryptedDecryptionAttestation<EncryptionScheme, SupportedFheType>>>;
-export declare function fetchEip712DomainVersion(executorAddress: HexString | undefined, defaultVersion: string, walletClient?: WalletClient<Transport, Chain, Account> | PublicClient<Transport, Chain>): Promise<string>;
+export declare function buildHandlesWithProofs(handles: HexString[]): Array<HandleWithProof>;
 export declare function decryptEncryptedAttestations(attestations: Array<DecryptionAttestation<EncryptionScheme, SupportedFheType> | EncryptedDecryptionAttestation<EncryptionScheme, SupportedFheType>>, reencryptKeypair: XwingKeypair): Promise<Array<DecryptionAttestation<EncryptionScheme, SupportedFheType>>>;

package/dist/types/chain.d.ts

@@ -5,6 +5,8 @@
  * to work around Pulumi closure serialisation issues.
  */
 export declare const supportedChains: {
+    readonly mainnet: 1;
+    readonly base: 8453;
     readonly baseSepolia: 84532;
     readonly sepolia: 11155111;
     readonly monadTestnet: 10143;
@@ -28,6 +30,12 @@ export type Numberish = number | bigint;
 export type Chainish = {
     id: Numberish;
 } | Numberish | string;
+/**
+ * Map of supported chain IDs to their short names.
+ * Public networks use the `shortName` from https://github.com/ethereum-lists/chains.
+ * Local Anvil uses `31337` (same ID as GoChain Testnet in the registry) but the SDK labels it `anvil`.
+ */
+export declare const chainShortNames: Record<SupportedChainId, string>;
 /**
  * Resolves a {@link Chainish} value to a {@link SupportedChain}.
  *

package/dist/types/eip712/eip712.d.ts

@@ -0,0 +1,18 @@
+import type { Account, Chain, Transport, WalletClient } from 'viem';
+import type { HexString } from '../binary.js';
+import type { SupportedChainId } from '../chain.js';
+import { ViemClient } from '../viem.js';
+export declare function fetchEip712DomainVersion(executorAddress: HexString, ethClient: ViemClient): Promise<string>;
+export declare function buildEip712Payload(params: {
+    executorAddress: HexString;
+    ethClient: ViemClient;
+    chainId: SupportedChainId;
+    handles: HexString[];
+    reencryptPubKey: Uint8Array;
+}): Promise<import("../reencryption/eip712.js").EIP712<{
+    handles: `0x${string}`[];
+    publicKey: `0x${string}`;
+}>>;
+type WalletSignTypedDataParams = Parameters<WalletClient<Transport, Chain, Account>['signTypedData']>[0];
+export declare function signEip712(walletClient: WalletClient<Transport, Chain, Account>, eip712Payload: WalletSignTypedDataParams): Promise<`0x${string}`>;
+export {};

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

@@ -0,0 +1 @@
+export { buildEip712Payload, fetchEip712DomainVersion, signEip712, } from './eip712.js';

package/dist/types/elistattesteddecrypt/elist-attested-decrypt.d.ts

@@ -0,0 +1,49 @@
+import type { Account, Chain, Transport, WalletClient } from 'viem';
+import { validateHandle } from '../attesteddecrypt/attested-decrypt.js';
+import { type HexString } from '../binary.js';
+import { type SupportedChainId } from '../chain.js';
+import { type EncryptionScheme, type SupportedFheType } from '../encryption/encryption.js';
+import { KmsQuorumClient } from '../kms/quorumClient.js';
+import type { XwingKeypair } from '../lite/xwing.js';
+import type { BackoffConfig } from '../retry.js';
+import { type EListDecryptionAttestation, type EncryptedEListDecryptionAttestation } from './types.js';
+export { validateHandle };
+export declare function eListAttestedDecrypt({ handle, backoffConfig, walletClient, chainId, reencryptPubKey, reencryptKeypair, kmsQuorumClient, executorAddress, }: {
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    chainId: SupportedChainId;
+    reencryptPubKey: Uint8Array;
+    reencryptKeypair: XwingKeypair;
+    kmsQuorumClient: KmsQuorumClient;
+    executorAddress: HexString;
+}): Promise<EListDecryptionAttestation<EncryptionScheme, SupportedFheType>>;
+export declare function eListAttestedDecrypt({ handle, backoffConfig, walletClient, chainId, reencryptPubKey, kmsQuorumClient, executorAddress, }: {
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    chainId: SupportedChainId;
+    reencryptPubKey: Uint8Array;
+    reencryptKeypair?: never;
+    kmsQuorumClient: KmsQuorumClient;
+    executorAddress: HexString;
+}): Promise<EncryptedEListDecryptionAttestation<EncryptionScheme, SupportedFheType>>;
+export declare function eListAttestedDecrypt({ handle, backoffConfig, walletClient, chainId, kmsQuorumClient, executorAddress, }: {
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    chainId: SupportedChainId;
+    reencryptPubKey?: never;
+    reencryptKeypair?: never;
+    kmsQuorumClient: KmsQuorumClient;
+    executorAddress: HexString;
+}): Promise<EListDecryptionAttestation<EncryptionScheme, SupportedFheType>>;
+/**
+ * Reveal a single elist handle without wallet authentication.
+ * Returns plaintext values along with an attestation of the checksum.
+ */
+export declare function eListAttestedReveal({ handle, backoffConfig, kmsQuorumClient, }: {
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    kmsQuorumClient: KmsQuorumClient;
+}): Promise<EListDecryptionAttestation<EncryptionScheme, SupportedFheType>>;

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

@@ -0,0 +1,2 @@
+export { eListAttestedDecrypt, eListAttestedReveal, } from './elist-attested-decrypt.js';
+export * from './types.js';

package/dist/types/elistattesteddecrypt/types.d.ts

@@ -0,0 +1,31 @@
+import type { HexString } from '../binary.js';
+import type { EncryptionScheme, EncryptResultOf, PlaintextOf, SupportedFheType } from '../encryption/encryption.js';
+import { handleTypes } from '../index.js';
+import type { BackoffConfig } from '../retry.js';
+/**
+ * Custom error class for elist attested decrypt operations.
+ */
+export declare class EListAttestedDecryptError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export type EListDecryptionAttestation<S extends EncryptionScheme, T extends SupportedFheType> = {
+    handle: HexString;
+    commitmentProof: PlaintextOf<S, typeof handleTypes.euint256>;
+    values: PlaintextOf<S, T>[];
+    covalidatorSignatures: Uint8Array[];
+    commitments: Uint8Array[];
+};
+export type EncryptedEListDecryptionAttestation<S extends EncryptionScheme, T extends SupportedFheType> = {
+    handle: HexString;
+    commitmentProof: PlaintextOf<S, typeof handleTypes.euint256>;
+    values: EncryptResultOf<S, T>[];
+    covalidatorSignatures: Uint8Array[];
+    commitments: Uint8Array[];
+};
+export type EListAttestedDecryptor<S extends EncryptionScheme> = <T extends SupportedFheType>(args: EListAttestedDecryptFnArgs<S, T>) => Promise<EListDecryptionAttestation<S, T>>;
+export type EListAttestedDecryptFnArgs<S extends EncryptionScheme, T extends SupportedFheType> = {
+    /** The handle to decrypt */
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig>;
+};

package/dist/types/generated/abis/lightning.d.ts

@@ -711,20 +711,6 @@ export declare const incoLightningAbi: readonly [{
         readonly type: "bytes32";
     }];
     readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "randType";
-        readonly internalType: "enum ETypes";
-        readonly type: "uint8";
-    }];
-    readonly name: "eRand";
-    readonly outputs: readonly [{
-        readonly name: "result";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly stateMutability: "payable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
@@ -2213,31 +2199,6 @@ export declare const incoLightningAbi: readonly [{
         readonly indexed: false;
     }];
     readonly name: "ENot";
-}, {
-    readonly type: "event";
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly name: "counter";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: true;
-    }, {
-        readonly name: "randType";
-        readonly internalType: "enum ETypes";
-        readonly type: "uint8";
-        readonly indexed: false;
-    }, {
-        readonly name: "result";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-        readonly indexed: true;
-    }, {
-        readonly name: "eventId";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }];
-    readonly name: "ERand";
 }, {
     readonly type: "event";
     readonly anonymous: false;

package/dist/types/generated/abis/test-elist.d.ts

@@ -141,6 +141,12 @@ export declare const elistTesterAbi: readonly [{
         readonly type: "bytes32";
     }];
     readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "listReveal";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly inputs: readonly [];