@inco/lightning-js 0.0.0-bootstrap.0

package/dist/cjs/encryption/encryption.d.ts

@@ -0,0 +1,235 @@
+import { Schema } from 'effect';
+import { ByteArray, Hex } from 'viem';
+import { Bytes32 } from '../binary.js';
+/**
+ * A function that encrypts a plaintext value, embedding its {@link InputContext} into the resulting ciphertext.
+ *
+ * @typeParam S - The encryption scheme (e.g. X-Wing).
+ * @example
+ * ```ts
+ * const result = await encrypt({ plaintext: { scheme: 2, type: 5, value: 42n }, context });
+ * // result.handle, result.ciphertext
+ * ```
+ */
+export type Encryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedTeeType>(plaintext: PlaintextWithContextOf<S, T>) => Promise<EncryptResultOf<S, T>>;
+/**
+ * A function that decrypts a ciphertext back to its plaintext value.
+ *
+ * @typeParam S - The encryption scheme (e.g. X-Wing).
+ * @example
+ * ```ts
+ * const plaintext = await decrypt({ scheme: 2, type: 5, value: '0x...' });
+ * ```
+ */
+export type Decryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedTeeType>(ciphertext: CiphertextOf<S, T>) => Promise<PlaintextOf<S, T>>;
+/**
+ * Subset of ENCRYPTION types currently supported for encryption/decryption.
+ *
+ * @remarks TODO: review need of `euint64` and `euint160` — `Lib.sol` only supports `euint256` and `ebool`.
+ */
+export declare const supportedTeeTypes: {
+    readonly euint64: 5;
+    readonly euint160: 7;
+    readonly euint256: 8;
+    readonly ebool: 0;
+};
+/** Schema that validates a string is one of the supported ENCRYPTION type names. */
+export declare const SupportedTeeTypeName: Schema.SchemaClass<"ebool" | "euint64" | "euint160" | "euint256", "ebool" | "euint64" | "euint160" | "euint256", never>;
+/** A supported ENCRYPTION type name (e.g. `"euint256"`, `"ebool"`). */
+export type SupportedTeeTypeName = typeof SupportedTeeTypeName.Type;
+/** Schema that validates a number is one of the supported ENCRYPTION type integer identifiers. */
+export declare const SupportedTeeType: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+/** Integer identifier of a supported ENCRYPTION type (a subset of all ENCRYPTION types). */
+export type SupportedTeeType = typeof SupportedTeeType.Type;
+/** Map of encryption scheme names to their integer identifiers. Currently only X-Wing (2) is supported. */
+export declare const encryptionSchemes: {
+    readonly xwing: 2;
+};
+/**
+ * Returns the human-readable name of an encryption scheme.
+ * @param scheme - The encryption scheme integer identifier.
+ * @returns The scheme name (e.g. `"X-Wing"`).
+ * @throws If the scheme identifier is unknown.
+ */
+export declare function getEncryptionSchemeName(scheme: number): string;
+/** The typeof {@link encryptionSchemes} — mapping from scheme names to integer IDs. */
+export type EncryptionSchemes = typeof encryptionSchemes;
+/** The integer identifier for the X-Wing encryption scheme (`2`). */
+export type XwingScheme = EncryptionSchemes['xwing'];
+/** Schema that validates a value is a known encryption scheme identifier. */
+export declare const EncryptionScheme: Schema.Literal<[2]>;
+/** An encryption scheme identifier (currently only X-Wing = `2`). */
+export type EncryptionScheme = typeof EncryptionScheme.Type;
+type DistType<P, S extends EncryptionScheme, T extends SupportedTeeType> = P extends any ? P & {
+    scheme: S;
+    type: T;
+} : never;
+/** Schema for an ENCRYPTION ciphertext: encryption scheme, ENCRYPTION type, and the encrypted value as a hex string. */
+export declare const Ciphertext: Schema.Struct<{
+    scheme: Schema.Literal<[2]>;
+    type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+    value: Schema.TemplateLiteral<`0x${string}`>;
+}>;
+/** An ENCRYPTION ciphertext containing the encryption scheme, ENCRYPTION type, and encrypted hex value. */
+export type Ciphertext = typeof Ciphertext.Type;
+export type CiphertextOf<S extends EncryptionScheme, T extends SupportedTeeType> = DistType<Ciphertext, S, T>;
+/** Schema for a ciphertext paired with the {@link InputContext} it was encrypted under. */
+export declare const CiphertextWithContext: Schema.Struct<{
+    ciphertext: Schema.Struct<{
+        scheme: Schema.Literal<[2]>;
+        type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+        value: Schema.TemplateLiteral<`0x${string}`>;
+    }>;
+    context: 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;
+    }>;
+}>;
+/** A ciphertext paired with the {@link InputContext} it was encrypted under. */
+export type CiphertextWithContext = typeof CiphertextWithContext.Type;
+export type CiphertextWithContextOf<S extends EncryptionScheme, T extends SupportedTeeType> = CiphertextWithContext & {
+    ciphertext: CiphertextOf<S, T>;
+};
+/** Schema for the result of an encryption operation: ciphertext, input context, and final handle. */
+export declare const EncryptResult: Schema.Struct<{
+    ciphertext: Schema.Struct<{
+        scheme: Schema.Literal<[2]>;
+        type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+        value: Schema.TemplateLiteral<`0x${string}`>;
+    }>;
+    context: 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;
+    }>;
+    handle: Schema.brand<Schema.filter<Schema.transformOrFail<Schema.Union<[typeof Schema.String, Schema.refine<object & Uint8Array<ArrayBufferLike>, Schema.Schema<object, object, never>>]>, Schema.TemplateLiteral<`0x${string}`>, never>>, "Bytes32">;
+}>;
+/** The result of an encryption operation, containing the ciphertext, context, and deterministic handle. */
+export type EncryptResult = typeof EncryptResult.Type;
+export type EncryptResultOf<S extends EncryptionScheme, T extends SupportedTeeType> = EncryptResult & {
+    ciphertext: CiphertextOf<S, T>;
+};
+/**
+ * Schema for an ENCRYPTION plaintext value. The `value` field type depends on the ENCRYPTION type:
+ * - `euint64` / `euint160` / `euint256`: `bigint`
+ * - `ebool`: `boolean`
+ */
+export declare const Plaintext: Schema.Union<[Schema.Struct<{
+    scheme: Schema.Literal<[2]>;
+    type: Schema.Literal<[5, 7, 8]>;
+    value: typeof Schema.BigInt;
+}>, Schema.Struct<{
+    scheme: Schema.Literal<[2]>;
+    type: Schema.Literal<[0]>;
+    value: typeof Schema.Boolean;
+}>]>;
+/** An ENCRYPTION plaintext value — `bigint` for integer types, `boolean` for `ebool`. */
+export type Plaintext = typeof Plaintext.Type;
+export type PlaintextOf<S extends EncryptionScheme, T extends SupportedTeeType> = DistType<Plaintext, S, T>;
+/** Schema for a plaintext paired with the {@link InputContext} it will be encrypted under. */
+export declare const PlaintextWithContext: Schema.Struct<{
+    plaintext: Schema.Union<[Schema.Struct<{
+        scheme: Schema.Literal<[2]>;
+        type: Schema.Literal<[5, 7, 8]>;
+        value: typeof Schema.BigInt;
+    }>, Schema.Struct<{
+        scheme: Schema.Literal<[2]>;
+        type: Schema.Literal<[0]>;
+        value: typeof Schema.Boolean;
+    }>]>;
+    context: 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;
+    }>;
+}>;
+/** A plaintext paired with the {@link InputContext} it will be encrypted under. */
+export type PlaintextWithContext = typeof PlaintextWithContext.Type;
+export type PlaintextWithContextOf<S extends EncryptionScheme, T extends SupportedTeeType> = PlaintextWithContext & {
+    plaintext: PlaintextOf<S, T>;
+};
+/**
+ * Converts a `bigint` to a typed {@link Plaintext} value.
+ *
+ * For integer ENCRYPTION types (`euint64`, `euint160`, `euint256`) the value is passed through as-is.
+ * For `ebool`, non-zero values become `true`.
+ *
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the value as.
+ * @param bigPt - The raw bigint plaintext value.
+ * @returns A typed `Plaintext` matching the given scheme and ENCRYPTION type.
+ * @throws If `type` is not a supported ENCRYPTION type.
+ */
+export declare function bigintToPlaintext<S extends EncryptionScheme, T extends SupportedTeeType>(scheme: S, type: T, bigPt: bigint): PlaintextOf<S, T>;
+/**
+ * Decodes an ABI-encoded ciphertext input into its components.
+ *
+ * The input format is: `4-byte version || abi.encode(bytes32 handle, bytes ciphertext)`.
+ *
+ * @param input - The raw encoded input as a byte array or hex string.
+ * @returns The decoded version, handle, and ciphertext.
+ */
+export declare function decodeCiphertextInput(input: ByteArray | Hex): {
+    version: number;
+    handle: Hex;
+    ciphertext: Hex;
+};
+/**
+ * Encodes a handle and ciphertext into the on-chain input format.
+ *
+ * The output format is: `4-byte version || abi.encode(bytes32 handle, bytes ciphertext)`.
+ *
+ * @param version - The encoding version (int32).
+ * @param handle - The 32-byte handle as a hex string.
+ * @param ciphertext - The ciphertext as a hex string.
+ * @returns The ABI-encoded input as a hex string.
+ */
+export declare function encodeCiphertextInput(version: number, handle: Hex, ciphertext: Hex): Hex;
+/**
+ * Converts a {@link Plaintext} to its `bigint` representation.
+ *
+ * Integer types pass through directly; `ebool` maps `true` → `1n`, `false` → `0n`.
+ *
+ * @param plaintext - The plaintext to convert.
+ * @returns The bigint representation of the plaintext value.
+ */
+export declare function plaintextToBigint(plaintext: Plaintext): bigint;
+/**
+ * Converts a {@link Plaintext} to a {@link Bytes32} hex string.
+ * @param plaintext - The plaintext to convert.
+ * @returns A 32-byte hex representation of the plaintext value.
+ */
+export declare function plaintextToBytes32(plaintext: Plaintext): Bytes32;
+/**
+ * Converts a {@link Plaintext} to a 32-byte `Buffer`.
+ * @param plaintext - The plaintext to convert.
+ * @returns A 32-byte big-endian buffer of the plaintext value.
+ */
+export declare function plaintextToBytes(plaintext: Plaintext): Buffer;
+/**
+ * Parses a {@link Bytes32} hex string into a typed {@link Plaintext}.
+ * @param plaintext - The 32-byte hex value to interpret.
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the bytes as.
+ * @returns A typed `Plaintext` value.
+ */
+export declare function bytes32ToPlaintext(plaintext: Bytes32, scheme: EncryptionScheme, type: SupportedTeeType): Plaintext;
+/**
+ * Parses a `Uint8Array` into a typed {@link Plaintext}.
+ * @param plaintext - The byte array to interpret.
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the bytes as.
+ * @returns A typed `Plaintext` value.
+ */
+export declare function bytesToPlaintext(plaintext: Uint8Array, scheme: EncryptionScheme, type: SupportedTeeType): Plaintext;
+export {};

package/dist/cjs/encryption/encryption.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaintextWithContext = exports.Plaintext = exports.EncryptResult = exports.CiphertextWithContext = exports.Ciphertext = exports.EncryptionScheme = exports.encryptionSchemes = exports.SupportedTeeType = exports.SupportedTeeTypeName = exports.supportedTeeTypes = void 0;
+exports.getEncryptionSchemeName = getEncryptionSchemeName;
+exports.bigintToPlaintext = bigintToPlaintext;
+exports.decodeCiphertextInput = decodeCiphertextInput;
+exports.encodeCiphertextInput = encodeCiphertextInput;
+exports.plaintextToBigint = plaintextToBigint;
+exports.plaintextToBytes32 = plaintextToBytes32;
+exports.plaintextToBytes = plaintextToBytes;
+exports.bytes32ToPlaintext = bytes32ToPlaintext;
+exports.bytesToPlaintext = bytesToPlaintext;
+const effect_1 = require("effect");
+const viem_1 = require("viem");
+const binary_js_1 = require("../binary.js");
+const handle_js_1 = require("../handle.js");
+/**
+ * Subset of ENCRYPTION types currently supported for encryption/decryption.
+ *
+ * @remarks TODO: review need of `euint64` and `euint160` — `Lib.sol` only supports `euint256` and `ebool`.
+ */
+exports.supportedTeeTypes = {
+    euint64: handle_js_1.handleTypes.euint64,
+    euint160: handle_js_1.handleTypes.euint160,
+    euint256: handle_js_1.handleTypes.euint256,
+    ebool: handle_js_1.handleTypes.ebool,
+};
+const supportedTeeTypeNames = Object.keys(exports.supportedTeeTypes);
+/** Schema that validates a string is one of the supported ENCRYPTION type names. */
+exports.SupportedTeeTypeName = effect_1.Schema.Literal(...supportedTeeTypeNames);
+/** Schema that validates a number is one of the supported ENCRYPTION type integer identifiers. */
+// TODO: extend to all types
+exports.SupportedTeeType = effect_1.Schema.Literal(...Object.values(exports.supportedTeeTypes));
+/** Map of encryption scheme names to their integer identifiers. Currently only X-Wing (2) is supported. */
+exports.encryptionSchemes = {
+    xwing: 2,
+};
+/**
+ * Returns the human-readable name of an encryption scheme.
+ * @param scheme - The encryption scheme integer identifier.
+ * @returns The scheme name (e.g. `"X-Wing"`).
+ * @throws If the scheme identifier is unknown.
+ */
+function getEncryptionSchemeName(scheme) {
+    switch (scheme) {
+        case exports.encryptionSchemes.xwing:
+            return 'X-Wing';
+        default:
+            throw new Error(`Unknown encryption scheme: ${scheme}`);
+    }
+}
+/** Schema that validates a value is a known encryption scheme identifier. */
+exports.EncryptionScheme = effect_1.Schema.Literal(exports.encryptionSchemes.xwing);
+/** Schema for an ENCRYPTION ciphertext: encryption scheme, ENCRYPTION type, and the encrypted value as a hex string. */
+exports.Ciphertext = effect_1.Schema.Struct({
+    scheme: exports.EncryptionScheme,
+    type: exports.SupportedTeeType,
+    value: binary_js_1.HexString,
+});
+/** Schema for a ciphertext paired with the {@link InputContext} it was encrypted under. */
+exports.CiphertextWithContext = effect_1.Schema.Struct({
+    ciphertext: exports.Ciphertext,
+    context: handle_js_1.InputContext,
+});
+/** Schema for the result of an encryption operation: ciphertext, input context, and final handle. */
+exports.EncryptResult = effect_1.Schema.Struct({
+    ciphertext: exports.Ciphertext,
+    context: handle_js_1.InputContext,
+    handle: binary_js_1.Bytes32,
+});
+/**
+ * Schema for an ENCRYPTION plaintext value. The `value` field type depends on the ENCRYPTION type:
+ * - `euint64` / `euint160` / `euint256`: `bigint`
+ * - `ebool`: `boolean`
+ */
+exports.Plaintext = effect_1.Schema.Union(effect_1.Schema.Struct({
+    scheme: exports.EncryptionScheme,
+    type: effect_1.Schema.Literal(handle_js_1.handleTypes.euint64, handle_js_1.handleTypes.euint160, handle_js_1.handleTypes.euint256),
+    value: effect_1.Schema.BigInt,
+}), effect_1.Schema.Struct({
+    scheme: exports.EncryptionScheme,
+    type: effect_1.Schema.Literal(handle_js_1.handleTypes.ebool),
+    value: effect_1.Schema.Boolean,
+}));
+/** Schema for a plaintext paired with the {@link InputContext} it will be encrypted under. */
+exports.PlaintextWithContext = effect_1.Schema.Struct({
+    plaintext: exports.Plaintext,
+    context: handle_js_1.InputContext,
+});
+/**
+ * Converts a `bigint` to a typed {@link Plaintext} value.
+ *
+ * For integer ENCRYPTION types (`euint64`, `euint160`, `euint256`) the value is passed through as-is.
+ * For `ebool`, non-zero values become `true`.
+ *
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the value as.
+ * @param bigPt - The raw bigint plaintext value.
+ * @returns A typed `Plaintext` matching the given scheme and ENCRYPTION type.
+ * @throws If `type` is not a supported ENCRYPTION type.
+ */
+function bigintToPlaintext(scheme, type, bigPt) {
+    switch (type) {
+        case handle_js_1.handleTypes.euint64:
+        case handle_js_1.handleTypes.euint160:
+        case handle_js_1.handleTypes.euint256:
+            return {
+                scheme,
+                type,
+                value: bigPt,
+            };
+        case handle_js_1.handleTypes.ebool:
+            return {
+                scheme,
+                type,
+                value: bigPt !== 0n,
+            };
+        default:
+            console.warn(`bigintToPlaintext: Unsupported Encryption Scheme type ${type}`);
+    }
+    throw new Error(`Unsupported Encryption Scheme type: ${type}`);
+}
+/**
+ * ABI parameter schema for on-chain ciphertext input encoding.
+ *
+ * Compatible with Solidity's `abi.decode(input, (bytes32, bytes))`:
+ * ```solidity
+ * (bytes32 externalHandle, bytes memory ciphertext) = abi.decode(input, (bytes32, bytes));
+ * ```
+ *
+ * This is the source of truth for the encoding format and does not refer to
+ * an actual contract or Solidity type's ABI.
+ */
+const ciphertextInputAbi = [
+    { name: 'handle', type: 'bytes32' },
+    { name: 'ciphertext', type: 'bytes' },
+];
+/**
+ * Decodes an ABI-encoded ciphertext input into its components.
+ *
+ * The input format is: `4-byte version || abi.encode(bytes32 handle, bytes ciphertext)`.
+ *
+ * @param input - The raw encoded input as a byte array or hex string.
+ * @returns The decoded version, handle, and ciphertext.
+ */
+function decodeCiphertextInput(input) {
+    const bytes = typeof input === 'string' ? (0, viem_1.hexToBytes)(input) : input;
+    const buf = new Uint8Array(bytes).buffer;
+    const version = new DataView(buf).getInt32(0);
+    const [handle, ciphertext] = (0, viem_1.decodeAbiParameters)(ciphertextInputAbi, bytes.slice(4));
+    return { version, handle, ciphertext };
+}
+/**
+ * Encodes a handle and ciphertext into the on-chain input format.
+ *
+ * The output format is: `4-byte version || abi.encode(bytes32 handle, bytes ciphertext)`.
+ *
+ * @param version - The encoding version (int32).
+ * @param handle - The 32-byte handle as a hex string.
+ * @param ciphertext - The ciphertext as a hex string.
+ * @returns The ABI-encoded input as a hex string.
+ */
+function encodeCiphertextInput(version, handle, ciphertext) {
+    const rest = (0, viem_1.hexToBytes)((0, viem_1.encodeAbiParameters)(ciphertextInputAbi, [handle, ciphertext]));
+    const buf = new ArrayBuffer(rest.length + 4);
+    const dv = new DataView(buf);
+    dv.setInt32(0, version);
+    const view = new Uint8Array(buf);
+    view.set(rest, 4);
+    return (0, viem_1.bytesToHex)(view);
+}
+/**
+ * Converts a {@link Plaintext} to its `bigint` representation.
+ *
+ * Integer types pass through directly; `ebool` maps `true` → `1n`, `false` → `0n`.
+ *
+ * @param plaintext - The plaintext to convert.
+ * @returns The bigint representation of the plaintext value.
+ */
+function plaintextToBigint(plaintext) {
+    switch (plaintext.type) {
+        case handle_js_1.handleTypes.euint64:
+        case handle_js_1.handleTypes.euint160:
+        case handle_js_1.handleTypes.euint256:
+            return plaintext.value;
+        case handle_js_1.handleTypes.ebool:
+            return plaintext.value ? 1n : 0n;
+    }
+}
+/**
+ * Converts a {@link Plaintext} to a {@link Bytes32} hex string.
+ * @param plaintext - The plaintext to convert.
+ * @returns A 32-byte hex representation of the plaintext value.
+ */
+function plaintextToBytes32(plaintext) {
+    return (0, binary_js_1.bigintToBytes32)(plaintextToBigint(plaintext));
+}
+/**
+ * Converts a {@link Plaintext} to a 32-byte `Buffer`.
+ * @param plaintext - The plaintext to convert.
+ * @returns A 32-byte big-endian buffer of the plaintext value.
+ */
+function plaintextToBytes(plaintext) {
+    return (0, binary_js_1.bigintToBytes)(plaintextToBigint(plaintext));
+}
+/**
+ * Parses a {@link Bytes32} hex string into a typed {@link Plaintext}.
+ * @param plaintext - The 32-byte hex value to interpret.
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the bytes as.
+ * @returns A typed `Plaintext` value.
+ */
+function bytes32ToPlaintext(plaintext, scheme, type) {
+    return bigintToPlaintext(scheme, type, BigInt(plaintext));
+}
+/**
+ * Parses a `Uint8Array` into a typed {@link Plaintext}.
+ * @param plaintext - The byte array to interpret.
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the bytes as.
+ * @returns A typed `Plaintext` value.
+ */
+function bytesToPlaintext(plaintext, scheme, type) {
+    return bigintToPlaintext(scheme, type, BigInt((0, binary_js_1.bytesToBigInt)(plaintext)));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/encryption/index.d.ts

@@ -0,0 +1 @@
+export { Ciphertext, EncryptionScheme, Plaintext, SupportedTeeType, SupportedTeeTypeName, bigintToPlaintext, bytes32ToPlaintext, bytesToPlaintext, encryptionSchemes, getEncryptionSchemeName, plaintextToBigint, plaintextToBytes, plaintextToBytes32, supportedTeeTypes, type EncryptionSchemes, } from './encryption.js';

package/dist/cjs/encryption/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedTeeTypes = exports.plaintextToBytes32 = exports.plaintextToBytes = exports.plaintextToBigint = exports.getEncryptionSchemeName = exports.encryptionSchemes = exports.bytesToPlaintext = exports.bytes32ToPlaintext = exports.bigintToPlaintext = exports.SupportedTeeTypeName = exports.SupportedTeeType = exports.Plaintext = exports.EncryptionScheme = exports.Ciphertext = void 0;
+var encryption_js_1 = require("./encryption.js");
+Object.defineProperty(exports, "Ciphertext", { enumerable: true, get: function () { return encryption_js_1.Ciphertext; } });
+Object.defineProperty(exports, "EncryptionScheme", { enumerable: true, get: function () { return encryption_js_1.EncryptionScheme; } });
+Object.defineProperty(exports, "Plaintext", { enumerable: true, get: function () { return encryption_js_1.Plaintext; } });
+Object.defineProperty(exports, "SupportedTeeType", { enumerable: true, get: function () { return encryption_js_1.SupportedTeeType; } });
+Object.defineProperty(exports, "SupportedTeeTypeName", { enumerable: true, get: function () { return encryption_js_1.SupportedTeeTypeName; } });
+Object.defineProperty(exports, "bigintToPlaintext", { enumerable: true, get: function () { return encryption_js_1.bigintToPlaintext; } });
+Object.defineProperty(exports, "bytes32ToPlaintext", { enumerable: true, get: function () { return encryption_js_1.bytes32ToPlaintext; } });
+Object.defineProperty(exports, "bytesToPlaintext", { enumerable: true, get: function () { return encryption_js_1.bytesToPlaintext; } });
+Object.defineProperty(exports, "encryptionSchemes", { enumerable: true, get: function () { return encryption_js_1.encryptionSchemes; } });
+Object.defineProperty(exports, "getEncryptionSchemeName", { enumerable: true, get: function () { return encryption_js_1.getEncryptionSchemeName; } });
+Object.defineProperty(exports, "plaintextToBigint", { enumerable: true, get: function () { return encryption_js_1.plaintextToBigint; } });
+Object.defineProperty(exports, "plaintextToBytes", { enumerable: true, get: function () { return encryption_js_1.plaintextToBytes; } });
+Object.defineProperty(exports, "plaintextToBytes32", { enumerable: true, get: function () { return encryption_js_1.plaintextToBytes32; } });
+Object.defineProperty(exports, "supportedTeeTypes", { enumerable: true, get: function () { return encryption_js_1.supportedTeeTypes; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZW5jcnlwdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFnQnlCO0FBZnZCLDJHQUFBLFVBQVUsT0FBQTtBQUNWLGlIQUFBLGdCQUFnQixPQUFBO0FBQ2hCLDBHQUFBLFNBQVMsT0FBQTtBQUNULGlIQUFBLGdCQUFnQixPQUFBO0FBQ2hCLHFIQUFBLG9CQUFvQixPQUFBO0FBQ3BCLGtIQUFBLGlCQUFpQixPQUFBO0FBQ2pCLG1IQUFBLGtCQUFrQixPQUFBO0FBQ2xCLGlIQUFBLGdCQUFnQixPQUFBO0FBQ2hCLGtIQUFBLGlCQUFpQixPQUFBO0FBQ2pCLHdIQUFBLHVCQUF1QixPQUFBO0FBQ3ZCLGtIQUFBLGlCQUFpQixPQUFBO0FBQ2pCLGlIQUFBLGdCQUFnQixPQUFBO0FBQ2hCLG1IQUFBLGtCQUFrQixPQUFBO0FBQ2xCLGtIQUFBLGlCQUFpQixPQUFBIn0=

package/dist/cjs/generated/abis/add-two.d.ts

@@ -0,0 +1,117 @@
+export declare const addTwoAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "_inco";
+        readonly internalType: "contract IncoLightning";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "receive";
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "a";
+        readonly internalType: "euint256";
+        readonly type: "bytes32";
+    }];
+    readonly name: "addTwo";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "euint256";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "a";
+        readonly internalType: "euint256";
+        readonly type: "bytes32";
+    }];
+    readonly name: "addTwoAlt";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "euint256";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "uint256EInput";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly name: "addTwoEoa";
+    readonly outputs: readonly [{
+        readonly name: "result";
+        readonly internalType: "euint256";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "resultRevealed";
+        readonly internalType: "euint256";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "getTrue";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "ebool";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "lastResult";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "resultHandle";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "p";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "decryption";
+        readonly internalType: "struct DecryptionAttestation";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "handle";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "value";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }];
+    }];
+    readonly name: "verifyAttestedComputeResultHandle";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "payable";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "ReentrantCall";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "RefundFailed";
+}];