@inco/js 0.2.16 → 0.2.17

package/dist/types/encryption/encryption.d.ts

@@ -0,0 +1,119 @@
+import { Schema } from 'effect';
+import { Bytes32 } from '../binary.js';
+import { InputContext } from '../handle.js';
+export type Encryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedFheType>(plaintext: PlaintextWithContextOf<S, T>) => Promise<EncryptResultOf<S, T>>;
+export type Decryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedFheType>(ciphertext: CiphertextOf<S, T>, context?: InputContext) => Promise<PlaintextOf<S, T>>;
+export declare const supportedFheTypes: {
+    readonly euint64: 5;
+    readonly euint160: 7;
+    readonly euint256: 8;
+    readonly ebool: 0;
+};
+export declare const SupportedFheTypeName: Schema.SchemaClass<"ebool" | "euint64" | "euint160" | "euint256", "ebool" | "euint64" | "euint160" | "euint256", never>;
+export type SupportedFheTypeName = typeof SupportedFheTypeName.Type;
+export declare const SupportedFheType: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+export type SupportedFheType = typeof SupportedFheType.Type;
+export declare const encryptionSchemes: {
+    readonly tfhe: 0;
+    readonly ecies: 1;
+    readonly cryptobox: 2;
+};
+export declare function getEncryptionSchemeName(scheme: number): string;
+export type EncryptionSchemes = typeof encryptionSchemes;
+export type EciesScheme = EncryptionSchemes['ecies'];
+export type TfheScheme = EncryptionSchemes['tfhe'];
+export type CryptoboxScheme = EncryptionSchemes['cryptobox'];
+export declare const EncryptionScheme: Schema.Literal<[0, 1, 2]>;
+export type EncryptionScheme = typeof EncryptionScheme.Type;
+type DistType<P, S extends EncryptionScheme, T extends SupportedFheType> = P extends any ? P & {
+    scheme: S;
+    type: T;
+} : never;
+export declare const ciphertextEnvelopes: {
+    readonly none: 0;
+    readonly hadu: 1;
+};
+export declare const CiphertextEnvelope: Schema.SchemaClass<0 | 1, 0 | 1, never>;
+export declare const Ciphertext: Schema.Struct<{
+    scheme: Schema.Literal<[0, 1, 2]>;
+    type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+    value: Schema.TemplateLiteral<`0x${string}`>;
+    envelope: Schema.optional<Schema.SchemaClass<0 | 1, 0 | 1, never>>;
+}>;
+export type Ciphertext = typeof Ciphertext.Type;
+export type CiphertextOf<S extends EncryptionScheme, T extends SupportedFheType> = DistType<Ciphertext, S, T>;
+export declare const CiphertextWithContext: Schema.Struct<{
+    ciphertext: Schema.Struct<{
+        scheme: Schema.Literal<[0, 1, 2]>;
+        type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+        value: Schema.TemplateLiteral<`0x${string}`>;
+        envelope: Schema.optional<Schema.SchemaClass<0 | 1, 0 | 1, never>>;
+    }>;
+    context: Schema.Struct<{
+        hostChainId: typeof Schema.BigInt;
+        aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+        userAddress: Schema.TemplateLiteral<`0x${string}`>;
+        contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+    }>;
+}>;
+export type CiphertextWithContext = typeof CiphertextWithContext.Type;
+export type CiphertextWithContextOf<S extends EncryptionScheme, T extends SupportedFheType> = CiphertextWithContext & {
+    ciphertext: CiphertextOf<S, T>;
+};
+export declare const EncryptResult: Schema.Struct<{
+    ciphertext: Schema.Struct<{
+        scheme: Schema.Literal<[0, 1, 2]>;
+        type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+        value: Schema.TemplateLiteral<`0x${string}`>;
+        envelope: Schema.optional<Schema.SchemaClass<0 | 1, 0 | 1, never>>;
+    }>;
+    context: Schema.Struct<{
+        hostChainId: typeof Schema.BigInt;
+        aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+        userAddress: Schema.TemplateLiteral<`0x${string}`>;
+        contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+    }>;
+    prehandle: 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">;
+    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">;
+}>;
+export type EncryptResult = typeof EncryptResult.Type;
+export type EncryptResultOf<S extends EncryptionScheme, T extends SupportedFheType> = EncryptResult & {
+    ciphertext: CiphertextOf<S, T>;
+};
+export declare const Plaintext: Schema.Union<[Schema.Struct<{
+    scheme: Schema.Literal<[0, 1, 2]>;
+    type: Schema.Literal<[5, 7, 8]>;
+    value: typeof Schema.BigInt;
+}>, Schema.Struct<{
+    scheme: Schema.Literal<[0, 1, 2]>;
+    type: Schema.Literal<[0]>;
+    value: typeof Schema.Boolean;
+}>]>;
+export type Plaintext = typeof Plaintext.Type;
+export type PlaintextOf<S extends EncryptionScheme, T extends SupportedFheType> = DistType<Plaintext, S, T>;
+export declare const PlaintextWithContext: Schema.Struct<{
+    plaintext: Schema.Union<[Schema.Struct<{
+        scheme: Schema.Literal<[0, 1, 2]>;
+        type: Schema.Literal<[5, 7, 8]>;
+        value: typeof Schema.BigInt;
+    }>, Schema.Struct<{
+        scheme: Schema.Literal<[0, 1, 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}`>;
+    }>;
+}>;
+export type PlaintextWithContext = typeof PlaintextWithContext.Type;
+export type PlaintextWithContextOf<S extends EncryptionScheme, T extends SupportedFheType> = PlaintextWithContext & {
+    plaintext: PlaintextOf<S, T>;
+};
+export declare function bigintToPlaintext<S extends EncryptionScheme, T extends SupportedFheType>(scheme: S, type: T, bigPt: bigint): PlaintextOf<S, T>;
+export declare function plaintextToBigint(plaintext: Plaintext): bigint;
+export declare function plaintextToBytes32(plaintext: Plaintext): Bytes32;
+export declare function bytes32ToPlaintext(plaintext: Bytes32, scheme: EncryptionScheme, type: SupportedFheType): Plaintext;
+export {};

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

@@ -0,0 +1 @@
+export * from './encryption.js';

package/dist/types/fhevm/fhe-environment.d.ts

@@ -0,0 +1,9 @@
+import { Chainish } from '../chain.js';
+export type Address = `0x${string}`;
+export type FheEnvironment = {
+    aclAddress: Address;
+    thfeExecutorAddress: Address;
+    gatewayAddress: Address;
+    kmsVerifierAddress: Address;
+};
+export declare function getFheEnvironment(chainId: Chainish): FheEnvironment;

package/dist/types/fhevm/fhevm.d.ts

@@ -0,0 +1,41 @@
+import { Account, Chain, PublicClient, TransactionReceipt, Transport, WalletClient } from 'viem';
+import { SupportedChain } from '../chain.js';
+export type PublicWalletClient = {
+    public: PublicClient<Transport, Chain, Account>;
+    wallet: WalletClient<Transport, Chain, Account>;
+};
+export declare function createPublicWalletClient({ account, hostChainRpcUrl, chain, }: {
+    account: Account;
+    hostChainRpcUrl: string;
+    chain: Chain;
+}): PublicWalletClient;
+export declare function getFhevmDeployerClient({ deployer, hostChainRpcUrl, chain, }: {
+    deployer: Account;
+    hostChainRpcUrl: string;
+    chain: SupportedChain;
+}): PublicWalletClient;
+export type PrivateKeys = {
+    relayer: string;
+    kmsSigner: string;
+    deployer: string;
+};
+export type HostChainConfig = {
+    privateKeys: PrivateKeys;
+    rpcUrl: string;
+};
+export declare function configureFhevmContracts({ chain, hostChain: { privateKeys, rpcUrl }, }: {
+    hostChain: HostChainConfig;
+    chain: SupportedChain;
+}): Promise<{
+    addRelayerTxReceipt: TransactionReceipt | null;
+    addKmsSignerTxReceipt: TransactionReceipt | null;
+}>;
+export type L1Config = {
+    cometRpcEndpoint: string;
+    mnemonic: string;
+    grpcEndpoint: string;
+};
+export declare function ensureFheEnvironmentRegistered({ l1, chain, }: {
+    l1: L1Config;
+    chain: SupportedChain;
+}): Promise<void>;

package/dist/types/fhevm/index.d.ts

@@ -0,0 +1 @@
+export * from './fhe-environment.js';

package/dist/types/fhevm/reencrypt.d.ts

@@ -0,0 +1,20 @@
+import { Account, Address, Chain, Transport, WalletClient } from 'viem';
+import { CryptoboxScheme } from '../encryption/encryption.js';
+import type { Reencryptor, ReencryptorArgs } from '../reencryption/index.js';
+import type { PubKeyEncodable } from '../reencryption/types.js';
+export interface EphemeralCryptoBoxKeypair extends PubKeyEncodable {
+    scheme: CryptoboxScheme;
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+export interface ZamaReencryptorArgs extends ReencryptorArgs {
+    gatewayUrl: string;
+    unsafeSkipVerifyKMSSignatures?: boolean;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    contractAddress: Address;
+    chainId: bigint;
+    kmsSigners: Address[];
+    userAddress: Address;
+}
+export declare function zamaReencryptor({ chainId, gatewayUrl, walletClient, unsafeSkipVerifyKMSSignatures, contractAddress, kmsSigners, userAddress, }: ZamaReencryptorArgs): Promise<Reencryptor<CryptoboxScheme>>;
+export declare function generateCryptoBoxEphemeralKeyPair(): EphemeralCryptoBoxKeypair;

package/dist/types/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.js';
+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/types/fhevm/types.d.ts

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

package/dist/types/generated/abis/addTwo.d.ts

@@ -0,0 +1,83 @@
+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: "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: "uint256EInput";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly name: "addTwoEOA";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        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: "addTwoScalar";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "euint256";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "result";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly name: "callback";
+    readonly outputs: readonly [];
+    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";
+}];