@inco/lightning-js 0.0.0-bootstrap.0

package/dist/types/generated/local-node.d.ts

@@ -0,0 +1,50 @@
+export declare const localNodeLightningConfig: {
+    readonly mainnet: {
+        readonly executorAddress: "0x4b9911b0191B0b6a6eA8F2Ed562e20Cff5AC8624";
+        readonly chainId: 31337;
+        readonly covalidatorUrls: readonly ["http://localhost:50055"];
+        readonly signers: readonly ["0xDD166476574D64D54A8d65810478007eDccc1d1d"];
+        readonly hostChainRpcUrls: readonly ["http://localhost:8545"];
+        readonly senderPrivateKey: "0x7f2a092a3ecab2e11400fc235b8d3d6b76fb7ec14c71b64baf5a6885a36c1b3a";
+    };
+    readonly demonet: {
+        readonly executorAddress: "0xad9Af2e804FbF14d69391167F1FCDf918A3980fb";
+        readonly chainId: 31337;
+        readonly covalidatorUrls: readonly ["http://localhost:50055"];
+        readonly signers: readonly ["0x9cDbDc8E83F84B9D6d3c19356B8C590f0CE1F549"];
+        readonly hostChainRpcUrls: readonly ["http://localhost:8545"];
+        readonly senderPrivateKey: "0x8e6681c7870f0adc53511b6f38515a5b0f4e3a3fa62a62505f58c61e64c92497";
+    };
+    readonly testnet: {
+        readonly executorAddress: "0xe9CB49A5b16C6D4a093E5900AA8b450FD40541B6";
+        readonly chainId: 31337;
+        readonly covalidatorUrls: readonly ["http://localhost:50055"];
+        readonly signers: readonly ["0x8A853ACC000D50bfb59e1D04635959957e28Db38"];
+        readonly hostChainRpcUrls: readonly ["http://localhost:8545"];
+        readonly senderPrivateKey: "0x835c46722a63e5132eaf24d0a1dad8689d43b85bdcc0e592c23e55fa603895d7";
+    };
+    readonly devnet: {
+        readonly executorAddress: "0xB3C06f0Ed967a7E366ba31C67927DDf93d7c1154";
+        readonly chainId: 31337;
+        readonly covalidatorUrls: readonly ["http://localhost:50055"];
+        readonly signers: readonly ["0x29C5a8C17d8c0A2B2036365EA6908291A35dDadF"];
+        readonly hostChainRpcUrls: readonly ["http://localhost:8545"];
+        readonly senderPrivateKey: "0xbea2b6c911de6a581e7e5fab9da94edbb00c5ddba7ab1645c100b012997c842e";
+    };
+    readonly alphanet: {
+        readonly executorAddress: "0xc0d693DeEF0A91CE39208676b6da09B822abd199";
+        readonly chainId: 31337;
+        readonly covalidatorUrls: readonly ["http://localhost:50055"];
+        readonly signers: readonly ["0x8E873085348a3406A07907E5d1465B9824bA07cd"];
+        readonly hostChainRpcUrls: readonly ["http://localhost:8545"];
+        readonly senderPrivateKey: "0x279c172cf3638a79642daa5f7666c600befde318550d7579cf96280920e318b6";
+    };
+    readonly scratch: {
+        readonly executorAddress: "0xb390b23b8fa1761a85035E7C135bf93713d1d4d1";
+        readonly chainId: 31337;
+        readonly covalidatorUrls: readonly ["http://localhost:50055"];
+        readonly signers: readonly ["0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"];
+        readonly hostChainRpcUrls: readonly ["http://127.0.0.1:8567"];
+        readonly senderPrivateKey: "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+    };
+};

package/dist/types/handle.d.ts

@@ -0,0 +1,123 @@
+import { Schema } from 'effect';
+import { HexString } from './binary.js';
+/** Current handle version byte, appended as the last byte of every handle. */
+export declare const HANDLE_VERSION = 0;
+/**
+ * Domain separators for handle derivation. Must be kept in sync with Solidity
+ * (contracts/lightning/src/Types.sol) and Go (pkg/hostchain/handle.go). Prefixing every
+ * keccak256 preimage with a unique constant string makes cross-derivation-path
+ * collision resistance structural rather than incidental.
+ */
+export declare const SEP_INPUT_HANDLE = "inco/handle/input-handle";
+export declare const SEP_INPUT_CONTEXT = "inco/handle/input-context";
+export declare const SEP_OP_RESULT = "inco/handle/op-result";
+export declare const SEP_ELIST_OP_RESULT = "inco/handle/elist-result";
+export declare const BYTE_ELIST_ELEMENT_TYPE_INDEX = 29;
+/**
+ * Map of ENCRYPTION type names to their integer identifiers.
+ *
+ * Keys provide a semantic interpretation over the underlying integral type.
+ * For example, `ebool` interprets a `uint16` as a boolean, `ebytes64` interprets
+ * a `uint512` as a 64-byte array, etc.
+ */
+export declare const handleTypes: Readonly<{
+    ebool: 0;
+    euint4: 1;
+    euint8: 2;
+    euint16: 3;
+    euint32: 4;
+    euint64: 5;
+    euint128: 6;
+    euint160: 7;
+    euint256: 8;
+    ebytes64: 9;
+    ebytes128: 10;
+    ebytes256: 11;
+}>;
+/** Schema that validates a string is one of the known ENCRYPTION type names (e.g. `"ebool"`, `"euint256"`). */
+export declare const HandleTypeName: Schema.SchemaClass<"ebool" | "euint4" | "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "euint160" | "euint256" | "ebytes64" | "ebytes128" | "ebytes256", "ebool" | "euint4" | "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "euint160" | "euint256" | "ebytes64" | "ebytes128" | "ebytes256", never>;
+/** A valid ENCRYPTION type name string (e.g. `"ebool"`, `"euint32"`, `"ebytes64"`). */
+export type HandleTypeName = typeof HandleTypeName.Type;
+/** The typeof {@link handleTypes} — mapping from ENCRYPTION type names to integer IDs. */
+export type HandleTypes = typeof handleTypes;
+/** Integer identifier of an ENCRYPTION type (0–11), corresponding to a {@link HandleTypeName}. */
+export type TeeType = HandleTypes[keyof HandleTypes];
+/**
+ * Type guard that checks whether a number is a valid {@link TeeType} identifier.
+ * @param value - The number to check.
+ * @returns `true` if `value` is a known ENCRYPTION type integer (0–11).
+ */
+export declare function isTeeType(value: number): value is TeeType;
+/** Schema for the context required to compute a deterministic ENCRYPTION handle. */
+export declare const InputContext: Schema.Struct<{
+    hostChainId: typeof Schema.BigInt;
+    aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+    userAddress: Schema.TemplateLiteral<`0x${string}`>;
+    contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+    version: typeof Schema.Number;
+    inputType: typeof Schema.Number;
+}>;
+/** Context fields (chain ID, ACL address, user/contract addresses, version, on-chain inputType) used to derive a deterministic handle. */
+export type InputContext = typeof InputContext.Type;
+/**
+ * A 32-byte hex string representing an ENCRYPTION ciphertext handle.
+ *
+ * Format: `keccak_hash[0:29] || index_handle || handle_type || handle_version`
+ *
+ * @see pkg/hostchain/handle.md for the handle format spec.
+ */
+export type Handle = HexString;
+/**
+ * Expected length of a handle in bytes.
+ * Handle format: 29 bytes hash + 1 byte index + 1 byte type + 1 byte version = 32 bytes
+ */
+export declare const HANDLE_LENGTH_BYTES = 32;
+/**
+ * Validates handle integrity by checking format, length, and version.
+ * Matches the validation in Go's HandleFromBytes (pkg/hostchain/handle.go).
+ * @param handle - The handle to validate
+ * @throws Error if handle is malformed (wrong format, length, or unsupported version)
+ */
+export declare function validateHandle(handle: HexString): void;
+/**
+ * Extracts the {@link TeeType} from byte 30 of a validated handle.
+ * @param handle - A 32-byte hex handle string.
+ * @returns The ENCRYPTION type identifier stored in the handle.
+ * @throws If the handle is malformed or contains an invalid ENCRYPTION type.
+ * @see pkg/hostchain/handle.md for the handle format spec.
+ */
+export declare function getHandleType(handle: HexString): TeeType;
+/**
+ * Extracts the elist element {@link TeeType} from byte 29 of a validated handle.
+ * @param handle - A 32-byte hex handle string for an elist.
+ * @returns The ENCRYPTION type identifier of the elist elements.
+ * @throws If the handle is malformed or contains an invalid ENCRYPTION type at byte 29.
+ */
+export declare function getEListElementType(handle: HexString): TeeType;
+/**
+ * Computes the final handle for an input based on the ciphertext and the input context, matches the handle generation
+ * in Go and Solidity.
+ *
+ * @param ciphertext Note this is different from the input which has the external handle prepended
+ * @param indexHandle
+ * @param handleType
+ * @param handleVersion
+ * @param context
+ */
+export declare function computeHandle({ ciphertext, indexHandle, handleType, handleVersion, context, }: {
+    ciphertext: Uint8Array;
+    indexHandle: number;
+    handleType: TeeType;
+    handleVersion: number;
+    context: InputContext;
+}): Buffer;
+/**
+ * Computes the Keccak-256 hash of an ABI-packed {@link InputContext}.
+ *
+ * The context is packed as: `"evm/" || SEP_INPUT_CONTEXT || HANDLE_VERSION || inputType ||
+ *   chainId || aclAddress || userAddress || contractAddress || version`.
+ *
+ * @param context - The input context to hash.
+ * @returns A 32-byte `Buffer` containing the Keccak-256 digest.
+ */
+export declare function hashInputContext(context: InputContext): Buffer;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './binary.js';
+export * from './chain.js';
+export { HANDLE_LENGTH_BYTES, HANDLE_VERSION, HandleTypeName, InputContext, getHandleType, handleTypes, isTeeType, validateHandle, type Handle, type HandleTypes, type TeeType, } from './handle.js';
+export * from './schema.js';
+export * from './viem.js';

package/dist/types/kms/client.d.ts

@@ -0,0 +1,12 @@
+import { type Client } from '@connectrpc/connect';
+import type { Address } from 'viem';
+import type { SupportedChain } from '../chain.js';
+import { KmsService } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+export declare const TEST_DEFAULT_COVALIDATOR_SIGNER: Address;
+export type KmsClient = Client<typeof KmsService> & {
+    signerAddress: Address;
+};
+export declare function getKmsClient(kmsConnectRpcEndpointOrClient: string | KmsClient, signerAddress: Address): KmsClient;
+export declare function defaultCovalidatorGrpc(chain: SupportedChain): string;
+export declare function lightningDevnetCovalidatorGrpc(chain: SupportedChain): string;
+export declare function lightningTestnetCovalidatorGrpc(chain: SupportedChain): string;

package/dist/types/kms/quorumClient.d.ts

@@ -0,0 +1,65 @@
+import { type Address } from 'viem';
+import type { DecryptionAttestation, EncryptedDecryptionAttestation } from '../attesteddecrypt/types.js';
+import { type EListDecryptionAttestation, type EncryptedEListDecryptionAttestation } from '../elistattesteddecrypt/types.js';
+import type { EncryptionScheme, SupportedTeeType } from '../encryption/encryption.js';
+import type { AttestedComputeRequest, AttestedDecryptRequest, AttestedRevealRequest, EListAttestedDecryptRequest, EListAttestedRevealRequest } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+import { type XwingKeypair } from '../lite/xwing.js';
+import type { BackoffConfig } from '../retry.js';
+import { type KmsClient } from './client.js';
+import type { ViemClient } from '../viem.js';
+export declare class KmsQuorumClient {
+    private readonly kmss;
+    private readonly threshold;
+    private constructor();
+    private constructor();
+    /**
+     * Creates a KmsQuorumClient from an array of URLs.
+     * Requires signer addresses and threshold to be explicitly provided.
+     *
+     * @param urls - Array of KMS endpoint URLs
+     * @param signers - Array of signer addresses, must match the length of URLs
+     * @param threshold - Number of successful responses required (must be between 1 and urls.length)
+     * @throws {Error} If URLs array is empty, signers length doesn't match URLs length, or threshold is invalid
+     */
+    static fromUrls(urls: string[], signers: Address[], threshold: number): KmsQuorumClient;
+    /**
+     * Creates a KmsQuorumClient from an array of KmsClient instances.
+     * Each KmsClient must have a signerAddress property.
+     *
+     * @param kmsClients - Array of KMS client instances
+     * @param threshold - Number of successful responses required (must be between 1 and kmsClients.length)
+     * @throws {Error} If KMS clients array is empty or threshold is invalid
+     */
+    static fromKmsClients(kmsClients: KmsClient[], threshold: number): KmsQuorumClient;
+    attestedDecrypt(request: AttestedDecryptRequest, executorAddress: Address, client: ViemClient, backoffConfig?: Partial<BackoffConfig>, reencryptKeypair?: XwingKeypair): Promise<(DecryptionAttestation<EncryptionScheme, SupportedTeeType> | EncryptedDecryptionAttestation<EncryptionScheme, SupportedTeeType>)[]>;
+    attestedCompute(request: AttestedComputeRequest, executorAddress: Address, client: ViemClient, backoffConfig?: Partial<BackoffConfig>, reencryptKeypair?: XwingKeypair): Promise<DecryptionAttestation<EncryptionScheme, SupportedTeeType> | EncryptedDecryptionAttestation<EncryptionScheme, SupportedTeeType>>;
+    attestedReveal(request: AttestedRevealRequest, executorAddress: Address, client: ViemClient, backoffConfig?: Partial<BackoffConfig>): Promise<(DecryptionAttestation<EncryptionScheme, SupportedTeeType> | EncryptedDecryptionAttestation<EncryptionScheme, SupportedTeeType>)[]>;
+    eListAttestedDecrypt(request: EListAttestedDecryptRequest, executorAddress: Address, client: ViemClient, backoffConfig?: Partial<BackoffConfig>, reencryptKeypair?: XwingKeypair): Promise<EListDecryptionAttestation<EncryptionScheme, SupportedTeeType> | EncryptedEListDecryptionAttestation<EncryptionScheme, SupportedTeeType>>;
+    eListAttestedReveal(request: EListAttestedRevealRequest, executorAddress: Address, client: ViemClient, backoffConfig?: Partial<BackoffConfig>): Promise<EListDecryptionAttestation<EncryptionScheme, SupportedTeeType>>;
+    /**
+     * Generic method to execute a KMS operation across all clients with retry and threshold logic.
+     * Returns results with both the response and signer address.
+     */
+    private executeKmsOperationWithThreshold;
+    /**
+     * Collects signatures from responses and sorts them by signer address (ascending).
+     * This is required by SignatureVerifier.
+     */
+    private collectAndSortSignatures;
+    /**
+     * Builds a plaintext attestation from a DecryptionAttestation proto message.
+     */
+    private buildPlaintextAttestation;
+    private buildAggregatedAttestations;
+    private buildAggregatedComputeAttestation;
+    private buildAggregatedEListAttestation;
+    /**
+     * Verifies proof hashes at two levels:
+     * 1. Aggregate: keccak256(concat(proofHashes)) must equal the attested commitmentProof
+     * 2. Per-element:
+     *    - For plaintext (reveal): proofHash[i] = keccak256(value[i])
+     *    - For reencryption (decrypt): proofHash[i] = keccak256(commitment[i] || plaintext[i])
+     *      — requires reencryptKeypair to decrypt the ciphertext first.
+     */
+    private verifyElementProofHashes;
+}

package/dist/types/kms/quorumConsistency.d.ts

@@ -0,0 +1,82 @@
+import type { Address } from 'viem';
+import type { AttestedComputeRequest, AttestedComputeResponse, AttestedDecryptResponse, AttestedRevealResponse, EListAttestedDecryptResponse, EListAttestedRevealResponse, DecryptionAttestation as ProtoDecryptionAttestation } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+import type { XwingKeypair } from '../lite/xwing.js';
+/**
+ * Computes a canonical key for a single attestation.
+ * For plaintext/reencryption+keypair, the key is handle:hex(value).
+ * For reencryption without a keypair (XWing ciphertexts are non-deterministic),
+ * falls back to handle:op-type as a structural stand-in.
+ */
+export declare function computeAttestationKey(att: ProtoDecryptionAttestation, reencryptKeypair?: XwingKeypair): Promise<string>;
+/**
+ * Validates that all responses in a winning bucket have the same attestation
+ * count and types as the quorum-elected reference (bucket[0]).
+ */
+export declare function validateDecryptResponseStructure<T extends AttestedDecryptResponse | AttestedRevealResponse>(bucket: Array<{
+    response: T;
+    signer: Address;
+}>): void;
+/**
+ * Validates that all responses in a winning bucket have a decryption
+ * attestation with the same case as the quorum-elected reference (bucket[0]),
+ * and that the case is consistent with the request's reencryptPubKey.
+ */
+export declare function validateComputeResponseStructure(bucket: Array<{
+    response: AttestedComputeResponse;
+    signer: Address;
+}>, request?: AttestedComputeRequest): void;
+/**
+ * Verifies decrypt/reveal response consistency using hash-bucket voting.
+ * Collects all N responses, buckets them by content key, and returns the
+ * winning bucket (the first one with >= threshold votes).
+ *
+ * This is robust against a faulty first-responding node: even if responses[0]
+ * disagrees, a quorum of agreeing responses will form a winning bucket.
+ */
+export declare function verifyDecryptResponseConsistency<T extends AttestedDecryptResponse | AttestedRevealResponse>(allResults: Array<{
+    response: T;
+    signer: Address;
+}>, threshold: number, reencryptKeypair?: XwingKeypair): Promise<{
+    reference: T;
+    winningResults: Array<{
+        response: T;
+        signer: Address;
+    }>;
+}>;
+type EListResponse = EListAttestedDecryptResponse | EListAttestedRevealResponse;
+/**
+ * Validates that all elist responses in a winning bucket have the same
+ * number of values and matching indices.
+ */
+export declare function validateEListResponseStructure<T extends EListResponse>(bucket: Array<{
+    response: T;
+    signer: Address;
+}>): void;
+/**
+ * Verifies elist response consistency using hash-bucket voting.
+ * Works for both EListAttestedDecryptResponse and EListAttestedRevealResponse.
+ */
+export declare function verifyEListResponseConsistency<T extends EListResponse>(allResults: Array<{
+    response: T;
+    signer: Address;
+}>, threshold: number, reencryptKeypair?: XwingKeypair): Promise<{
+    reference: T;
+    winningResults: Array<{
+        response: T;
+        signer: Address;
+    }>;
+}>;
+/**
+ * Verifies compute response consistency using hash-bucket voting.
+ */
+export declare function verifyComputeResponseConsistency(allResults: Array<{
+    response: AttestedComputeResponse;
+    signer: Address;
+}>, threshold: number, request?: AttestedComputeRequest, reencryptKeypair?: XwingKeypair): Promise<{
+    reference: AttestedComputeResponse;
+    winningResults: Array<{
+        response: AttestedComputeResponse;
+        signer: Address;
+    }>;
+}>;
+export {};

package/dist/types/kms/signatureVerification.d.ts

@@ -0,0 +1,35 @@
+import type { Address } from 'viem';
+import { ViemClient } from '../viem.js';
+/**
+ * Verifies covalidator signatures for a plaintext DecryptionAttestation
+ * by calling `isValidDecryptionAttestation` on the IncoVerifier contract.
+ *
+ * This delegates all verification logic (EIP-712 digest computation,
+ * ECDSA recovery, signer authorization, threshold check) to the contract,
+ * ensuring exact parity with on-chain verification.
+ *
+ * @param handle - The handle hex string (bytes32)
+ * @param rawValueBytes - The raw plaintext value bytes (will be left-padded to 32 bytes)
+ * @param signatures - The covalidator ECDSA signatures to verify
+ * @param executorAddress - The Lightning contract address (executor)
+ * @param client - A viem client capable of reading contract state
+ * @throws If the contract returns false (insufficient valid signatures)
+ */
+export declare function verifyPlaintextAttestationSignatures(handle: string, rawValueBytes: Uint8Array, signatures: Uint8Array[], executorAddress: Address, client: ViemClient): Promise<void>;
+/**
+ * Verifies covalidator envelope signatures for reencryption attestations
+ * by calling `isValidReencryptionAttestation` on the IncoVerifier contract.
+ *
+ * Each covalidator signs over its own unique (userCiphertext, handle, encryptedSignature)
+ * tuple, so all three per-covalidator arrays must be aligned by index and sorted
+ * by signer address in ascending order.
+ *
+ * @param handle - The handle hex string (bytes32)
+ * @param userCiphertexts - Per-covalidator ciphertexts (sorted by signer address)
+ * @param encryptedSignatures - Per-covalidator encrypted inner signatures (sorted by signer address)
+ * @param envelopeSignatures - Per-covalidator envelope signatures (sorted by signer address)
+ * @param executorAddress - The Lightning contract address (executor)
+ * @param client - A viem client capable of reading contract state
+ * @throws If the contract returns false (insufficient valid signatures)
+ */
+export declare function verifyReencryptionAttestationSignatures(handle: string, userCiphertexts: Uint8Array[], encryptedSignatures: Uint8Array[], envelopeSignatures: Uint8Array[], executorAddress: Address, client: ViemClient): Promise<void>;

package/dist/types/kms/thresholdPromises.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Executes all promises and returns all successful results.
+ * Rejects early if it becomes mathematically impossible to reach the threshold.
+ * @param promises Array of promises to execute
+ * @param threshold Minimum number of successful responses required
+ * @returns Promise that resolves with all successful results (length >= threshold)
+ */
+export declare function executeWithThreshold<T>(promises: Promise<T>[], threshold: number): Promise<T[]>;

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

@@ -0,0 +1,6 @@
+import { ATTESTED_COMPUTE_DOMAIN_NAME, type IncoLiteAttestedComputeArgs } from '../attestedcompute/attested-compute.js';
+import type { AttestedCompute, AttestedComputeFnArgs } from '../attestedcompute/types.js';
+import { AttestedComputeSupportedOps } from '../attestedcompute/types.js';
+import type { AttestedDecryptFnArgs } from '../attesteddecrypt/types.js';
+export { ATTESTED_COMPUTE_DOMAIN_NAME, AttestedComputeSupportedOps };
+export type { AttestedCompute, AttestedComputeFnArgs, AttestedDecryptFnArgs, IncoLiteAttestedComputeArgs, };

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

@@ -0,0 +1,4 @@
+import { type IncoLiteAttestedDecryptorArgs } from '../attesteddecrypt/attested-decrypt.js';
+export type { IncoLiteAttestedDecryptorArgs };
+import { ATTESTED_DECRYPT_DOMAIN_NAME } from '../attesteddecrypt/attested-decrypt.js';
+export { ATTESTED_DECRYPT_DOMAIN_NAME };

package/dist/types/lite/deployments.d.ts

@@ -0,0 +1,24 @@
+import { Chainish } from '../chain.js';
+export type Address = `0x${string}`;
+export type IncoLiteDeployment = {
+    active: boolean;
+    blockNumber: number;
+    chainId: number;
+    chainName: string;
+    commit: string;
+    deployDate: string;
+    deployer: string;
+    executorAddress: string;
+    majorVersion: number;
+    name: string;
+    pepper: string;
+    salt: string;
+    version: {
+        major: number;
+        minor: number;
+        patch: number;
+        shortSalt: string;
+    };
+};
+export declare function getActiveLightningDeployment(chain: Chainish): IncoLiteDeployment;
+export declare function getLightningDeployments(chainId: Chainish): readonly IncoLiteDeployment[];

package/dist/types/lite/hadu.d.ts

@@ -0,0 +1,4 @@
+import { PlaintextWithContext } from '../encryption/encryption.js';
+import { InputPayload } from '../generated/es/inco/covalidator/compute/v1/types_pb.js';
+export declare function encodeInput({ plaintext, context, }: PlaintextWithContext): Uint8Array;
+export declare function decodeInput(input: Uint8Array): InputPayload;

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

@@ -0,0 +1,13 @@
+export { AttestedComputeError } from '../attestedcompute/types.js';
+export { AttestedDecryptError } from '../attesteddecrypt/types.js';
+export { AttestedRevealError } from '../attestedreveal/types.js';
+export * from '../generated/abis/lightning.js';
+export type { AttestedComputeRequest, AttestedDecryptRequest, KmsService, } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+export type { HandleWithProof } from '../generated/es/inco/kms/lite/v1/types_pb.js';
+export * from './attested-compute.js';
+export * from './attested-decrypt.js';
+export * from './deployments.js';
+export * from './lightning.js';
+export type { AttestedOpts, AttestedOptsDecrypted, AttestedOptsEncrypted, AttestedOptsEphemeral, AttestedRevealOpts, AttestedWithVoucherOpts, AttestedWithVoucherOptsDecrypted, AttestedWithVoucherOptsEncrypted, AttestedWithVoucherOptsEphemeral, } from './types.js';
+export { generateXwingKeypair } from './xwing.js';
+export type { XwingKeypair } from './xwing.js';