@inco/js 0.8.0-devnet-13 → 0.8.0-devnet-22

package/dist/esm/kms/quorumConsistency.js

@@ -0,0 +1,193 @@
+import { bytesToHex, parseHex } from '../binary.js';
+import { getHandleType } from '../handle.js';
+import { decrypt } 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 async function computeAttestationKey(att, reencryptKeypair) {
+    if (!att.value)
+        throw new Error('No value in attestation');
+    if (att.value.case === 'plaintext') {
+        if (!att.value.value.value)
+            throw new Error('No plaintext value in attestation');
+        return att.handle + ':' + bytesToHex(att.value.value.value);
+    }
+    if (att.value.case === 'reencryption') {
+        const ct = att.value.value.userCiphertext;
+        if (!ct)
+            throw new Error('No ciphertext in reencryption');
+        if (reencryptKeypair) {
+            return att.handle + ':' + bytesToHex(await decrypt(reencryptKeypair, ct));
+        }
+        // Without a keypair, XWing ciphertexts are non-deterministic so we
+        // can only check structural equality (handle + op-type).
+        return att.handle + ':' + String(getHandleType(parseHex(att.handle)));
+    }
+    throw new Error(`Unexpected attestation type: ${att.value.case}, expected 'plaintext' or 'reencryption'`);
+}
+/**
+ * Validates that all responses in a winning bucket have the same attestation
+ * count and types as the quorum-elected reference (bucket[0]).
+ */
+export function validateDecryptResponseStructure(bucket) {
+    const reference = bucket[0].response;
+    for (let r = 1; r < bucket.length; r++) {
+        if (bucket[r].response.decryptionAttestations.length !==
+            reference.decryptionAttestations.length) {
+            throw new Error('Inconsistent number of decryption attestations across KMS responses');
+        }
+    }
+    for (let i = 0; i < reference.decryptionAttestations.length; i++) {
+        const refAtt = reference.decryptionAttestations[i];
+        const refCase = refAtt.value?.case;
+        if (!refCase) {
+            throw new Error('No value in reference attestation');
+        }
+        for (let r = 1; r < bucket.length; r++) {
+            const att = bucket[r].response.decryptionAttestations[i];
+            if (!att.value) {
+                throw new Error('No value in attestation');
+            }
+            // Defensive check: handles should match within a bucket (bucketing includes handle in key)
+            if (att.handle !== refAtt.handle) {
+                throw new Error(`Handle mismatch at attestation index ${i}: expected '${refAtt.handle}' but got '${att.handle}'`);
+            }
+            if (att.value.case !== refCase) {
+                throw new Error(`Inconsistent attestation types: reference has '${refCase}' but response ${r} has '${att.value.case}'`);
+            }
+        }
+    }
+}
+/**
+ * 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 function validateComputeResponseStructure(bucket, request) {
+    const refAtt = bucket[0].response.decryptionAttestation;
+    if (!refAtt) {
+        throw new Error('No decryption attestation in reference response');
+    }
+    if (!refAtt.value) {
+        throw new Error('No value in reference attestation');
+    }
+    const refCase = refAtt.value.case;
+    const hasReencryptPubKey = request?.reencryptPubKey && request.reencryptPubKey.length > 0;
+    if (refCase === 'reencryption' && !hasReencryptPubKey) {
+        throw new Error("Unexpected attestation type: reencryption, expected 'plaintext'");
+    }
+    if (refCase !== 'plaintext' && refCase !== 'reencryption') {
+        throw new Error(`Unexpected attestation type: ${refCase}, expected 'plaintext' or 'reencryption'`);
+    }
+    for (let r = 1; r < bucket.length; r++) {
+        const att = bucket[r].response.decryptionAttestation;
+        if (!att)
+            throw new Error('No decryption attestation in response');
+        if (!att.value)
+            throw new Error('No value in attestation');
+        // Defensive check: handles should match within a bucket (bucketing includes handle in key)
+        if (att.handle !== refAtt.handle) {
+            throw new Error(`Handle mismatch: expected '${refAtt.handle}' but got '${att.handle}'`);
+        }
+        if (att.value.case !== refCase) {
+            throw new Error(`Inconsistent attestation types: reference has '${refCase}' but response ${r} has '${att.value.case}'`);
+        }
+    }
+}
+async function computeDecryptResponseKey(response, reencryptKeypair) {
+    const keys = await Promise.all(response.decryptionAttestations.map((att) => computeAttestationKey(att, reencryptKeypair)));
+    return keys.join('|');
+}
+async function computeComputeResponseKey(response, reencryptKeypair) {
+    const att = response.decryptionAttestation;
+    if (!att)
+        throw new Error('No decryption attestation in response');
+    return computeAttestationKey(att, reencryptKeypair);
+}
+/**
+ * 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 async function verifyDecryptResponseConsistency(allResults, threshold, reencryptKeypair) {
+    if (allResults.length === 0) {
+        throw new Error('No responses collected to verify');
+    }
+    // Compute a content key for each response and bucket by key.
+    // Responses whose key computation fails (malformed/invalid attestation) are
+    // excluded so that one faulty responder cannot abort the whole check.
+    const buckets = new Map();
+    const skippedErrors = [];
+    for (const result of allResults) {
+        let key;
+        try {
+            key = await computeDecryptResponseKey(result.response, reencryptKeypair);
+        }
+        catch (e) {
+            skippedErrors.push(e instanceof Error ? e.message : String(e));
+            continue;
+        }
+        if (!buckets.has(key))
+            buckets.set(key, []);
+        buckets.get(key).push(result);
+    }
+    // Find the first bucket that reaches the quorum threshold.
+    // With majority threshold (floor(n/2) + 1), at most one bucket can reach quorum,
+    // so iteration order doesn't affect which bucket wins.
+    for (const bucket of buckets.values()) {
+        if (bucket.length >= threshold) {
+            validateDecryptResponseStructure(bucket);
+            return { reference: bucket[0].response, winningResults: bucket };
+        }
+    }
+    const skippedSuffix = skippedErrors.length > 0
+        ? `; ${skippedErrors.length} response(s) excluded due to key-computation errors: ${skippedErrors.join(', ')}`
+        : '';
+    throw new Error(`No quorum: no group of ${threshold} KMS responses agreed on the same value${skippedSuffix}`);
+}
+/**
+ * Verifies compute response consistency using hash-bucket voting.
+ */
+export async function verifyComputeResponseConsistency(allResults, threshold, request, reencryptKeypair) {
+    if (allResults.length === 0) {
+        throw new Error('No responses collected to verify');
+    }
+    // Compute a content key for each response and bucket by key.
+    // Responses whose key computation fails (malformed/invalid attestation) are
+    // excluded so that one faulty responder cannot abort the whole check.
+    const buckets = new Map();
+    const skippedErrors = [];
+    for (const result of allResults) {
+        let key;
+        try {
+            key = await computeComputeResponseKey(result.response, reencryptKeypair);
+        }
+        catch (e) {
+            skippedErrors.push(e instanceof Error ? e.message : String(e));
+            continue;
+        }
+        if (!buckets.has(key))
+            buckets.set(key, []);
+        buckets.get(key).push(result);
+    }
+    // Find the first bucket that reaches the quorum threshold.
+    // With majority threshold (floor(n/2) + 1), at most one bucket can reach quorum,
+    // so iteration order doesn't affect which bucket wins.
+    for (const bucket of buckets.values()) {
+        if (bucket.length >= threshold) {
+            validateComputeResponseStructure(bucket, request);
+            return { reference: bucket[0].response, winningResults: bucket };
+        }
+    }
+    const skippedSuffix = skippedErrors.length > 0
+        ? `; ${skippedErrors.length} response(s) excluded due to key-computation errors: ${skippedErrors.join(', ')}`
+        : '';
+    throw new Error(`No quorum: no group of ${threshold} KMS responses agreed on the same value${skippedSuffix}`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quorumConsistency.js","sourceRoot":"","sources":["../../../src/kms/quorumConsistency.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,35 @@
+import type { Account, Address, Chain, PublicClient, Transport, WalletClient } from 'viem';
+export type ViemClient = WalletClient<Transport, Chain, Account> | PublicClient<Transport, Chain>;
+/**
+ * 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/esm/kms/signatureVerification.js

@@ -0,0 +1,84 @@
+import { getContract, pad, bytesToHex as viemBytesToHex } from 'viem';
+import { incoLightningAbi } from '../generated/abis/lightning.js';
+import { incoVerifierAbi } from '../generated/abis/verifier.js';
+/**
+ * Resolves the IncoVerifier contract instance from the executor (Lightning) contract.
+ */
+async function getVerifierContract(executorAddress, client) {
+    const lightning = getContract({
+        address: executorAddress,
+        abi: incoLightningAbi,
+        client,
+    });
+    const verifierAddress = await lightning.read.incoVerifier();
+    return getContract({
+        address: verifierAddress,
+        abi: incoVerifierAbi,
+        client,
+    });
+}
+/**
+ * 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 async function verifyPlaintextAttestationSignatures(handle, rawValueBytes, signatures, executorAddress, client) {
+    const verifier = await getVerifierContract(executorAddress, client);
+    // Left-pad value to 32 bytes (matching Go's common.LeftPadBytes(value, 32))
+    const valueHex = pad(viemBytesToHex(rawValueBytes), {
+        dir: 'left',
+        size: 32,
+    });
+    // Convert signatures to hex format for the contract call
+    const signaturesHex = signatures.map((sig) => viemBytesToHex(sig));
+    const isValid = await verifier.read.isValidDecryptionAttestation([
+        { handle: handle, value: valueHex },
+        signaturesHex,
+    ]);
+    if (!isValid) {
+        throw new Error('Covalidator signature verification failed: isValidDecryptionAttestation returned false');
+    }
+}
+/**
+ * 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 async function verifyReencryptionAttestationSignatures(handle, userCiphertexts, encryptedSignatures, envelopeSignatures, executorAddress, client) {
+    const verifier = await getVerifierContract(executorAddress, client);
+    const attestations = userCiphertexts.map((ct, i) => ({
+        handle: handle,
+        userCiphertext: viemBytesToHex(ct),
+        encryptedSignature: viemBytesToHex(encryptedSignatures[i]),
+    }));
+    const signaturesHex = envelopeSignatures.map((sig) => viemBytesToHex(sig));
+    const isValid = await verifier.read.isValidReencryptionAttestation([
+        attestations,
+        signaturesHex,
+    ]);
+    if (!isValid) {
+        throw new Error('Covalidator signature verification failed: isValidReencryptionAttestation returned false');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,7 +1,8 @@
 /**
- * Executes promises and returns results as soon as threshold is reached
+ * 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 Number of successful responses needed
- * @returns Promise that resolves with threshold number of results
+ * @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/esm/kms/thresholdPromises.js

@@ -1,8 +1,9 @@
 /**
- * Executes promises and returns results as soon as threshold is reached
+ * 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 Number of successful responses needed
- * @returns Promise that resolves with threshold number of results
+ * @param threshold Minimum number of successful responses required
+ * @returns Promise that resolves with all successful results (length >= threshold)
  */
 export async function executeWithThreshold(promises, threshold) {
     if (threshold < 0) {
@@ -19,31 +20,40 @@ export async function executeWithThreshold(promises, threshold) {
         throw new Error(`Threshold ${threshold} exceeds number of promises ${promises.length}`);
     }
     const results = [];
-    let failures = 0;
+    let settled = 0;
+    let rejected = false;
     return new Promise((resolve, reject) => {
         promises.forEach((promise) => {
             promise
                 .then((response) => {
-                if (results.length < threshold) {
-                    results.push(response);
-                    if (results.length === threshold) {
-                        resolve(results);
-                    }
+                // After early rejection (threshold became unreachable), ignore late-arriving
+                // successes since we've already rejected the overall promise.
+                if (rejected)
+                    return;
+                results.push(response);
+                settled++;
+                if (settled === promises.length) {
+                    resolve(results);
                 }
             })
                 .catch((error) => {
-                console.error(`Error executing promise: ${error}`);
-                failures++;
+                // After early rejection, ignore subsequent failures since we've already
+                // rejected the overall promise.
+                if (rejected)
+                    return;
+                settled++;
                 // Check if we can still reach the threshold
-                // We need (threshold - results.length) more successes
-                // from (promises.length - results.length - failures) remaining promises
-                const remainingPromises = promises.length - results.length - failures;
+                const remainingPromises = promises.length - settled;
                 const neededSuccesses = threshold - results.length;
                 if (remainingPromises < neededSuccesses) {
+                    rejected = true;
                     reject(new Error(`Cannot reach threshold of ${threshold} responses. Failed clients exceed limit. Last error: ${error}`));
                 }
+                else if (settled === promises.length) {
+                    resolve(results);
+                }
             });
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhyZXNob2xkUHJvbWlzZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMva21zL3RocmVzaG9sZFByb21pc2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxvQkFBb0IsQ0FDeEMsUUFBc0IsRUFDdEIsU0FBaUI7SUFFakIsSUFBSSxTQUFTLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDbEIsTUFBTSxJQUFJLEtBQUssQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFDRCwwQ0FBMEM7SUFDMUMsSUFBSSxTQUFTLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDcEIsT0FBTyxFQUFFLENBQUM7SUFDWixDQUFDO0lBQ0QsSUFBSSxRQUFRLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxTQUFTLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDM0MsTUFBTSxJQUFJLEtBQUssQ0FBQyxrREFBa0QsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7SUFDRCxJQUFJLFNBQVMsR0FBRyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDaEMsTUFBTSxJQUFJLEtBQUssQ0FDYixhQUFhLFNBQVMsK0JBQStCLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FDdkUsQ0FBQztJQUNKLENBQUM7SUFFRCxNQUFNLE9BQU8sR0FBUSxFQUFFLENBQUM7SUFDeEIsSUFBSSxRQUFRLEdBQUcsQ0FBQyxDQUFDO0lBRWpCLE9BQU8sSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7UUFDckMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFO1lBQzNCLE9BQU87aUJBQ0osSUFBSSxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUU7Z0JBQ2pCLElBQUksT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLEVBQUUsQ0FBQztvQkFDL0IsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztvQkFDdkIsSUFBSSxPQUFPLENBQUMsTUFBTSxLQUFLLFNBQVMsRUFBRSxDQUFDO3dCQUNqQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7b0JBQ25CLENBQUM7Z0JBQ0gsQ0FBQztZQUNILENBQUMsQ0FBQztpQkFDRCxLQUFLLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRTtnQkFDZixPQUFPLENBQUMsS0FBSyxDQUFDLDRCQUE0QixLQUFLLEVBQUUsQ0FBQyxDQUFDO2dCQUNuRCxRQUFRLEVBQUUsQ0FBQztnQkFDWCw0Q0FBNEM7Z0JBQzVDLHNEQUFzRDtnQkFDdEQsd0VBQXdFO2dCQUN4RSxNQUFNLGlCQUFpQixHQUFHLFFBQVEsQ0FBQyxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxRQUFRLENBQUM7Z0JBQ3RFLE1BQU0sZUFBZSxHQUFHLFNBQVMsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDO2dCQUNuRCxJQUFJLGlCQUFpQixHQUFHLGVBQWUsRUFBRSxDQUFDO29CQUN4QyxNQUFNLENBQ0osSUFBSSxLQUFLLENBQ1AsNkJBQTZCLFNBQVMsd0RBQXdELEtBQUssRUFBRSxDQUN0RyxDQUNGLENBQUM7Z0JBQ0osQ0FBQztZQUNILENBQUMsQ0FBQyxDQUFDO1FBQ1AsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,4 +1,4 @@
-import { PlaintextWithContext } from '../encryption/index.js';
+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/esm/lite/hadu.js

@@ -1,5 +1,5 @@
 import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
-import { plaintextToBytes } from '../encryption/index.js';
+import { plaintextToBytes, } from '../encryption/encryption.js';
 import { InputPayloadSchema, ScalarSchema, } from '../generated/es/inco/covalidator/compute/v1/types_pb.js';
 import { hashInputContext } from '../handle.js';
 // HADU stands for "Host Chain, ACL, DApp, and User" it maps to the InputContext type where the aclAddress
@@ -21,4 +21,4 @@ export function decodeInput(input) {
     const payload = fromBinary(InputPayloadSchema, input);
     return payload;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFkdS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saXRlL2hhZHUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEUsT0FBTyxFQUFFLGdCQUFnQixFQUF3QixNQUFNLHdCQUF3QixDQUFDO0FBQ2hGLE9BQU8sRUFFTCxrQkFBa0IsRUFDbEIsWUFBWSxHQUNiLE1BQU0seURBQXlELENBQUM7QUFDakUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRWhELDBHQUEwRztBQUMxRywwRUFBMEU7QUFFMUUsTUFBTSxVQUFVLFdBQVcsQ0FBQyxFQUMxQixTQUFTLEVBQ1QsT0FBTyxHQUNjO0lBQ3JCLE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBQyxrQkFBa0IsRUFBRTtRQUN6QyxXQUFXLEVBQUUsZ0JBQWdCLENBQUMsT0FBTyxDQUFDO1FBQ3RDLEtBQUssRUFBRTtZQUNMLElBQUksRUFBRSxRQUFRO1lBQ2QsS0FBSyxFQUFFLE1BQU0sQ0FBQyxZQUFZLEVBQUU7Z0JBQzFCLElBQUksRUFBRSxTQUFTLENBQUMsSUFBSTtnQkFDcEIsS0FBSyxFQUFFLGdCQUFnQixDQUFDLFNBQVMsQ0FBQzthQUNuQyxDQUFDO1NBQ0g7S0FDRixDQUFDLENBQUM7SUFDSCxPQUFPLFFBQVEsQ0FBQyxrQkFBa0IsRUFBRSxPQUFPLENBQUMsQ0FBQztBQUMvQyxDQUFDO0FBRUQsTUFBTSxVQUFVLFdBQVcsQ0FBQyxLQUFpQjtJQUMzQyxNQUFNLE9BQU8sR0FBRyxVQUFVLENBQUMsa0JBQWtCLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDdEQsT0FBTyxPQUFPLENBQUM7QUFDakIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFkdS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saXRlL2hhZHUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEUsT0FBTyxFQUNMLGdCQUFnQixHQUVqQixNQUFNLDZCQUE2QixDQUFDO0FBQ3JDLE9BQU8sRUFFTCxrQkFBa0IsRUFDbEIsWUFBWSxHQUNiLE1BQU0seURBQXlELENBQUM7QUFDakUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRWhELDBHQUEwRztBQUMxRywwRUFBMEU7QUFFMUUsTUFBTSxVQUFVLFdBQVcsQ0FBQyxFQUMxQixTQUFTLEVBQ1QsT0FBTyxHQUNjO0lBQ3JCLE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBQyxrQkFBa0IsRUFBRTtRQUN6QyxXQUFXLEVBQUUsZ0JBQWdCLENBQUMsT0FBTyxDQUFDO1FBQ3RDLEtBQUssRUFBRTtZQUNMLElBQUksRUFBRSxRQUFRO1lBQ2QsS0FBSyxFQUFFLE1BQU0sQ0FBQyxZQUFZLEVBQUU7Z0JBQzFCLElBQUksRUFBRSxTQUFTLENBQUMsSUFBSTtnQkFDcEIsS0FBSyxFQUFFLGdCQUFnQixDQUFDLFNBQVMsQ0FBQzthQUNuQyxDQUFDO1NBQ0g7S0FDRixDQUFDLENBQUM7SUFDSCxPQUFPLFFBQVEsQ0FBQyxrQkFBa0IsRUFBRSxPQUFPLENBQUMsQ0FBQztBQUMvQyxDQUFDO0FBRUQsTUFBTSxVQUFVLFdBQVcsQ0FBQyxLQUFpQjtJQUMzQyxNQUFNLE9BQU8sR0FBRyxVQUFVLENBQUMsa0JBQWtCLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDdEQsT0FBTyxPQUFPLENBQUM7QUFDakIsQ0FBQyJ9

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

@@ -4,6 +4,4 @@ export type { HandleWithProof } from '../generated/es/inco/kms/lite/v1/types_pb.
 export * from './attested-compute.js';
 export * from './attested-decrypt.js';
 export * from './deployments.js';
-export * from './hadu.js';
 export * from './lightning.js';
-export { TEST_NETWORK_SEED_KEY, XWING_PUBLIC_KEY_SIZE, decodeXwingPrivateKey, decodeXwingPublicKey, decrypt, deriveXwingKeypairFromSeed, encodeXwingPublicKey, encrypt, generateXwingKeypair, getXwingDecryptor, getXwingEncryptor, type XwingDecryptorArgs, type XwingEncryptorArgs, type XwingKeypair, } from './xwing.js';

package/dist/esm/lite/index.js

@@ -2,7 +2,5 @@ export * from '../generated/abis/lightning.js';
 export * from './attested-compute.js';
 export * from './attested-decrypt.js';
 export * from './deployments.js';
-export * from './hadu.js';
 export * from './lightning.js';
-export { TEST_NETWORK_SEED_KEY, XWING_PUBLIC_KEY_SIZE, decodeXwingPrivateKey, decodeXwingPublicKey, decrypt, deriveXwingKeypairFromSeed, encodeXwingPublicKey, encrypt, generateXwingKeypair, getXwingDecryptor, getXwingEncryptor, } from './xwing.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGl0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBTy9DLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsT0FBTyxFQUNMLHFCQUFxQixFQUNyQixxQkFBcUIsRUFDckIscUJBQXFCLEVBQ3JCLG9CQUFvQixFQUNwQixPQUFPLEVBQ1AsMEJBQTBCLEVBQzFCLG9CQUFvQixFQUNwQixPQUFPLEVBQ1Asb0JBQW9CLEVBQ3BCLGlCQUFpQixFQUNqQixpQkFBaUIsR0FJbEIsTUFBTSxZQUFZLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGl0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBTy9DLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZ0JBQWdCLENBQUMifQ==

package/dist/esm/lite/lightning.d.ts

@@ -4,7 +4,7 @@ import { AllowanceVoucherWithSig } from '../advancedacl/types.js';
 import { AttestedComputeOP } from '../attestedcompute/types.js';
 import { DecryptionAttestation, EncryptedDecryptionAttestation } from '../attesteddecrypt/index.js';
 import { Address, HexString } from '../binary.js';
-import { EncryptionScheme, SupportedFheType } from '../encryption/index.js';
+import { EncryptionScheme, SupportedFheType } from '../encryption/encryption.js';
 import { incoVerifierAbi } from '../generated/abis/verifier.js';
 import { lightningDeployments } from '../generated/lightning.js';
 import { localNodeLightningConfig } from '../generated/local-node.js';