@inco/js 0.1.9

package/dist/fhevm/tfhe.d.ts

@@ -0,0 +1,74 @@
+import { RustType } from 'bincode-ts';
+import { Schema } from 'effect';
+import { CompactPkePublicParams, TfheCompactPublicKey } from 'node-tfhe';
+import { Decryptor, Encryptor, Plaintext, TfheScheme } from '../encryption/encryption';
+export declare const SERIALIZED_SIZE_LIMIT_CIPHERTEXT: bigint;
+export declare const SERIALIZED_SIZE_LIMIT_PK: bigint;
+export declare const SERIALIZED_SIZE_LIMIT_CRS: bigint;
+export type TfheEncryptorArgs = {
+    scheme: TfheScheme;
+    publicKey: Buffer;
+    crs2048: Buffer;
+};
+export type TfheDecryptorArgs = {
+    scheme: TfheScheme;
+    cks: Buffer;
+};
+export type PublicParams<T = CompactPkePublicParams> = {
+    [key in EncryptionTypes]?: {
+        publicParams: T;
+    };
+};
+export declare const ENCRYPTION_TYPES: {
+    1: number;
+    4: number;
+    8: number;
+    16: number;
+    32: number;
+    64: number;
+    128: number;
+    160: number;
+    256: number;
+    512: number;
+    1024: number;
+    2048: number;
+};
+export type EncryptionTypes = keyof typeof ENCRYPTION_TYPES;
+export type ZKInput = {
+    addBool: (value: boolean) => ZKInput;
+    add4: (value: number | bigint) => ZKInput;
+    add8: (value: number | bigint) => ZKInput;
+    add16: (value: number | bigint) => ZKInput;
+    add32: (value: number | bigint) => ZKInput;
+    add64: (value: number | bigint) => ZKInput;
+    add128: (value: number | bigint) => ZKInput;
+    add256: (value: number | bigint) => ZKInput;
+    addBytes64: (value: Uint8Array) => ZKInput;
+    addBytes128: (value: Uint8Array) => ZKInput;
+    addBytes256: (value: Uint8Array) => ZKInput;
+    addAddress: (value: string) => ZKInput;
+    getBits: () => number[];
+    encrypt: () => Promise<{
+        prehandles: Uint8Array[];
+        ciphertext: Uint8Array;
+    }>;
+};
+export declare function getTfheEncryptor(args: TfheEncryptorArgs): Encryptor<TfheScheme>;
+export declare function createEncryptedInput(aclContractAddress: string, chainId: bigint, tfheCompactPublicKey: TfheCompactPublicKey, publicParams: PublicParams): (userAddress: string, contractAddress: string) => ZKInput;
+export declare function addPlaintextInput(input: ZKInput, plaintext: Plaintext): ZKInput;
+export declare function getTfheDecryptor({ cks }: TfheDecryptorArgs): Decryptor<TfheScheme>;
+export declare const SerializationHeader: RustType.Type<{
+    [x: string]: {};
+} & {
+    [x: string]: {};
+}>;
+export declare const ProvenCompactCiphertextListTypeName = "high_level_api::ProvenCompactCiphertextList";
+export declare const FheUintTypeName = "high_level_api::FheUint";
+export declare const TfheSerialisationTypeName: Schema.Literal<["high_level_api::ProvenCompactCiphertextList", "high_level_api::FheUint"]>;
+export type TfheSerialisationTypeName = typeof TfheSerialisationTypeName.Type;
+export declare const TfheSerializationHeader: Schema.Struct<{
+    header_version: typeof Schema.String;
+    name: Schema.Union<[Schema.Literal<["high_level_api::ProvenCompactCiphertextList", "high_level_api::FheUint"]>, typeof Schema.String]>;
+}>;
+export type TfheSerializationHeader = typeof TfheSerializationHeader.Type;
+export declare function decodeTfheSerializationHeader(buffer: Uint8Array): TfheSerializationHeader;

package/dist/fhevm/types.d.ts

@@ -0,0 +1,3 @@
+import { FheTypes } from 'node-tfhe';
+import { FheType } from '../handle';
+export declare function getHandleTypeFromFheType(fheType: FheTypes | undefined): FheType;