@interfold/sdk 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,136 @@
+import { PublicClient, WalletClient, Chain, Hash, Abi, Log, Address } from 'viem';
+import { C as ContractAddresses, E as E3, a as E3RequestParams, F as FailureReason, b as E3Stage } from './types-C9WZ1Khd.js';
+export { c as CommitteeSize } from './types-C9WZ1Khd.js';
+import { ThresholdBfvParamsPresetName, BfvParams, EncryptedValueAndPublicInputs, VerifiableEncryptionResult } from './crypto/index.js';
+export { ThresholdBfvParamsPresetNames, computePublicKeyCommitment, encryptNumber, encryptNumberAndGenInputs, encryptNumberAndGenProof, encryptVector, encryptVectorAndGenInputs, encryptVectorAndGenProof, generateProof, generatePublicKey, getThresholdBfvParamsSet } from './crypto/index.js';
+import { AllEventTypes, EventCallback } from './events/index.js';
+export { CiphernodeAddedData, CiphernodeRemovedData, CiphertextOutputPublishedData, CommitteeFinalizedData, CommitteePublishedData, CommitteeRequestedData, E3ActivatedData, E3RequestedData, EventFilter, EventListener, EventListenerConfig, EventListenerOptions, InterfoldEvent, InterfoldEventData, InterfoldEventType, PlaintextOutputPublishedData, RegistryEventData, RegistryEventType, SDKEventEmitter } from './events/index.js';
+export { ContractClient, ContractClientConfig } from './contracts/index.js';
+import '@aztec/bb.js';
+
+interface SDKConfig {
+    publicClient: PublicClient;
+    walletClient?: WalletClient;
+    contracts: ContractAddresses;
+    chain?: Chain;
+    thresholdBfvParamsPresetName?: ThresholdBfvParamsPresetName;
+}
+
+declare class InterfoldSDK {
+    private config;
+    private eventListener;
+    private contractClient;
+    private thresholdBfvParamsPresetName;
+    private publicClient;
+    constructor(config: SDKConfig);
+    getPublicClient(): PublicClient;
+    getThresholdBfvParamsSet(): Promise<BfvParams>;
+    generatePublicKey(): Promise<Uint8Array>;
+    computePublicKeyCommitment(publicKey: Uint8Array): Promise<Uint8Array>;
+    encryptNumber(data: bigint, publicKey: Uint8Array): Promise<Uint8Array>;
+    encryptVector(data: BigUint64Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    encryptNumberAndGenInputs(data: bigint, publicKey: Uint8Array): Promise<EncryptedValueAndPublicInputs>;
+    encryptNumberAndGenProof(data: bigint, publicKey: Uint8Array): Promise<VerifiableEncryptionResult>;
+    encryptVectorAndGenInputs(data: BigUint64Array, publicKey: Uint8Array): Promise<EncryptedValueAndPublicInputs>;
+    encryptVectorAndGenProof(data: BigUint64Array, publicKey: Uint8Array): Promise<VerifiableEncryptionResult>;
+    approveFeeToken(amount: bigint): Promise<Hash>;
+    requestE3(params: {
+        committeeSize: number;
+        inputWindow: [bigint, bigint];
+        e3Program: `0x${string}`;
+        paramSet: number;
+        computeProviderParams: `0x${string}`;
+        customParams?: `0x${string}`;
+        proofAggregationEnabled?: boolean;
+        gasLimit?: bigint;
+    }): Promise<Hash>;
+    getE3PublicKey(e3Id: bigint): Promise<`0x${string}`>;
+    publishCiphertextOutput(e3Id: bigint, ciphertextOutput: `0x${string}`, proof: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    getE3(e3Id: bigint): Promise<E3>;
+    getE3Quote(params: E3RequestParams): Promise<bigint>;
+    getFailureReason(e3Id: bigint): Promise<FailureReason>;
+    getE3Stage(e3Id: bigint): Promise<E3Stage>;
+    estimateGas(functionName: string, args: readonly unknown[], contractAddress: `0x${string}`, abi: Abi, value?: bigint): Promise<bigint>;
+    waitForTransaction(hash: Hash): Promise<unknown>;
+    onInterfoldEvent<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): Promise<void>;
+    off<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): void;
+    once<T extends AllEventTypes>(type: T, callback: EventCallback<T>): Promise<void>;
+    getHistoricalEvents(eventType: AllEventTypes, fromBlock?: bigint, toBlock?: bigint): Promise<Log[]>;
+    startEventPolling(): Promise<void>;
+    stopEventPolling(): void;
+    cleanup(): void;
+    static create(options: {
+        rpcUrl: string;
+        contracts: {
+            interfold: `0x${string}`;
+            ciphernodeRegistry: `0x${string}`;
+            feeToken: `0x${string}`;
+        };
+        privateKey?: `0x${string}`;
+        chain: Chain;
+        thresholdBfvParamsPresetName?: ThresholdBfvParamsPresetName;
+    }): InterfoldSDK;
+}
+
+declare const DEFAULT_THRESHOLD_BFV_PARAMS_PRESET_NAME: ThresholdBfvParamsPresetName;
+
+declare class SDKError extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+declare function isValidAddress(address: string): address is Address;
+declare function isValidHash(hash: string): hash is Hash;
+declare function formatEventName(contractName: string, eventName: string): string;
+declare function parseEventData<T>(log: Log): T;
+/**
+ * Sleep for a specified number of milliseconds
+ */
+declare const sleep: (ms: number) => Promise<void>;
+declare function formatBigInt(value: bigint): string;
+declare function parseBigInt(value: string): bigint;
+declare function generateEventId(log: Log): string;
+/**
+ * Get the current timestamp in seconds
+ * from onchain
+ * @param publicClient - The public client to use
+ */
+declare function getCurrentTimestamp(publicClient: PublicClient): Promise<bigint>;
+interface ComputeProviderParams {
+    name: string;
+    parallel: boolean;
+    batch_size: number;
+}
+declare const DEFAULT_COMPUTE_PROVIDER_PARAMS: ComputeProviderParams;
+declare const DEFAULT_E3_CONFIG: {
+    readonly committeeSize: 0;
+    readonly duration: 1800;
+    readonly payment_amount: "0";
+};
+/**
+ * Encode BFV parameters for the smart contract
+ * BFV (Brakerski-Fan-Vercauteren) is a type of fully homomorphic encryption
+ */
+declare function encodeBfvParams(params: BfvParams): `0x${string}`;
+/**
+ * Encode compute provider parameters for the smart contract'
+ * If mock is true, the compute provider parameters will return 32 bytes of 0x00
+ */
+declare function encodeComputeProviderParams(params: ComputeProviderParams, mock?: boolean): `0x${string}`;
+/**
+ * Encode custom parameters for the smart contract.
+ */
+declare function encodeCustomParams(params: Record<string, unknown>): `0x${string}`;
+/**
+ * Calculate start window for E3 request
+ * @dev This function can be used for testing purposes, or for E3s which need to start as soon as possible.
+ * @param publicClient - The public client to use
+ * @param duration - The duration of the input window in seconds
+ * @param startBuffer - Buffer in seconds added to current timestamp for input window start
+ */
+declare function calculateInputWindow(publicClient: PublicClient, duration?: number, startBuffer?: bigint): Promise<[bigint, bigint]>;
+/**
+ * Decode plaintextOutput bytes to get the actual result number
+ */
+declare function decodePlaintextOutput(plaintextOutput: string): number | null;
+
+export { AllEventTypes, BfvParams, type ComputeProviderParams, ContractAddresses, DEFAULT_COMPUTE_PROVIDER_PARAMS, DEFAULT_E3_CONFIG, DEFAULT_THRESHOLD_BFV_PARAMS_PRESET_NAME, E3, E3RequestParams, E3Stage, EncryptedValueAndPublicInputs, EventCallback, FailureReason, InterfoldSDK, type SDKConfig, SDKError, ThresholdBfvParamsPresetName, VerifiableEncryptionResult, calculateInputWindow, decodePlaintextOutput, encodeBfvParams, encodeComputeProviderParams, encodeCustomParams, formatBigInt, formatEventName, generateEventId, getCurrentTimestamp, isValidAddress, isValidHash, parseBigInt, parseEventData, sleep };