@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/_esm/core/coprocessor/InputProof-p.js

@@ -0,0 +1,268 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _InputProofImpl_inputProofBytesHex, _InputProofImpl_inputHandles, _InputProofImpl_coprocessorSignatures, _InputProofImpl_extraData, _InputProofImpl_signedHandleAccess;
+import { MAX_UINT8, uintToBytesHexNo0x } from '../base/uint.js';
+import { assertIsBytes, assertIsBytes65HexArray, assertIsBytesHex, bytes32ToHex, bytes65ToHex, bytesToHex, hexToBytes, unsafeBytesEquals, } from '../base/bytes.js';
+import { assertIsChecksummedAddress } from '../base/address.js';
+import { InvalidTypeError } from '../base/errors/InvalidTypeError.js';
+import { assert } from '../base/errors/InternalError.js';
+import { remove0x } from '../base/string.js';
+import { InputProofError, TooManyHandlesError } from '../errors/InputProofError.js';
+import { toInputHandle } from '../handle/FhevmHandle.js';
+////////////////////////////////////////////////////////////////////////////////
+const PRIVATE_TOKEN = Symbol('InputProof.token');
+////////////////////////////////////////////////////////////////////////////////
+// Private class InputProof
+////////////////////////////////////////////////////////////////////////////////
+class InputProofImpl {
+    constructor(privateToken, parameters) {
+        _InputProofImpl_inputProofBytesHex.set(this, void 0);
+        // Components of the proof
+        _InputProofImpl_inputHandles.set(this, void 0);
+        _InputProofImpl_coprocessorSignatures.set(this, void 0);
+        _InputProofImpl_extraData.set(this, void 0);
+        // Optional data required to verify individual coprocessor signatures
+        _InputProofImpl_signedHandleAccess.set(this, void 0);
+        if (privateToken !== PRIVATE_TOKEN) {
+            throw new Error('Unauthorized');
+        }
+        const { inputProofBytesHex, coprocessorSignatures, inputHandles, extraData, signedHandleAccess } = parameters;
+        // Note: it is not possible to create a ZKProof with zero values.
+        // consequently, the handles array cannot be empty
+        assert(inputHandles.length > 0);
+        assert(coprocessorSignatures.length > 0);
+        __classPrivateFieldSet(this, _InputProofImpl_inputProofBytesHex, inputProofBytesHex, "f");
+        __classPrivateFieldSet(this, _InputProofImpl_coprocessorSignatures, coprocessorSignatures, "f");
+        __classPrivateFieldSet(this, _InputProofImpl_inputHandles, inputHandles, "f");
+        __classPrivateFieldSet(this, _InputProofImpl_extraData, extraData, "f");
+        if (signedHandleAccess !== undefined) {
+            __classPrivateFieldSet(this, _InputProofImpl_signedHandleAccess, { ...signedHandleAccess }, "f");
+        }
+        Object.freeze(__classPrivateFieldGet(this, _InputProofImpl_coprocessorSignatures, "f"));
+        Object.freeze(__classPrivateFieldGet(this, _InputProofImpl_inputHandles, "f"));
+        Object.freeze(__classPrivateFieldGet(this, _InputProofImpl_signedHandleAccess, "f"));
+        Object.freeze(this);
+    }
+    get bytesHex() {
+        return __classPrivateFieldGet(this, _InputProofImpl_inputProofBytesHex, "f");
+    }
+    get coprocessorSignatures() {
+        return __classPrivateFieldGet(this, _InputProofImpl_coprocessorSignatures, "f");
+    }
+    get inputHandles() {
+        return __classPrivateFieldGet(this, _InputProofImpl_inputHandles, "f");
+    }
+    get extraData() {
+        return __classPrivateFieldGet(this, _InputProofImpl_extraData, "f");
+    }
+    get verified() {
+        return __classPrivateFieldGet(this, _InputProofImpl_signedHandleAccess, "f") !== undefined;
+    }
+    get signedHandleAccess() {
+        return __classPrivateFieldGet(this, _InputProofImpl_signedHandleAccess, "f");
+    }
+}
+_InputProofImpl_inputProofBytesHex = new WeakMap(), _InputProofImpl_inputHandles = new WeakMap(), _InputProofImpl_coprocessorSignatures = new WeakMap(), _InputProofImpl_extraData = new WeakMap(), _InputProofImpl_signedHandleAccess = new WeakMap();
+////////////////////////////////////////////////////////////////////////////////
+// Freeze
+////////////////////////////////////////////////////////////////////////////////
+Object.freeze(InputProofImpl);
+Object.freeze(InputProofImpl.prototype);
+////////////////////////////////////////////////////////////////////////////////
+export function createUnverifiedInputProofFromComponents(args) {
+    return createInputProofFromComponents(args);
+}
+////////////////////////////////////////////////////////////////////////////////
+export function createInputProofFromComponents({ coprocessorEip712Signatures, inputHandleBytes32HexArray, extraData, signedHandleAccess, }) {
+    return createInputProofFromInputHandles({
+        coprocessorEip712Signatures,
+        inputHandles: inputHandleBytes32HexArray.map(toInputHandle),
+        extraData,
+        signedHandleAccess,
+    });
+}
+////////////////////////////////////////////////////////////////////////////////
+export function createInputProofFromInputHandles({ coprocessorEip712Signatures, inputHandles, extraData, signedHandleAccess, }) {
+    if (inputHandles.length === 0) {
+        throw new InputProofError({
+            message: `Input proof must contain at least one external handle`,
+        });
+    }
+    if (signedHandleAccess !== undefined) {
+        assertIsChecksummedAddress(signedHandleAccess.userAddress, {});
+        assertIsChecksummedAddress(signedHandleAccess.contractAddress, {});
+    }
+    assertIsBytes65HexArray(coprocessorEip712Signatures, {});
+    assertIsBytesHex(extraData, {});
+    const numberOfHandles = inputHandles.length;
+    const numberOfSignatures = coprocessorEip712Signatures.length;
+    if (numberOfHandles > MAX_UINT8) {
+        throw new TooManyHandlesError({ numberOfHandles });
+    }
+    assert(numberOfSignatures <= MAX_UINT8);
+    const numHandlesHexByte1 = uintToBytesHexNo0x(numberOfHandles);
+    const numSignaturesHexByte1 = uintToBytesHexNo0x(numberOfHandles);
+    assert(numHandlesHexByte1.length === 2); // Byte1
+    assert(numSignaturesHexByte1.length === 2); // Byte1
+    //
+    // Proof format :
+    // ==============
+    //
+    // <len(handles)><len(signatures)><concat(handles)><concat(signatures)>
+    //
+    // size: Byte1 + Byte1 + len(handles)*Bytes32 + len(signatures)*Bytes65
+    //
+    let proof = '';
+    // Add number of handles (uint8 | Byte1)
+    proof += uintToBytesHexNo0x(inputHandles.length);
+    // Add number of signatures (uint8 | Byte1)
+    proof += uintToBytesHexNo0x(coprocessorEip712Signatures.length);
+    // Add handles: (uint256 | Byte32) x numHandles
+    inputHandles.forEach((h) => (proof += h.bytes32HexNo0x));
+    // Add signatures: (uint256 | Byte32) x numSignatures
+    coprocessorEip712Signatures.forEach((signatureBytesHex) => (proof += remove0x(signatureBytesHex)));
+    // Append the extra data to the input proof
+    proof += remove0x(extraData);
+    // Make sure we get the right size
+    assert(proof.length === (1 + 1 + numberOfHandles * 32 + numberOfSignatures * 65) * 2 + (extraData.length - 2));
+    const inputProof = new InputProofImpl(PRIVATE_TOKEN, {
+        inputProofBytesHex: `0x${proof}`,
+        coprocessorSignatures: [...coprocessorEip712Signatures],
+        inputHandles,
+        extraData,
+        signedHandleAccess: signedHandleAccess,
+    });
+    return inputProof;
+}
+////////////////////////////////////////////////////////////////////////////////
+export function createUnverifiedInputProofFromRawBytes(inputProofBytes) {
+    return createInputProofFromRawBytes({
+        inputProofBytes,
+    });
+}
+////////////////////////////////////////////////////////////////////////////////
+export function createInputProofFromRawBytes({ inputProofBytes, signedHandleAccess, }) {
+    assertIsBytes(inputProofBytes, {});
+    if (inputProofBytes.length < 2) {
+        throw new InputProofError({
+            message: `Invalid proof: too short`,
+        });
+    }
+    const numHandles = inputProofBytes[0];
+    if (numHandles === 0 || numHandles === undefined) {
+        throw new InputProofError({
+            message: `Input proof must contain at least one external handle`,
+        });
+    }
+    const numSignatures = inputProofBytes[1];
+    const HANDLE_SIZE = 32;
+    const SIGNATURE_SIZE = 65;
+    const HEADER_SIZE = 2;
+    const handlesStart = HEADER_SIZE;
+    const handlesEnd = handlesStart + numHandles * HANDLE_SIZE;
+    const signaturesStart = handlesEnd;
+    const signaturesEnd = signaturesStart + numSignatures * SIGNATURE_SIZE;
+    const extraDataStart = signaturesEnd;
+    if (inputProofBytes.length < signaturesEnd) {
+        throw new InputProofError({
+            message: `Invalid proof: expected at least ${signaturesEnd} bytes, got ${inputProofBytes.length}`,
+        });
+    }
+    // Extract handles
+    const inputHandleBytes32HexArray = [];
+    for (let i = 0; i < numHandles; i++) {
+        const start = handlesStart + i * HANDLE_SIZE;
+        const end = start + HANDLE_SIZE;
+        const handleBytes = inputProofBytes.slice(start, end);
+        const handleBytes32Hex = bytes32ToHex(handleBytes);
+        inputHandleBytes32HexArray.push(handleBytes32Hex);
+    }
+    // Extract signatures
+    const signatures = [];
+    for (let i = 0; i < numSignatures; i++) {
+        const start = signaturesStart + i * SIGNATURE_SIZE;
+        const end = start + SIGNATURE_SIZE;
+        const signatureBytes = inputProofBytes.slice(start, end);
+        const signatureBytes65Hex = bytes65ToHex(signatureBytes);
+        signatures.push(signatureBytes65Hex);
+    }
+    // Extract extra data
+    const extraDataBytes = inputProofBytes.slice(extraDataStart);
+    const extraData = bytesToHex(extraDataBytes);
+    const inputProof = createInputProofFromComponents({
+        coprocessorEip712Signatures: signatures,
+        inputHandleBytes32HexArray: inputHandleBytes32HexArray,
+        extraData,
+        signedHandleAccess: signedHandleAccess,
+    });
+    /// Debug TO BE REMOVED
+    assert(bytesToHex(inputProofBytes) === inputProof.bytesHex);
+    //////////
+    return inputProof;
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Validates that the provided handles and inputProof bytes match this InputProof.
+ * Use this as a sanity check to ensure handles correspond to the proof data.
+ */
+export function inputProofBytesEquals(bytesA, bytesB) {
+    if (bytesA.handles.length !== bytesB.handles.length) {
+        return false;
+    }
+    for (let i = 0; i < bytesA.handles.length; ++i) {
+        const a = bytesA.handles[i];
+        const b = bytesB.handles[i];
+        if (!unsafeBytesEquals(a, b)) {
+            return false;
+        }
+    }
+    return unsafeBytesEquals(bytesA.inputProof, bytesB.inputProof);
+}
+////////////////////////////////////////////////////////////////////////////////
+export function isInputProof(value) {
+    return value instanceof InputProofImpl;
+}
+////////////////////////////////////////////////////////////////////////////////
+export function assertIsInputProof(value, options) {
+    if (!isInputProof(value)) {
+        throw new InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'InputProof',
+        }, options);
+    }
+}
+////////////////////////////////////////////////////////////////////////////////
+export function isVerifiedInputProof(value) {
+    return isInputProof(value) && value.signedHandleAccess !== undefined;
+}
+////////////////////////////////////////////////////////////////////////////////
+export function assertIsVerifiedInputProof(value, options) {
+    if (!isVerifiedInputProof(value)) {
+        throw new InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'VerifiedInputProof',
+        }, options);
+    }
+}
+////////////////////////////////////////////////////////////////////////////////
+export function toInputProofBytes(inputProof) {
+    if (!(inputProof instanceof InputProofImpl)) {
+        throw new InputProofError({ message: 'Invalid inputProof object' });
+    }
+    return {
+        handles: inputProof.inputHandles.map((h) => h.bytes32),
+        inputProof: hexToBytes(inputProof.bytesHex),
+    };
+}
+//# sourceMappingURL=InputProof-p.js.map

package/_esm/core/coprocessor/InputProof-p.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputProof-p.js","sourceRoot":"","sources":["../../../core/coprocessor/InputProof-p.ts"],"names":[],"mappings":"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"}

package/_esm/core/coprocessor/ZkProof-p.js

@@ -0,0 +1,343 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ZkProofImpl_chainId, _ZkProofImpl_aclContractAddress, _ZkProofImpl_contractAddress, _ZkProofImpl_userAddress, _ZkProofImpl_ciphertextWithZkProof, _ZkProofImpl_encryptionBits, _ZkProofImpl_fheTypeIds, _ZkProofImpl_inputHandles;
+import { addressToChecksummedAddress, assertIsAddress, assertIsChecksummedAddress, checksummedAddressToBytes20, } from '../base/address.js';
+import { bytes32ToHex, bytesToHexLarge, concatBytes, hexToBytes32, toBytes } from '../base/bytes.js';
+import { assertIsUint64, assertIsUint8, asUint64BigInt, uint64ToBytes32 } from '../base/uint.js';
+import { ZkProofError } from '../errors/ZkProofError.js';
+import { assertIsEncryptionBitsArray, fheTypeIdFromEncryptionBits } from '../handle/FheType.js';
+import { buildHandle } from '../handle/FhevmHandle.js';
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import { InvalidTypeError } from '../base/errors/InvalidTypeError.js';
+////////////////////////////////////////////////////////////////////////////////
+const PRIVATE_TOKEN = Symbol('ZkProof.token');
+const GET_UNSAFE_RAW_BYTES_FUNC = Symbol('ZkProof.getUnsafeRawBytes');
+////////////////////////////////////////////////////////////////////////////////
+// ZkProof
+////////////////////////////////////////////////////////////////////////////////
+export const FHEVM_HANDLE_RAW_CT_HASH_DOMAIN_SEPARATOR = 'ZK-w_rct';
+export const FHEVM_HANDLE_HASH_DOMAIN_SEPARATOR = 'ZK-w_hdl';
+class ZkProofImpl {
+    constructor(privateToken, params) {
+        _ZkProofImpl_chainId.set(this, void 0);
+        _ZkProofImpl_aclContractAddress.set(this, void 0);
+        _ZkProofImpl_contractAddress.set(this, void 0);
+        _ZkProofImpl_userAddress.set(this, void 0);
+        _ZkProofImpl_ciphertextWithZkProof.set(this, void 0); // Never empty
+        _ZkProofImpl_encryptionBits.set(this, void 0); // Can be empty
+        _ZkProofImpl_fheTypeIds.set(this, void 0); // Can be empty
+        _ZkProofImpl_inputHandles.set(this, void 0);
+        if (privateToken !== PRIVATE_TOKEN) {
+            throw new Error('Unauthorized');
+        }
+        __classPrivateFieldSet(this, _ZkProofImpl_chainId, params.chainId, "f");
+        __classPrivateFieldSet(this, _ZkProofImpl_aclContractAddress, params.aclContractAddress, "f");
+        __classPrivateFieldSet(this, _ZkProofImpl_contractAddress, params.contractAddress, "f");
+        __classPrivateFieldSet(this, _ZkProofImpl_userAddress, params.userAddress, "f");
+        __classPrivateFieldSet(this, _ZkProofImpl_ciphertextWithZkProof, params.ciphertextWithZkProof, "f");
+        __classPrivateFieldSet(this, _ZkProofImpl_encryptionBits, Object.freeze([...params.encryptionBits]), "f");
+        __classPrivateFieldSet(this, _ZkProofImpl_fheTypeIds, Object.freeze(__classPrivateFieldGet(this, _ZkProofImpl_encryptionBits, "f").map(fheTypeIdFromEncryptionBits)), "f");
+        Object.freeze(this);
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Instance Getters
+    //////////////////////////////////////////////////////////////////////////////
+    /** The chain ID where this proof is valid. */
+    get chainId() {
+        return __classPrivateFieldGet(this, _ZkProofImpl_chainId, "f");
+    }
+    /** The ACL contract address associated with this proof. */
+    get aclContractAddress() {
+        return __classPrivateFieldGet(this, _ZkProofImpl_aclContractAddress, "f");
+    }
+    /** The target contract address associated with this proof. */
+    get contractAddress() {
+        return __classPrivateFieldGet(this, _ZkProofImpl_contractAddress, "f");
+    }
+    /** The user address associated with this proof. */
+    get userAddress() {
+        return __classPrivateFieldGet(this, _ZkProofImpl_userAddress, "f");
+    }
+    /** The ciphertext with Zk proof (guaranteed non-empty). Returns a copy. */
+    get ciphertextWithZkProof() {
+        return new Uint8Array(__classPrivateFieldGet(this, _ZkProofImpl_ciphertextWithZkProof, "f"));
+    }
+    /** The encryption bit sizes for each encrypted value in the proof. */
+    get encryptionBits() {
+        return __classPrivateFieldGet(this, _ZkProofImpl_encryptionBits, "f");
+    }
+    /** The FHE type IDs corresponding to each encrypted value. */
+    get fheTypeIds() {
+        return __classPrivateFieldGet(this, _ZkProofImpl_fheTypeIds, "f");
+    }
+    /**
+     * Returns the raw internal bytes without copying.
+     * WARNING: Do not mutate the returned array - this would violate immutability.
+     * Use `ciphertextWithZkProof` getter if you need a safe copy.
+     */
+    [(_ZkProofImpl_chainId = new WeakMap(), _ZkProofImpl_aclContractAddress = new WeakMap(), _ZkProofImpl_contractAddress = new WeakMap(), _ZkProofImpl_userAddress = new WeakMap(), _ZkProofImpl_ciphertextWithZkProof = new WeakMap(), _ZkProofImpl_encryptionBits = new WeakMap(), _ZkProofImpl_fheTypeIds = new WeakMap(), _ZkProofImpl_inputHandles = new WeakMap(), GET_UNSAFE_RAW_BYTES_FUNC)](token) {
+        if (token !== PRIVATE_TOKEN) {
+            throw new Error('Unauthorized');
+        }
+        return __classPrivateFieldGet(this, _ZkProofImpl_ciphertextWithZkProof, "f");
+    }
+    /**
+     * Returns a safe string representation for debugging.
+     * Does not expose ciphertext content - only metadata.
+     */
+    toString() {
+        return `ZkProof(chainId=${String(__classPrivateFieldGet(this, _ZkProofImpl_chainId, "f"))}, contract=${__classPrivateFieldGet(this, _ZkProofImpl_contractAddress, "f")}, user=${__classPrivateFieldGet(this, _ZkProofImpl_userAddress, "f")}, types=${__classPrivateFieldGet(this, _ZkProofImpl_fheTypeIds, "f").length}, bytes=${String(__classPrivateFieldGet(this, _ZkProofImpl_ciphertextWithZkProof, "f").length)})`;
+    }
+    getInputHandles() {
+        if (__classPrivateFieldGet(this, _ZkProofImpl_inputHandles, "f") === undefined) {
+            __classPrivateFieldSet(this, _ZkProofImpl_inputHandles, _zkProofToInputHandles({
+                ciphertextWithZkProof: __classPrivateFieldGet(this, _ZkProofImpl_ciphertextWithZkProof, "f"),
+                aclContractAddress: __classPrivateFieldGet(this, _ZkProofImpl_aclContractAddress, "f"),
+                fheTypeIds: __classPrivateFieldGet(this, _ZkProofImpl_fheTypeIds, "f"),
+                chainId: __classPrivateFieldGet(this, _ZkProofImpl_chainId, "f"),
+            }), "f");
+            Object.freeze(__classPrivateFieldGet(this, _ZkProofImpl_inputHandles, "f"));
+        }
+        return __classPrivateFieldGet(this, _ZkProofImpl_inputHandles, "f");
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // JSON
+    //////////////////////////////////////////////////////////////////////////////
+    /**
+     * Serializes the ZkProof to a JSON-compatible object.
+     * Ciphertext is hex-encoded, chainId is converted to number if safe.
+     * @returns A plain object suitable for JSON.stringify.
+     */
+    toJSON() {
+        return {
+            chainId: __classPrivateFieldGet(this, _ZkProofImpl_chainId, "f") <= Number.MAX_SAFE_INTEGER ? Number(__classPrivateFieldGet(this, _ZkProofImpl_chainId, "f")) : __classPrivateFieldGet(this, _ZkProofImpl_chainId, "f"),
+            aclContractAddress: __classPrivateFieldGet(this, _ZkProofImpl_aclContractAddress, "f"),
+            contractAddress: __classPrivateFieldGet(this, _ZkProofImpl_contractAddress, "f"),
+            userAddress: __classPrivateFieldGet(this, _ZkProofImpl_userAddress, "f"),
+            ciphertextWithZkProof: bytesToHexLarge(__classPrivateFieldGet(this, _ZkProofImpl_ciphertextWithZkProof, "f")),
+            encryptionBits: __classPrivateFieldGet(this, _ZkProofImpl_encryptionBits, "f"),
+            fheTypeIds: __classPrivateFieldGet(this, _ZkProofImpl_fheTypeIds, "f"),
+        };
+    }
+}
+////////////////////////////////////////////////////////////////////////////////
+// Freeze
+////////////////////////////////////////////////////////////////////////////////
+Object.freeze(ZkProofImpl);
+Object.freeze(ZkProofImpl.prototype);
+////////////////////////////////////////////////////////////////////////////////
+// Public API: createZkProof
+////////////////////////////////////////////////////////////////////////////////
+export function isZkProof(value) {
+    return value instanceof ZkProofImpl;
+}
+export function assertIsZkProof(value, options) {
+    if (!isZkProof(value)) {
+        throw new InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'ZkProof',
+        }, options);
+    }
+}
+/**
+ * @internal
+ * Creates a ZkProof from loose input types.
+ * Validates and normalizes all fields.
+ *
+ * If `ciphertextWithZkProof` is a hex string, it will be converted to a new Uint8Array.
+ * If it is already a Uint8Array:
+ * - By default, a defensive copy is made, allowing the caller to retain the original.
+ * - With `noCopy: true`, the instance takes ownership — callers must not mutate it afterward.
+ * @param zkProofLike - The loose input to validate and normalize (see {@link ZkProofLike}).
+ * @param options - Optional settings. Set `options.copy` to `false` to skip copying the
+ *   `ciphertextWithZkProof` Uint8Array (takes ownership). Defaults to `true` (copy by default).
+ * @throws A {@link ZkProofError} if ciphertextWithZkProof is invalid or empty.
+ * @throws A {@link InvalidTypeError} if any field fails validation.
+ */
+export async function toZkProof(zkProofLike, options) {
+    if (zkProofLike instanceof ZkProofImpl) {
+        return zkProofLike;
+    }
+    // Validate arguments
+    assertIsUint64(zkProofLike.chainId, {});
+    const chainId = BigInt(zkProofLike.chainId);
+    assertIsAddress(zkProofLike.aclContractAddress, {});
+    assertIsAddress(zkProofLike.contractAddress, {});
+    assertIsAddress(zkProofLike.userAddress, {});
+    const aclContractAddress = addressToChecksummedAddress(zkProofLike.aclContractAddress);
+    const contractAddress = addressToChecksummedAddress(zkProofLike.contractAddress);
+    const userAddress = addressToChecksummedAddress(zkProofLike.userAddress);
+    // Validate and normalize ciphertextWithZkProof
+    const ciphertextWithZkProof = toBytes(zkProofLike.ciphertextWithZkProof, {
+        subject: 'ciphertextWithZkProof',
+        copy: options?.copy !== false,
+    });
+    if (ciphertextWithZkProof.length === 0) {
+        throw new ZkProofError({
+            message: 'ciphertextWithZkProof argument should not be empty',
+        });
+    }
+    // Validation of packed variable count and total bits is handled by
+    // parseTFHEProvenCompactCiphertextList, which deserializes and validates
+    // the ciphertext structure via the TFHE WASM module.
+    const encryptionBits = await _getOrParseEncryptionBits(zkProofLike.encryptionBits, ciphertextWithZkProof, options?.zkProofParser);
+    return new ZkProofImpl(PRIVATE_TOKEN, {
+        chainId,
+        aclContractAddress,
+        contractAddress,
+        userAddress,
+        ciphertextWithZkProof: ciphertextWithZkProof,
+        encryptionBits,
+    });
+}
+////////////////////////////////////////////////////////////////////////////////
+// Public API: zkProofToFhevmHandles
+////////////////////////////////////////////////////////////////////////////////
+export async function zkProofToExternalEncryptedValues(zkProofLike, options) {
+    if (zkProofLike instanceof ZkProofImpl) {
+        return zkProofLike.getInputHandles();
+    }
+    assertIsChecksummedAddress(zkProofLike.aclContractAddress, {
+        subject: 'aclContractAddress',
+    });
+    const encryptionBits = await _getOrParseEncryptionBits(zkProofLike.encryptionBits, zkProofLike.ciphertextWithZkProof, options?.zkProofParser);
+    const ciphertextWithZkProof = toBytes(zkProofLike.ciphertextWithZkProof, {
+        subject: 'ciphertextWithZkProof',
+    });
+    const fheTypeIds = encryptionBits.map((w) => fheTypeIdFromEncryptionBits(w));
+    assertIsUint8(fheTypeIds.length, {});
+    return _zkProofToInputHandles({
+        ciphertextWithZkProof: ciphertextWithZkProof,
+        aclContractAddress: zkProofLike.aclContractAddress,
+        fheTypeIds,
+        chainId: asUint64BigInt(zkProofLike.chainId, { subject: 'chainId' }),
+    });
+}
+////////////////////////////////////////////////////////////////////////////////
+// Private Helpers
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Asserts that two encryption bits arrays are equal (same length and values).
+ * @param actual - The actual encryption bits array.
+ * @param expected - The expected encryption bits array.
+ * @throws ZkProofError if there's a count or type mismatch.
+ */
+function _assertEncryptionBitsMatch(actual, expected) {
+    if (actual.length !== expected.length) {
+        throw new ZkProofError({
+            message: `Encryption count mismatch, expected ${expected.length}, got ${actual.length}.`,
+        });
+    }
+    for (let i = 0; i < actual.length; ++i) {
+        if (actual[i] !== expected[i]) {
+            throw new ZkProofError({
+                message: `Encryption type mismatch at index ${i}.`,
+            });
+        }
+    }
+}
+////////////////////////////////////////////////////////////////////////////////
+function _zkProofToInputHandles(args, options) {
+    const encoder = new TextEncoder();
+    const domainSepBytes = encoder.encode(FHEVM_HANDLE_RAW_CT_HASH_DOMAIN_SEPARATOR);
+    const blobHashBytes32Hex = bytes32ToHex(keccak_256(concatBytes(domainSepBytes, args.ciphertextWithZkProof)));
+    const inputHandles = [];
+    for (const [i, fheTypeId] of args.fheTypeIds.entries()) {
+        const hash21 = _computeInputHash21(hexToBytes32(blobHashBytes32Hex), args.aclContractAddress, args.chainId, i);
+        inputHandles.push(buildHandle({
+            hash21,
+            chainId: args.chainId,
+            fheTypeId,
+            ...(options?.version !== undefined ? { version: options.version } : {}),
+            index: i,
+        }));
+    }
+    return inputHandles; // not readonly
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Returns the encryption bits from a ZkProofLike.
+ * If `encryptionBits` is provided, validates and returns it.
+ * Otherwise, parses the ciphertext to extract the encryption bits.
+ */
+async function _getOrParseEncryptionBits(encryptionBits, ciphertextWithZkProof, zkProofParser) {
+    // Case 1: encryptionBits provided — validate, and verify against parsed if possible
+    if (encryptionBits != null) {
+        assertIsEncryptionBitsArray(encryptionBits, {
+            subject: 'encryptionBits',
+        });
+        if (zkProofParser != null) {
+            const parsed = await zkProofParser.parseTFHEProvenCompactCiphertextList({
+                ciphertextWithZkProof: ciphertextWithZkProof,
+            });
+            _assertEncryptionBitsMatch(parsed.encryptionBits, encryptionBits);
+        }
+        return encryptionBits;
+    }
+    // Case 2: encryptionBits not provided — extract if parse function available
+    if (zkProofParser != null) {
+        const parsed = await zkProofParser.parseTFHEProvenCompactCiphertextList({
+            ciphertextWithZkProof: ciphertextWithZkProof,
+        });
+        return parsed.encryptionBits;
+    }
+    // Case 3: no encryptionBits and no way to extract them
+    throw new ZkProofError({ message: 'Missing encryption bits' });
+}
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Computes the 21-byte handle hash for an encrypted input.
+ *
+ * handle_hash = "ZK-w_hdl" (8 bytes) + blobHash (32 bytes) + index (1 byte) + aclAddress (20 bytes) + chainId (32 bytes)
+ *
+ * Reference implementation (Rust):
+ * ```rust
+ * const HANDLE_HASH_DOMAIN_SEPARATOR: [u8; 8] = *b"ZK-w_hdl";
+ *
+ * let mut handle_hash = Keccak256::new();
+ * handle_hash.update(HANDLE_HASH_DOMAIN_SEPARATOR);
+ * handle_hash.update(blob_hash);
+ * handle_hash.update([ct_idx as u8]);
+ * handle_hash.update(
+ *     Address::from_str(&aux_data.acl_contract_address)
+ *         .expect("valid acl_contract_address")
+ *         .into_array(),
+ * );
+ * handle_hash.update(chain_id_bytes);
+ * let mut handle = handle_hash.finalize().to_vec();
+ * assert_eq!(handle.len(), 32);
+ * ```
+ *
+ * @see https://github.com/zama-ai/fhevm/blob/8ffbd5906ab3d57af178e049930e3fc065c9d4b3/coprocessor/fhevm-engine/zkproof-worker/src/verifier.rs#L431
+ * @internal
+ */
+function _computeInputHash21(blobHashBytes32, aclAddress, chainId, index) {
+    const encryptionIndexByte1 = new Uint8Array([index]);
+    const aclContractAddressBytes20 = checksummedAddressToBytes20(aclAddress);
+    const chainIdBytes32 = uint64ToBytes32(chainId);
+    const encoder = new TextEncoder();
+    const domainSepBytes = encoder.encode(FHEVM_HANDLE_HASH_DOMAIN_SEPARATOR);
+    const hashBytes32Hex = bytes32ToHex(keccak_256(concatBytes(domainSepBytes, blobHashBytes32, encryptionIndexByte1, aclContractAddressBytes20, chainIdBytes32)));
+    // Truncate to 21 bytes (0x + 42 hex chars)
+    return hashBytes32Hex.slice(0, 2 + 2 * 21);
+}
+/**
+ * @internal
+ */
+export function zkProofGetUnsafeRawBytes(zkProof) {
+    if (!(zkProof instanceof ZkProofImpl)) {
+        throw new Error('Unauthorized');
+    }
+    return zkProof[GET_UNSAFE_RAW_BYTES_FUNC](PRIVATE_TOKEN);
+}
+//# sourceMappingURL=ZkProof-p.js.map