@inco/lightning-js 0.0.0-bootstrap.0

package/dist/types/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/types/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/types/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";
+}];