@inco/lightning-js 0.0.0-bootstrap.0

package/dist/cjs/viem.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chains = void 0;
+exports.getViemChain = getViemChain;
+const chains_1 = require("viem/chains");
+const chain_js_1 = require("./chain.js");
+/** Map of supported chain short names to their viem chain objects. */
+exports.chains = {
+    mainnet: chains_1.mainnet,
+    base: chains_1.base,
+    sepolia: chains_1.sepolia,
+    baseSepolia: chains_1.baseSepolia,
+    monadTestnet: chains_1.monadTestnet,
+    plasmaTestnet: chains_1.plasmaTestnet,
+    anvil: chains_1.anvil,
+    worldchainSepolia: chains_1.worldchainSepolia,
+};
+/**
+ * Resolves a {@link Chainish} value to a viem {@link Chain} object.
+ *
+ * Accepts a chain ID (`number` or `bigint`), an object with an `id` field,
+ * or a chain short name (e.g. `"baseSepolia"`).
+ *
+ * @param chainish - The chain identifier to resolve.
+ * @returns The matching `viem` chain object.
+ * @throws If no supported chain matches the given identifier.
+ */
+function getViemChain(chainish) {
+    const { name } = (0, chain_js_1.getSupportedChain)(chainish);
+    const chain = exports.chains[name];
+    if (!chain) {
+        throw new Error(`Unable to get viem chain: ${name}`);
+    }
+    return chain;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmllbS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92aWVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQXVDQSxvQ0FPQztBQTdDRCx3Q0FTcUI7QUFDckIseUNBQXlEO0FBTXpELHNFQUFzRTtBQUN6RCxRQUFBLE1BQU0sR0FBRztJQUNwQixPQUFPLEVBQVAsZ0JBQU87SUFDUCxJQUFJLEVBQUosYUFBSTtJQUNKLE9BQU8sRUFBUCxnQkFBTztJQUNQLFdBQVcsRUFBWCxvQkFBVztJQUNYLFlBQVksRUFBWixxQkFBWTtJQUNaLGFBQWEsRUFBYixzQkFBYTtJQUNiLEtBQUssRUFBTCxjQUFLO0lBQ0wsaUJBQWlCLEVBQWpCLDBCQUFpQjtDQUNsQixDQUFDO0FBRUY7Ozs7Ozs7OztHQVNHO0FBQ0gsU0FBZ0IsWUFBWSxDQUFDLFFBQWtCO0lBQzdDLE1BQU0sRUFBRSxJQUFJLEVBQUUsR0FBRyxJQUFBLDRCQUFpQixFQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQzdDLE1BQU0sS0FBSyxHQUFHLGNBQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUMzQixJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDWCxNQUFNLElBQUksS0FBSyxDQUFDLDZCQUE2QixJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMifQ==

package/dist/esm/advancedacl/index.d.ts

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

package/dist/esm/advancedacl/index.js

@@ -0,0 +1,3 @@
+export * from './session-key.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWR2YW5jZWRhY2wvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLFlBQVksQ0FBQyJ9

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

@@ -0,0 +1,95 @@
+import { type Account, type Address, type Chain, type Hex, PublicClient, type Transport, type WalletClient } from 'viem';
+import type { PrivateKeyAccount } from 'viem/accounts';
+import { DecryptionAttestation, EncryptedDecryptionAttestation } from '../attesteddecrypt/index.js';
+import { SupportedChainId } from '../chain.js';
+import { EncryptionScheme, SupportedTeeType } from '../encryption/encryption.js';
+import { HexString } from '../index.js';
+import { type XwingKeypair } from '../lite/xwing.js';
+import { BackoffConfig } from '../retry.js';
+import type { AllowanceVoucher, AllowanceVoucherWithSig } from './types.js';
+import { AttestedComputeOP } from '../attestedcompute/types.js';
+import { KmsQuorumClient } from '../kms/quorumClient.js';
+export declare const SESSION_KEY_WARNING = "Inco Warning: signing this message may leak your private data, including from unrelated apps. Sign only if you fully trust this app.";
+export interface Session {
+    decrypter: Address;
+    expiresAt: bigint;
+}
+export declare function createAllowanceVoucher(incoLiteAddress: Address, sharerWalletClient: WalletClient<Transport, Chain, Account>, verifyingContract: Address, callFunction: Hex, sharerArgData: Hex): Promise<AllowanceVoucher>;
+export interface GrantSessionKeyArgs {
+    chainId: bigint;
+    incoLiteAddress: Address;
+    sessionVerifierContractAddress: Address;
+    granteeAddress: Address;
+    sharerWalletClient: WalletClient<Transport, Chain, Account>;
+    expiresAt: Date;
+}
+export interface GrantSessionKeyCustomVerifierArgs {
+    chainId: bigint;
+    incoLiteAddress: Address;
+    sessionVerifierContractAddress: Address;
+    sharerWalletClient: WalletClient<Transport, Chain, Account>;
+    sharerArgData: Hex;
+}
+export declare function grantSessionKey({ chainId, incoLiteAddress, sessionVerifierContractAddress, granteeAddress, sharerWalletClient, expiresAt, }: GrantSessionKeyArgs): Promise<AllowanceVoucherWithSig>;
+export declare function grantSessionKeyCustomVerifier({ chainId, incoLiteAddress, sessionVerifierContractAddress, sharerWalletClient, sharerArgData, }: GrantSessionKeyCustomVerifierArgs): Promise<AllowanceVoucherWithSig>;
+export declare function updateActiveVouchersSessionNonce(incoLiteAddress: Address, sharerWalletClient: WalletClient<Transport, Chain, Account>): Promise<`0x${string}`>;
+export interface SessionKeyAttestedComputeArgs {
+    chainId: SupportedChainId;
+    ephemeralAccount: PrivateKeyAccount;
+    kmsQuorumClient: KmsQuorumClient;
+    allowanceVoucherWithSig: AllowanceVoucherWithSig;
+    lhsHandle: HexString;
+    op: AttestedComputeOP;
+    rhsPlaintext: bigint | boolean;
+    requesterArgData?: Hex | undefined;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    ethClient: PublicClient<Transport, Chain>;
+    executorAddress: HexString;
+    reencryptPubKey?: Uint8Array | undefined;
+    reencryptKeypair?: XwingKeypair | undefined;
+}
+export declare function sessionKeyAttestedCompute<T extends SupportedTeeType>({ lhsHandle, op, rhsPlaintext, backoffConfig, chainId, kmsQuorumClient, ephemeralAccount, allowanceVoucherWithSig, requesterArgData, ethClient, executorAddress, reencryptPubKey, reencryptKeypair, }: SessionKeyAttestedComputeArgs): Promise<DecryptionAttestation<EncryptionScheme, SupportedTeeType> | EncryptedDecryptionAttestation<EncryptionScheme, SupportedTeeType>>;
+export interface SessionKeyAttestedDecryptArgs {
+    chainId: SupportedChainId;
+    ephemeralAccount: PrivateKeyAccount;
+    kmsQuorumClient: KmsQuorumClient;
+    allowanceVoucherWithSig: AllowanceVoucherWithSig;
+    handles: HexString[];
+    requesterArgData?: Hex | undefined;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    reencryptPubKey?: Uint8Array | undefined;
+    reencryptKeypair?: XwingKeypair | undefined;
+    ethClient: PublicClient<Transport, Chain>;
+    executorAddress: HexString;
+}
+/**
+ * Performs attested decrypts using a voucher-backed session key.
+ *
+ * @example Plaintext results
+ * ```ts
+ * const attestations = await sessionKeyAttestedDecrypt({
+ *   chainId,
+ *   kmsConnectRpcEndpointOrClient: covalidatorUrl,
+ *   allowanceVoucherWithSig: voucher,
+ *   ephemeralAccount,
+ *   handles,
+ * });
+ * console.log(attestations[0].plaintext.value);
+ * ```
+ *
+ * @example Encrypted results
+ * ```ts
+ * const encryptedResults = await sessionKeyAttestedDecrypt({
+ *   chainId,
+ *   kmsConnectRpcEndpointOrClient: covalidatorUrl,
+ *   allowanceVoucherWithSig: voucher,
+ *   ephemeralAccount,
+ *   handles,
+ *   reencryptPubKey: recipientPubKey,
+ * });
+ * console.log(
+ *   encryptedResults[0].encryptedPlaintext.ciphertext.value,
+ * );
+ * ```
+ */
+export declare function sessionKeyAttestedDecrypt({ chainId, kmsQuorumClient, handles, ephemeralAccount, allowanceVoucherWithSig, requesterArgData, backoffConfig, reencryptPubKey, reencryptKeypair, ethClient, executorAddress, }: SessionKeyAttestedDecryptArgs): Promise<Array<DecryptionAttestation<EncryptionScheme, SupportedTeeType> | EncryptedDecryptionAttestation<EncryptionScheme, SupportedTeeType>>>;

package/dist/esm/advancedacl/session-key.js

@@ -0,0 +1,367 @@
+import { create } from '@bufbuild/protobuf';
+import { bytesToHex, encodeAbiParameters, getContract, hexToBytes, toFunctionSelector, } from 'viem';
+import { abiHelperAbi, advancedAccessControlAbi, incoLightningAbi, sessionVerifierAbi, } from '../generated/abis/lightning.js';
+import { incoVerifierAbi } from '../generated/abis/verifier.js';
+import { bigintToBytes32 } from '../index.js';
+import { ATTESTED_COMPUTE_DOMAIN_NAME, ATTESTED_DECRYPT_DOMAIN_NAME, } from '../lite/index.js';
+import { reencryptPublicKeysMatch } from '../lite/xwing.js';
+import { createEIP712Payload } from '../reencryption/index.js';
+import { AttestedComputeError, } from '../attestedcompute/types.js';
+import { decryptEncryptedAttestations } from '../attesteddecrypt/attested-decrypt.js';
+import { AttestedDecryptError } from '../attesteddecrypt/types.js';
+import { fetchEip712DomainVersion } from '../eip712/eip712.js';
+import { AttestedComputeRequestSchema, AttestedDecryptRequestSchema, } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+import { AllowanceProofSchema, AllowanceVoucherSchema, HandleWithProofSchema, IncoLiteAdvancedACLProofSchema, } from '../generated/es/inco/kms/lite/v1/types_pb.js';
+// SessionKey is a special case of the SessionVerifier allowance, where the
+// requester is an ephemeral keypair generated by the user, to use the same
+// keypair for multiple reencryptions, expired after a certain time.
+// Default warning message included in session vouchers. Displayed by wallets
+// at signing time so users understand what they are granting access to.
+export const SESSION_KEY_WARNING = 'Inco Warning: signing this message may leak your private data, including from unrelated apps. Sign only if you fully trust this app.';
+// Given a sharer's wallet client, an incoLite contract address, and a
+// (verifyingContract, callFunction, sharerArgData) tuple, this function
+// creates an AllowanceVoucher. The warning is always SESSION_KEY_WARNING.
+export async function createAllowanceVoucher(incoLiteAddress, sharerWalletClient, verifyingContract, callFunction, sharerArgData) {
+    const verifier = await getIncoVerifier(incoLiteAddress, sharerWalletClient);
+    // The session nonce in the AllowanceVoucher must match the current active
+    // session nonce of the sharer on-chain.
+    const sessionNonce = await verifier.read.getActiveVouchersSessionNonce([
+        sharerWalletClient.account.address,
+    ]);
+    return {
+        sessionNonce,
+        verifyingContract,
+        callFunction,
+        sharerArgData,
+        warning: SESSION_KEY_WARNING,
+    };
+}
+// Let the sharer grant a session key to the requester.
+// The session grants temporary access to ALL of the sharer's encrypted handles.
+export async function grantSessionKey({ chainId, incoLiteAddress, sessionVerifierContractAddress, granteeAddress, sharerWalletClient, expiresAt, }) {
+    // Validate that expiresAt is a valid Date object
+    if (!(expiresAt instanceof Date) || isNaN(expiresAt.getTime())) {
+        throw new Error('expiresAt must be a valid Date object');
+    }
+    const nowMs = Date.now();
+    const expiresAtMs = expiresAt.getTime();
+    // Validate that expiresAt is in the future
+    if (expiresAtMs < nowMs) {
+        throw new Error('expiresAt must be in the future');
+    }
+    const sharerArgData = encodeAbiParameters(getSessionAbi(), [
+        granteeAddress,
+        BigInt(Math.floor(expiresAtMs / 1000)),
+    ]);
+    const incoVerifier = await getIncoVerifier(incoLiteAddress, sharerWalletClient);
+    // returned by read.eip712Domain():
+    // bytes1 fields,
+    // string memory name,
+    // string memory version,
+    // uint256 chainId,
+    // address verifyingContract,
+    // bytes32 salt,
+    // uint256[] memory extensions
+    const verifierDomain = await incoVerifier.read.eip712Domain();
+    const eip712DomainName = verifierDomain[1];
+    const eip712DomainVersion = verifierDomain[2];
+    const voucher = await createAllowanceVoucher(incoLiteAddress, sharerWalletClient, 
+    // Careful that the verifying contract here is the SessionVerifier contract,
+    // not the incoLite contract.
+    sessionVerifierContractAddress, toFunctionSelector(getCanUseSessionAbi()), sharerArgData);
+    const eip712Payload = createEIP712Payload({
+        chainId,
+        primaryType: 'AllowanceVoucher',
+        primaryTypeFields: getAllowanceVoucherAbi(),
+        message: voucher,
+        // Related to comment above: careful that the verifying contract here is
+        // the incoVerifier contract (not the SessionVerifier contract).
+        verifyingContract: incoVerifier.address,
+        domainName: eip712DomainName,
+        domainVersion: eip712DomainVersion,
+    });
+    // Using browser extensions, this step will prompt the user to sign the
+    // payload.
+    const voucherSignature = await sharerWalletClient.signTypedData(eip712Payload);
+    return {
+        sharer: sharerWalletClient.account.address,
+        voucher,
+        voucherSignature,
+    };
+}
+export async function grantSessionKeyCustomVerifier({ chainId, incoLiteAddress, sessionVerifierContractAddress, sharerWalletClient, sharerArgData, }) {
+    const incoVerifier = await getIncoVerifier(incoLiteAddress, sharerWalletClient);
+    // returned by read.eip712Domain():
+    // bytes1 fields,
+    // string memory name,
+    // string memory version,
+    // uint256 chainId,
+    // address verifyingContract,
+    // bytes32 salt,
+    // uint256[] memory extensions
+    const verifierDomain = await incoVerifier.read.eip712Domain();
+    const eip712DomainName = verifierDomain[1];
+    const eip712DomainVersion = verifierDomain[2];
+    const voucher = await createAllowanceVoucher(incoLiteAddress, sharerWalletClient, 
+    // Careful that the verifying contract here is the SessionVerifier contract,
+    // not the incoLite contract.
+    sessionVerifierContractAddress, toFunctionSelector(getCanUseSessionAbi()), sharerArgData);
+    const eip712Payload = createEIP712Payload({
+        chainId,
+        primaryType: 'AllowanceVoucher',
+        primaryTypeFields: getAllowanceVoucherAbi(),
+        message: voucher,
+        // Related to comment above: careful that the verifying contract here is
+        // the incoVerifier contract (not the SessionVerifier contract).
+        verifyingContract: incoVerifier.address,
+        domainName: eip712DomainName,
+        domainVersion: eip712DomainVersion,
+    });
+    // Using browser extensions, this step will prompt the user to sign the
+    // payload.
+    const voucherSignature = await sharerWalletClient.signTypedData(eip712Payload);
+    return {
+        sharer: sharerWalletClient.account.address,
+        voucher,
+        voucherSignature,
+    };
+}
+export async function updateActiveVouchersSessionNonce(incoLiteAddress, sharerWalletClient) {
+    const verifier = await getIncoVerifier(incoLiteAddress, sharerWalletClient);
+    const salt = bytesToHex(crypto.getRandomValues(new Uint8Array(32)));
+    const txHash = await verifier.write.updateActiveVouchersSessionNonce([salt]);
+    return txHash;
+}
+// The sessionKeyAttestedCompute function is a decryptor that uses a session key
+// to compute on a handle.
+export async function sessionKeyAttestedCompute({ lhsHandle, op, rhsPlaintext, backoffConfig, chainId, kmsQuorumClient, ephemeralAccount, allowanceVoucherWithSig, requesterArgData, ethClient, executorAddress, reencryptPubKey, reencryptKeypair, }) {
+    const requesterAccount = ephemeralAccount;
+    const rhsPlaintextBig = BigInt(rhsPlaintext);
+    if (reencryptPubKey &&
+        reencryptKeypair &&
+        !reencryptPublicKeysMatch(reencryptPubKey, reencryptKeypair)) {
+        throw new AttestedComputeError('reencryptPubKey does not match reencryptKeypair public key');
+    }
+    const eip712DomainVersion = await fetchEip712DomainVersion(executorAddress, ethClient);
+    // Sign the EIP712 attesting that the requester has access to the private key
+    // corresponding to the ephemeral public key.
+    const eip712Payload = createEIP712Payload({
+        chainId: BigInt(chainId),
+        primaryType: 'AttestedComputeRequest',
+        primaryTypeFields: [
+            { name: 'op', type: 'uint8' },
+            { name: 'lhsHandle', type: 'bytes32' },
+            { name: 'rhsPlaintext', type: 'bytes32' },
+            { name: 'publicKey', type: 'bytes' },
+        ],
+        message: {
+            op: op,
+            lhsHandle: lhsHandle,
+            rhsPlaintext: bigintToBytes32(rhsPlaintextBig),
+            publicKey: bytesToHex(reencryptPubKey ? reencryptPubKey : new Uint8Array()),
+        },
+        domainName: ATTESTED_COMPUTE_DOMAIN_NAME,
+        domainVersion: eip712DomainVersion,
+    });
+    // Since the account is an ephemeral keypair stored in memory (not in Metamask),
+    // this step will NOT prompt the user with a pop-up.
+    const eip712Signature = await requesterAccount.signTypedData(eip712Payload);
+    const attestedComputeRequest = create(AttestedComputeRequestSchema, {
+        userAddress: requesterAccount.address,
+        reencryptPubKey: reencryptPubKey ? reencryptPubKey : new Uint8Array(),
+        op: op,
+        lhsHandle: lhsHandle,
+        rhsPlaintext: rhsPlaintextBig.toString(16),
+        eip712Signature: hexToBytes(eip712Signature),
+        aclProof: {
+            proof: {
+                case: 'incoLiteAdvancedAclProof',
+                value: create(IncoLiteAdvancedACLProofSchema, {
+                    allowanceProof: create(AllowanceProofSchema, {
+                        sharer: allowanceVoucherWithSig.sharer,
+                        voucher: create(AllowanceVoucherSchema, {
+                            sessionNonce: hexToBytes(allowanceVoucherWithSig.voucher.sessionNonce),
+                            verifyingContract: allowanceVoucherWithSig.voucher.verifyingContract,
+                            callFunction: hexToBytes(allowanceVoucherWithSig.voucher.callFunction),
+                            sharerArgData: hexToBytes(allowanceVoucherWithSig.voucher.sharerArgData),
+                            warning: allowanceVoucherWithSig.voucher.warning,
+                        }),
+                        voucherSignature: hexToBytes(allowanceVoucherWithSig.voucherSignature),
+                        // For DefaultSessionVerifier, the requesterArgData is empty.
+                        requesterArgData: requesterArgData
+                            ? hexToBytes(requesterArgData)
+                            : new Uint8Array(),
+                    }),
+                }),
+            },
+        },
+    });
+    let response = await kmsQuorumClient.attestedCompute(attestedComputeRequest, executorAddress, ethClient, backoffConfig, reencryptKeypair);
+    // If reencryptPubKey is provided with a keypair, decrypt the encrypted attestation
+    if (reencryptPubKey && reencryptKeypair) {
+        const [decryptedAttestation] = await decryptEncryptedAttestations([response], reencryptKeypair);
+        return decryptedAttestation;
+    }
+    return response;
+}
+/**
+ * Performs attested decrypts using a voucher-backed session key.
+ *
+ * @example Plaintext results
+ * ```ts
+ * const attestations = await sessionKeyAttestedDecrypt({
+ *   chainId,
+ *   kmsConnectRpcEndpointOrClient: covalidatorUrl,
+ *   allowanceVoucherWithSig: voucher,
+ *   ephemeralAccount,
+ *   handles,
+ * });
+ * console.log(attestations[0].plaintext.value);
+ * ```
+ *
+ * @example Encrypted results
+ * ```ts
+ * const encryptedResults = await sessionKeyAttestedDecrypt({
+ *   chainId,
+ *   kmsConnectRpcEndpointOrClient: covalidatorUrl,
+ *   allowanceVoucherWithSig: voucher,
+ *   ephemeralAccount,
+ *   handles,
+ *   reencryptPubKey: recipientPubKey,
+ * });
+ * console.log(
+ *   encryptedResults[0].encryptedPlaintext.ciphertext.value,
+ * );
+ * ```
+ */
+export async function sessionKeyAttestedDecrypt({ chainId, kmsQuorumClient, handles, ephemeralAccount, allowanceVoucherWithSig, requesterArgData, backoffConfig, reencryptPubKey, reencryptKeypair, ethClient, executorAddress, }) {
+    const requesterAccount = ephemeralAccount;
+    if (reencryptPubKey &&
+        reencryptKeypair &&
+        !reencryptPublicKeysMatch(reencryptPubKey, reencryptKeypair)) {
+        throw new AttestedDecryptError('reencryptPubKey does not match reencryptKeypair public key');
+    }
+    const eip712DomainVersion = await fetchEip712DomainVersion(executorAddress, ethClient);
+    // Sign the EIP712 attesting that the requester has access to the private key
+    // corresponding to the ephemeral public key.
+    const eip712Payload = createEIP712Payload({
+        chainId: BigInt(chainId),
+        primaryType: 'AttestedDecryptRequest',
+        primaryTypeFields: [
+            { name: 'handles', type: 'bytes32[]' },
+            { name: 'publicKey', type: 'bytes' },
+        ],
+        message: {
+            handles: handles,
+            publicKey: bytesToHex(reencryptPubKey ? reencryptPubKey : Uint8Array.from([])),
+        },
+        domainName: ATTESTED_DECRYPT_DOMAIN_NAME,
+        domainVersion: eip712DomainVersion,
+    });
+    // Since the account is an ephemeral keypair stored in memory (not in Metamask),
+    // this step will NOT prompt the user with a pop-up.
+    const eip712Signature = await requesterAccount.signTypedData(eip712Payload);
+    const handlesWithProofs = handles.map((handle) => {
+        return create(HandleWithProofSchema, {
+            handle: handle,
+            aclProof: {
+                proof: {
+                    case: 'incoLiteAdvancedAclProof',
+                    value: create(IncoLiteAdvancedACLProofSchema, {
+                        allowanceProof: create(AllowanceProofSchema, {
+                            sharer: allowanceVoucherWithSig.sharer,
+                            voucher: create(AllowanceVoucherSchema, {
+                                sessionNonce: hexToBytes(allowanceVoucherWithSig.voucher.sessionNonce),
+                                verifyingContract: allowanceVoucherWithSig.voucher.verifyingContract,
+                                callFunction: hexToBytes(allowanceVoucherWithSig.voucher.callFunction),
+                                sharerArgData: hexToBytes(allowanceVoucherWithSig.voucher.sharerArgData),
+                                warning: allowanceVoucherWithSig.voucher.warning,
+                            }),
+                            voucherSignature: hexToBytes(allowanceVoucherWithSig.voucherSignature),
+                            // For DefaultSessionVerifier, the requesterArgData is empty.
+                            requesterArgData: requesterArgData
+                                ? hexToBytes(requesterArgData)
+                                : new Uint8Array(),
+                        }),
+                    }),
+                },
+            },
+        });
+    });
+    const attestedDecryptRequest = create(AttestedDecryptRequestSchema, {
+        userAddress: requesterAccount.address,
+        handlesWithProofs: handlesWithProofs,
+        eip712Signature: hexToBytes(eip712Signature),
+        reencryptPubKey: reencryptPubKey ? reencryptPubKey : Uint8Array.from([]),
+    });
+    let response = await kmsQuorumClient.attestedDecrypt(attestedDecryptRequest, executorAddress, ethClient, backoffConfig, reencryptKeypair);
+    // If reencryptPubKey is provided with a keypair, decrypt the encrypted attestations
+    if (reencryptPubKey !== undefined && reencryptKeypair) {
+        response = await decryptEncryptedAttestations(response, reencryptKeypair);
+    }
+    return response;
+}
+// Below are helpers to get ABIs of functions/structs from the SessionVerifier
+// contract.
+// Get the ABI of the `AllowanceVoucher` struct.
+function getAllowanceVoucherAbi() {
+    // Find the `allowanceVoucherDigest` function, it takes an AllowanceVoucher
+    // as sole argument.
+    const allowanceVoucherDigest = advancedAccessControlAbi.find((item) => item.name === 'allowanceVoucherDigest');
+    if (!allowanceVoucherDigest) {
+        throw new Error('allowanceVoucherDigest not found');
+    }
+    // Get the input whose internalType is "struct AllowanceVoucher"
+    const allowanceVoucherInput = allowanceVoucherDigest.inputs.find((input) => input.internalType === 'struct AllowanceVoucher');
+    if (!allowanceVoucherInput) {
+        throw new Error('allowanceVoucherInput not found');
+    }
+    return allowanceVoucherInput.components;
+}
+// Get the ABI of the `Session` struct.
+//
+// We specifically created an ABIHelper.sol contract to export the Session
+// struct from the SessionVerifier contract.
+function getSessionAbi() {
+    const getSession = abiHelperAbi.find((item) => 'name' in item && item.name === 'getSession');
+    if (!getSession) {
+        throw new Error('getSession not found');
+    }
+    const session = getSession.outputs[0];
+    if (!session) {
+        throw new Error('session not found');
+    }
+    return session.components;
+}
+// Get the ABI of the `canUseSession` function.
+function getCanUseSessionAbi() {
+    const canUseSession = sessionVerifierAbi.find((item) => 'name' in item && item.name === 'canUseSession');
+    if (!canUseSession) {
+        throw new Error('canUseSession not found');
+    }
+    return canUseSession;
+}
+function getAdvancedAcl(incoVerifierAddress, sharerWalletClient) {
+    return getContract({
+        address: incoVerifierAddress,
+        abi: advancedAccessControlAbi,
+        client: sharerWalletClient,
+    });
+}
+function getIncoLightning(incoLiteAddress, walletClient) {
+    return getContract({
+        address: incoLiteAddress,
+        abi: incoLightningAbi,
+        client: walletClient,
+    });
+}
+async function getIncoVerifier(incoLiteAddress, walletClient) {
+    const incoLite = getIncoLightning(incoLiteAddress, walletClient);
+    const incoVerifierAddress = await incoLite.read.incoVerifier();
+    return getContract({
+        address: incoVerifierAddress,
+        abi: incoVerifierAbi,
+        client: walletClient,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session-key.js","sourceRoot":"","sources":["../../../src/advancedacl/session-key.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,16 @@
+import { Address, Hex } from 'viem';
+export type AllowanceVoucher = {
+    sessionNonce: Hex;
+    verifyingContract: Address;
+    callFunction: Hex;
+    sharerArgData: Hex;
+    warning: string;
+};
+export interface AllowanceVoucherWithSig {
+    sharer: Address;
+    voucher: AllowanceVoucher;
+    voucherSignature: Hex;
+}
+export interface AllowanceProof extends AllowanceVoucherWithSig {
+    requesterArgData: Uint8Array;
+}

package/dist/esm/advancedacl/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWR2YW5jZWRhY2wvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -0,0 +1,65 @@
+import type { Account, Chain, Transport, WalletClient } from 'viem';
+import { DecryptionAttestation, EncryptedDecryptionAttestation } from '../attesteddecrypt/types.js';
+import { HexString } from '../binary.js';
+import { SupportedChainId } from '../chain.js';
+import type { EncryptionScheme, SupportedTeeType } from '../encryption/encryption.js';
+import { KmsQuorumClient } from '../kms/quorumClient.js';
+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";
+/**
+ * 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 quorum client instance */
+    kmsQuorumClient: KmsQuorumClient;
+    /** 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.
+ */
+export declare function attestedCompute<T extends SupportedTeeType>({ executorAddress, lhsHandle, op, rhsPlaintext, backoffConfig, walletClient, kmsQuorumClient, chainId, reencryptPubKey, reencryptKeypair, }: {
+    executorAddress: HexString;
+    lhsHandle: HexString;
+    op: AttestedComputeOP;
+    rhsPlaintext: bigint | boolean;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    kmsQuorumClient: KmsQuorumClient;
+    chainId: SupportedChainId;
+    reencryptPubKey: Uint8Array;
+    reencryptKeypair: XwingKeypair;
+}): Promise<DecryptionAttestation<EncryptionScheme, T>>;
+export declare function attestedCompute<T extends SupportedTeeType>({ executorAddress, lhsHandle, op, rhsPlaintext, backoffConfig, walletClient, kmsQuorumClient, chainId, reencryptPubKey, }: {
+    executorAddress: HexString;
+    lhsHandle: HexString;
+    op: AttestedComputeOP;
+    rhsPlaintext: bigint | boolean;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    kmsQuorumClient: KmsQuorumClient;
+    chainId: SupportedChainId;
+    reencryptPubKey: Uint8Array;
+    reencryptKeypair?: never;
+}): Promise<EncryptedDecryptionAttestation<EncryptionScheme, T>>;
+export declare function attestedCompute<T extends SupportedTeeType>({ executorAddress, lhsHandle, op, rhsPlaintext, backoffConfig, walletClient, kmsQuorumClient, chainId, }: {
+    executorAddress: HexString;
+    lhsHandle: HexString;
+    op: AttestedComputeOP;
+    rhsPlaintext: bigint | boolean;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    kmsQuorumClient: KmsQuorumClient;
+    chainId: SupportedChainId;
+    reencryptPubKey?: never;
+    reencryptKeypair?: never;
+}): Promise<DecryptionAttestation<EncryptionScheme, T>>;