@inco/js 0.2.17 → 0.3.0

package/dist/cjs/viem.d.ts

@@ -8,6 +8,7 @@ export declare const chains: {
                 readonly apiUrl: "https://api-sepolia.etherscan.io/api";
             };
         };
+        blockTime?: number | undefined | undefined;
         contracts: {
             readonly multicall3: {
                 readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
@@ -21,6 +22,7 @@ export declare const chains: {
                 readonly blockCreated: 5317080;
             };
         };
+        ensTlds?: readonly string[] | undefined;
         id: 11155111;
         name: "Sepolia";
         nativeCurrency: {
@@ -28,6 +30,7 @@ export declare const chains: {
             readonly symbol: "ETH";
             readonly decimals: 18;
         };
+        experimental_preconfirmationTime?: number | undefined | undefined;
         rpcUrls: {
             readonly default: {
                 readonly http: readonly ["https://sepolia.drpc.org"];
@@ -48,6 +51,7 @@ export declare const chains: {
                 readonly apiUrl: "https://api-sepolia.basescan.org/api";
             };
         };
+        blockTime: 2000;
         contracts: {
             readonly disputeGameFactory: {
                 readonly 11155111: {
@@ -94,6 +98,7 @@ export declare const chains: {
                 readonly address: "0x4200000000000000000000000000000000000016";
             };
         };
+        ensTlds?: readonly string[] | undefined;
         id: 84532;
         name: "Base Sepolia";
         nativeCurrency: {
@@ -101,6 +106,7 @@ export declare const chains: {
             readonly symbol: "ETH";
             readonly decimals: 18;
         };
+        experimental_preconfirmationTime?: number | undefined | undefined;
         rpcUrls: {
             readonly default: {
                 readonly http: readonly ["https://sepolia.base.org"];
@@ -353,12 +359,14 @@ export declare const chains: {
                 readonly url: "https://testnet.monadexplorer.com";
             };
         };
+        blockTime?: number | undefined | undefined;
         contracts: {
             readonly multicall3: {
                 readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
                 readonly blockCreated: 251449;
             };
         };
+        ensTlds?: readonly string[] | undefined;
         id: 10143;
         name: "Monad Testnet";
         nativeCurrency: {
@@ -366,6 +374,7 @@ export declare const chains: {
             readonly symbol: "MON";
             readonly decimals: 18;
         };
+        experimental_preconfirmationTime?: number | undefined | undefined;
         rpcUrls: {
             readonly default: {
                 readonly http: readonly ["https://testnet-rpc.monad.xyz"];
@@ -378,6 +387,44 @@ export declare const chains: {
         formatters?: undefined;
         serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
     };
+    plasmaTestnet: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "RouteScan";
+                readonly url: "https://testnet.plasmaexplorer.io";
+            };
+        };
+        blockTime?: number | 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;
+        ensTlds?: readonly string[] | undefined;
+        id: 9746;
+        name: "Plasma Testnet";
+        nativeCurrency: {
+            readonly name: "Testnet Plasma";
+            readonly symbol: "XPL";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://testnet-rpc.plasma.to"];
+            };
+        };
+        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]: {
@@ -391,6 +438,7 @@ export declare const chains: {
                 apiUrl?: string | undefined;
             };
         } | undefined | undefined;
+        blockTime?: number | undefined | undefined;
         contracts?: {
             [x: string]: import("viem").ChainContract | {
                 [sourceId: number]: import("viem").ChainContract | undefined;
@@ -400,6 +448,7 @@ export declare const chains: {
             multicall3?: import("viem").ChainContract | undefined;
             universalSignatureVerifier?: import("viem").ChainContract | undefined;
         } | undefined;
+        ensTlds?: readonly string[] | undefined;
         id: 31337;
         name: "Anvil";
         nativeCurrency: {
@@ -407,6 +456,7 @@ export declare const chains: {
             readonly name: "Ether";
             readonly symbol: "ETH";
         };
+        experimental_preconfirmationTime?: number | undefined | undefined;
         rpcUrls: {
             readonly default: {
                 readonly http: readonly ["http://127.0.0.1:8545"];
@@ -420,6 +470,318 @@ export declare const chains: {
         formatters?: undefined;
         serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
     };
+    worldchainSepolia: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Worldscan Sepolia";
+                readonly url: "https://sepolia.worldscan.org";
+                readonly apiUrl: "https://api-sepolia.worldscan.org/api";
+            };
+            readonly blockscout: {
+                readonly name: "Blockscout";
+                readonly url: "https://worldchain-sepolia.explorer.alchemy.com";
+                readonly apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api";
+            };
+        };
+        blockTime: 2000;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 0;
+            };
+            readonly disputeGameFactory: {
+                readonly 11155111: {
+                    readonly address: "0x8Ec1111f67Dad6b6A93B3F42DfBC92D81c98449A";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 11155111: {
+                    readonly address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e";
+                };
+            };
+            readonly portal: {
+                readonly 11155111: {
+                    readonly address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4";
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 11155111: {
+                    readonly address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE";
+                };
+            };
+            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: 4801;
+        name: "World Chain Sepolia";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://worldchain-sepolia.g.alchemy.com/public"];
+            };
+        };
+        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: "worldchain-sepolia";
+    };
 };
 type ChainName = keyof typeof chains;
 export type ViemChain = (typeof chains)[ChainName];

package/dist/cjs/viem.js

@@ -4,9 +4,9 @@ exports.chains = void 0;
 exports.getViemChain = getViemChain;
 const chains_1 = require("viem/chains");
 const chain_js_1 = require("./chain.js");
-exports.chains = { sepolia: chains_1.sepolia, baseSepolia: chains_1.baseSepolia, monadTestnet: chains_1.monadTestnet, anvil: chains_1.anvil };
+exports.chains = { sepolia: chains_1.sepolia, baseSepolia: chains_1.baseSepolia, monadTestnet: chains_1.monadTestnet, plasmaTestnet: chains_1.plasmaTestnet, anvil: chains_1.anvil, worldchainSepolia: chains_1.worldchainSepolia };
 function getViemChain(chainish) {
     const { name } = (0, chain_js_1.getSupportedChain)(chainish);
     return exports.chains[name];
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmllbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92aWVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVNBLG9DQUdDO0FBWkQsd0NBQXdFO0FBQ3hFLHlDQUF5RDtBQUU1QyxRQUFBLE1BQU0sR0FBRyxFQUFFLE9BQU8sRUFBUCxnQkFBTyxFQUFFLFdBQVcsRUFBWCxvQkFBVyxFQUFFLFlBQVksRUFBWixxQkFBWSxFQUFFLEtBQUssRUFBTCxjQUFLLEVBQUUsQ0FBQztBQU1wRSxTQUFnQixZQUFZLENBQUMsUUFBa0I7SUFDN0MsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLElBQUEsNEJBQWlCLEVBQUMsUUFBUSxDQUFDLENBQUM7SUFDN0MsT0FBTyxjQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDdEIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmllbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92aWVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVNBLG9DQUdDO0FBWkQsd0NBQTBHO0FBQzFHLHlDQUF5RDtBQUU1QyxRQUFBLE1BQU0sR0FBRyxFQUFFLE9BQU8sRUFBUCxnQkFBTyxFQUFFLFdBQVcsRUFBWCxvQkFBVyxFQUFFLFlBQVksRUFBWixxQkFBWSxFQUFFLGFBQWEsRUFBYixzQkFBYSxFQUFFLEtBQUssRUFBTCxjQUFLLEVBQUUsaUJBQWlCLEVBQWpCLDBCQUFpQixFQUFFLENBQUM7QUFNdEcsU0FBZ0IsWUFBWSxDQUFDLFFBQWtCO0lBQzdDLE1BQU0sRUFBRSxJQUFJLEVBQUUsR0FBRyxJQUFBLDRCQUFpQixFQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQzdDLE9BQU8sY0FBTSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ3RCLENBQUMifQ==

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

@@ -0,0 +1,38 @@
+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 { AttestedCompute } from './types.js';
+/**
+ * Arguments for creating an attested compute.
+ */
+export interface IncoLiteAttestedComputeArgs {
+    /** The wallet used to interact with the blockchain and sign the compute 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 compute function that can decrypt handles with an attached attestation from the covalidator.
+ * @param args - The arguments for creating the attested compute function
+ * @returns A function that can perform binary operation on a handle and return an attestation
+ * @throws {AttestedComputeError} If the creation fails
+ *
+ * @todo Support multiple operations in a single request.
+ *
+ * @example
+ * ```typescript
+ * const compute = await incoLiteAttestedCompute({
+ *   walletClient,
+ *   chainId: sepolia,
+ * });
+ * const decryptionAttestation = await compute({
+ *   lhsHandle: '0x...',
+ *   op: AttestedComputeSupportedOps.Eq,
+ *   rhsPlaintext: 1337n,
+ * });
+ * ```
+ */
+export declare function incoLiteAttestedCompute({ kmsConnectRpcEndpointOrClient, chainId, walletClient, }: IncoLiteAttestedComputeArgs): AttestedCompute<EciesScheme>;

package/dist/esm/attestedcompute/attested-compute.js

@@ -0,0 +1,95 @@
+import { hexToBytes } from 'viem';
+import { validateHandle } from '../attesteddecrypt/attested-decrypt.js';
+import { bigintToBytes32, bytesToBigInt } from '../binary.js';
+import { getSupportedChain } from '../chain.js';
+import { bigintToPlaintext, encryptionSchemes } from '../encryption/encryption.js';
+import { getHandleType } from '../handle.js';
+import { defaultCovalidatorGrpc, getKmsClient } from '../kms/client.js';
+import { createEIP712Payload } from '../reencryption/eip712.js';
+import { retryWithBackoff } from '../retry.js';
+import { AttestedComputeError } from './types.js';
+const ATTESTED_COMPUTE_DOMAIN_NAME = 'IncoAttestedCompute';
+const ATTESTED_COMPUTE_DOMAIN_VERSION = '0.1.0';
+/**
+ * Creates an attested compute function that can decrypt handles with an attached attestation from the covalidator.
+ * @param args - The arguments for creating the attested compute function
+ * @returns A function that can perform binary operation on a handle and return an attestation
+ * @throws {AttestedComputeError} If the creation fails
+ *
+ * @todo Support multiple operations in a single request.
+ *
+ * @example
+ * ```typescript
+ * const compute = await incoLiteAttestedCompute({
+ *   walletClient,
+ *   chainId: sepolia,
+ * });
+ * const decryptionAttestation = await compute({
+ *   lhsHandle: '0x...',
+ *   op: AttestedComputeSupportedOps.Eq,
+ *   rhsPlaintext: 1337n,
+ * });
+ * ```
+ */
+export function incoLiteAttestedCompute({ kmsConnectRpcEndpointOrClient, chainId, walletClient, }) {
+    const kmsClient = getKmsClient(kmsConnectRpcEndpointOrClient || defaultCovalidatorGrpc(getSupportedChain(chainId)));
+    return async function attestedCompute({ lhsHandle, op, rhsPlaintext, backoffConfig, }) {
+        try {
+            validateHandle(lhsHandle);
+            const rhsPlaintextBig = BigInt(rhsPlaintext);
+            // Create the EIP712 payload for the handles to decrypt
+            const eip712Payload = createEIP712Payload({
+                chainId: BigInt(chainId),
+                primaryType: 'AttestedComputeRequest',
+                primaryTypeFields: [
+                    { name: 'op', type: 'uint8' },
+                    { name: 'lhsHandle', type: 'bytes32' },
+                    { name: 'rhsPlaintext', type: 'bytes32' },
+                ],
+                message: {
+                    op: op,
+                    lhsHandle: lhsHandle,
+                    rhsPlaintext: bigintToBytes32(rhsPlaintextBig),
+                },
+                domainName: ATTESTED_COMPUTE_DOMAIN_NAME,
+                domainVersion: ATTESTED_COMPUTE_DOMAIN_VERSION,
+            });
+            // Sign the EIP712 message
+            const eip712Signature = await walletClient.signTypedData(eip712Payload);
+            const rhsValueBytes = bigintToPlaintext(encryptionSchemes.ecies, getHandleType(lhsHandle), rhsPlaintextBig);
+            const attestedComputeRequest = {
+                $typeName: 'inco.kms.lite.v1.AttestedComputeRequest',
+                userAddress: walletClient.account.address,
+                op: op,
+                lhsHandle: lhsHandle,
+                rhsPlaintext: rhsValueBytes.value.toString(16),
+                eip712Signature: hexToBytes(eip712Signature),
+            };
+            const response = await retryWithBackoff(async () => {
+                return await kmsClient.attestedCompute(attestedComputeRequest);
+            }, backoffConfig);
+            const decryptionAttestation = response.decryptionAttestation;
+            if (decryptionAttestation?.plaintext === undefined) {
+                throw new AttestedComputeError('No plaintext in response');
+            }
+            const computeResultHandle = response.decryptionAttestation?.handle;
+            if (!computeResultHandle) {
+                throw new AttestedComputeError('No compute result handle in response');
+            }
+            const handleType = getHandleType(computeResultHandle);
+            const bigIntValue = bytesToBigInt(decryptionAttestation.plaintext);
+            return {
+                handle: computeResultHandle,
+                plaintext: bigintToPlaintext(encryptionSchemes.ecies, handleType, bigIntValue),
+                covalidatorSignature: decryptionAttestation.signature,
+            };
+        }
+        catch (error) {
+            if (error instanceof AttestedComputeError) {
+                throw error;
+            }
+            throw new AttestedComputeError('Failed to perform attested compute', error);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/attestedcompute/types.d.ts

@@ -0,0 +1,34 @@
+import type { DecryptionAttestation } from '../attesteddecrypt/types.js';
+import { HexString } from '../binary.js';
+import { EncryptionScheme, SupportedFheType } from '../encryption/encryption.js';
+import { SupportedScalarBinaryOp } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+import type { BackoffConfig } from '../retry.js';
+/**
+ * Supported attested compute operations.
+ */
+export declare const AttestedComputeSupportedOps: {
+    readonly Eq: SupportedScalarBinaryOp.FHE_EQ;
+    readonly Ne: SupportedScalarBinaryOp.FHE_NE;
+    readonly Ge: SupportedScalarBinaryOp.FHE_GE;
+    readonly Gt: SupportedScalarBinaryOp.FHE_GT;
+    readonly Le: SupportedScalarBinaryOp.FHE_LE;
+    readonly Lt: SupportedScalarBinaryOp.FHE_LT;
+};
+/**
+ * This type represents all the supported operations for attested compute.
+ */
+export type AttestedComputeOP = (typeof AttestedComputeSupportedOps)[keyof typeof AttestedComputeSupportedOps];
+/**
+ * Custom error class for attested compute operations.
+ */
+export declare class AttestedComputeError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export type AttestedCompute<S extends EncryptionScheme> = <T extends SupportedFheType>(args: {
+    /** The handle to compute on */
+    lhsHandle: HexString;
+    op: AttestedComputeOP;
+    rhsPlaintext: bigint | boolean;
+    backoffConfig?: Partial<BackoffConfig>;
+}) => Promise<DecryptionAttestation<S, T>>;