@inco/js 0.1.9

package/dist/generated/ts/inco/preflight/v1/tx.d.ts

@@ -0,0 +1,187 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { type CallOptions, ChannelCredentials, Client, type ClientOptions, type ClientUnaryCall, type handleUnaryCall, Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+import { InputContext, Params } from "./types";
+export declare const protobufPackage = "inco.preflight.v1";
+/** MsgRegisterInput the Msg/RegisterInput request type. */
+export interface MsgRegisterInput {
+    /**
+     * signer is the bech32-encoded address of the signer of the Msg. It doesn't
+     * necessarily have to be the owner of the input. In practice, it will one of
+     * the following:
+     * - the owner of the input (if the end-user interacts with the Inco L1
+     * directly)
+     * - a Paymaster that facilitates the interaction between the end-user and
+     * the Inco L1, usually by paying for the gas fees. The Paymaster is
+     * expected to be run by one or more of the covalidators.
+     */
+    signer: string;
+    /** ciphertext is the input encrypted by the end-user. It contains the zkpok. */
+    ciphertext: Uint8Array;
+    /** context is the context with which the input is registered. */
+    context: InputContext | undefined;
+    /**
+     * The prehandle depends on the hash of the ciphertext, and three separate
+     * 1-byte cleartext metadata values in positions 29, 30, and 31 of the 32-byte
+     * handle respectively:
+     *   - the handle index (since ciphertexts are now a list-shaped container),
+     *   - the handle type
+     *   - the handle version (currently always 0)
+     * We could take these 3 bytes of metadata to produce the handle, but since
+     * the client need to compute the prehandle anyway we might as well just have
+     * them submit the finished value, we will still hash in the context
+     * preserving the fallback mechanism security guarantees.
+     */
+    prehandle: Uint8Array;
+}
+/** MsgRegisterInputResponse the Msg/RegisterInput response type. */
+export interface MsgRegisterInputResponse {
+    /** handle refers to a unique identifier for the ciphertext. */
+    handle: Uint8Array;
+}
+/** MsgRegisterFallback the Msg/RegisterFallback request type. */
+export interface MsgRegisterFallback {
+    /** handle refers to a unique identifier for the ciphertext. */
+    handle: Uint8Array;
+    /**
+     * covalidator is the covalidator's bech32-encoded address. This address is
+     * checked against the list of covalidators, which lives in the x/fhe
+     * params.
+     */
+    covalidator: string;
+}
+/** MsgRegisterFallbackResponse the Msg/RegisterFallback response type. */
+export interface MsgRegisterFallbackResponse {
+}
+/** MsgUpdateParams the Msg/UpdateParams request type. */
+export interface MsgUpdateParams {
+    /**
+     * params is the new parameters for the x/preflight module.
+     *
+     * Note: all fields must be set.
+     */
+    params: Params | undefined;
+    /**
+     * authority is the bech32-encoded address of the authority of the Msg. It
+     * defaults to the governance module.
+     */
+    authority: string;
+}
+/** MsgUpdateParamsResponse the Msg/UpdateParams response type. */
+export interface MsgUpdateParamsResponse {
+}
+export declare const MsgRegisterInput: MessageFns<MsgRegisterInput>;
+export declare const MsgRegisterInputResponse: MessageFns<MsgRegisterInputResponse>;
+export declare const MsgRegisterFallback: MessageFns<MsgRegisterFallback>;
+export declare const MsgRegisterFallbackResponse: MessageFns<MsgRegisterFallbackResponse>;
+export declare const MsgUpdateParams: MessageFns<MsgUpdateParams>;
+export declare const MsgUpdateParamsResponse: MessageFns<MsgUpdateParamsResponse>;
+/** Msg is the message service for the x/preflight module. */
+export type MsgService = typeof MsgService;
+export declare const MsgService: {
+    /**
+     * RegisterInput registers a handle to a ciphertext and associated context
+     * for the Preflight schemes.
+     */
+    readonly registerInput: {
+        readonly path: "/inco.preflight.v1.Msg/RegisterInput";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: MsgRegisterInput) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => MsgRegisterInput;
+        readonly responseSerialize: (value: MsgRegisterInputResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => MsgRegisterInputResponse;
+    };
+    /**
+     * RegisterFallback registers a handle to a fallback value if it has not
+     * been registered. It can only be called by the covalidators.
+     */
+    readonly registerFallback: {
+        readonly path: "/inco.preflight.v1.Msg/RegisterFallback";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: MsgRegisterFallback) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => MsgRegisterFallback;
+        readonly responseSerialize: (value: MsgRegisterFallbackResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => MsgRegisterFallbackResponse;
+    };
+    /**
+     * UpdateParams updates the parameters of the x/preflight module. It can only
+     * be called by the x/preflight's authority, which defaults to the governance
+     * module.
+     */
+    readonly updateParams: {
+        readonly path: "/inco.preflight.v1.Msg/UpdateParams";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: MsgUpdateParams) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => MsgUpdateParams;
+        readonly responseSerialize: (value: MsgUpdateParamsResponse) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => MsgUpdateParamsResponse;
+    };
+};
+export interface MsgServer extends UntypedServiceImplementation {
+    /**
+     * RegisterInput registers a handle to a ciphertext and associated context
+     * for the Preflight schemes.
+     */
+    registerInput: handleUnaryCall<MsgRegisterInput, MsgRegisterInputResponse>;
+    /**
+     * RegisterFallback registers a handle to a fallback value if it has not
+     * been registered. It can only be called by the covalidators.
+     */
+    registerFallback: handleUnaryCall<MsgRegisterFallback, MsgRegisterFallbackResponse>;
+    /**
+     * UpdateParams updates the parameters of the x/preflight module. It can only
+     * be called by the x/preflight's authority, which defaults to the governance
+     * module.
+     */
+    updateParams: handleUnaryCall<MsgUpdateParams, MsgUpdateParamsResponse>;
+}
+export interface MsgClient extends Client {
+    /**
+     * RegisterInput registers a handle to a ciphertext and associated context
+     * for the Preflight schemes.
+     */
+    registerInput(request: MsgRegisterInput, callback: (error: ServiceError | null, response: MsgRegisterInputResponse) => void): ClientUnaryCall;
+    registerInput(request: MsgRegisterInput, metadata: Metadata, callback: (error: ServiceError | null, response: MsgRegisterInputResponse) => void): ClientUnaryCall;
+    registerInput(request: MsgRegisterInput, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: MsgRegisterInputResponse) => void): ClientUnaryCall;
+    /**
+     * RegisterFallback registers a handle to a fallback value if it has not
+     * been registered. It can only be called by the covalidators.
+     */
+    registerFallback(request: MsgRegisterFallback, callback: (error: ServiceError | null, response: MsgRegisterFallbackResponse) => void): ClientUnaryCall;
+    registerFallback(request: MsgRegisterFallback, metadata: Metadata, callback: (error: ServiceError | null, response: MsgRegisterFallbackResponse) => void): ClientUnaryCall;
+    registerFallback(request: MsgRegisterFallback, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: MsgRegisterFallbackResponse) => void): ClientUnaryCall;
+    /**
+     * UpdateParams updates the parameters of the x/preflight module. It can only
+     * be called by the x/preflight's authority, which defaults to the governance
+     * module.
+     */
+    updateParams(request: MsgUpdateParams, callback: (error: ServiceError | null, response: MsgUpdateParamsResponse) => void): ClientUnaryCall;
+    updateParams(request: MsgUpdateParams, metadata: Metadata, callback: (error: ServiceError | null, response: MsgUpdateParamsResponse) => void): ClientUnaryCall;
+    updateParams(request: MsgUpdateParams, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: MsgUpdateParamsResponse) => void): ClientUnaryCall;
+}
+export declare const MsgClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): MsgClient;
+    service: typeof MsgService;
+    serviceName: string;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/generated/ts/inco/preflight/v1/types.d.ts

@@ -0,0 +1,84 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "inco.preflight.v1";
+/**
+ * InputRegistration is the message that is stored on-chain in the inputs
+ * registry.
+ */
+export interface InputRegistration {
+    /**
+     * inputted_at is the Inco L1 block height at which the input was registered.
+     * It is used for pruning purposes.
+     */
+    inputtedAt: number;
+    ciphertextRegistration?: CiphertextRegistration | undefined;
+    fallbackRegistration?: FallbackRegistration | undefined;
+}
+/**
+ * CiphertextRegistration is the registration of an input encrypted by the
+ * end-user.
+ */
+export interface CiphertextRegistration {
+    /** ciphertext is the input encrypted by the end-user. */
+    ciphertext: Uint8Array;
+    /** context is the context in which the input was registered. */
+    context: InputContext | undefined;
+}
+/** InputContext is the context in which the input was registered. */
+export interface InputContext {
+    /**
+     * host_chain_id is the chain ID of the host chain. Refer to the x/hostchain
+     * module for a specification of the chain ID.
+     */
+    hostChainId: string;
+    /**
+     * keyset_id is the keyset that the input was encrypted under. Refer
+     * to the x/fhe module for a specification of the keysets.
+     */
+    keysetId: string;
+    /**
+     * contract_addr is the address of the contract that the input is intended
+     * for. This is a hex-encoded, non-prefixed Ethereum address (20 bytes).
+     */
+    contractAddr: string;
+    /**
+     * owner_addr is the address of the owner of the input. This is a hex-encoded,
+     * non-prefixed Ethereum address (20 bytes).
+     */
+    ownerAddr: string;
+}
+/** FallbackRegistration is the registration of an input by a covalidator. */
+export interface FallbackRegistration {
+}
+/** Params defines the parameters for the x/preflight module. */
+export interface Params {
+    /**
+     * blocks_to_keep_inputs is the number of blocks to keep inputs registrations
+     * in state. After this number of blocks, the input registration will be
+     * pruned from state, but still accessible via an archive node.
+     */
+    blocksToKeepInputs: number;
+}
+export declare const InputRegistration: MessageFns<InputRegistration>;
+export declare const CiphertextRegistration: MessageFns<CiphertextRegistration>;
+export declare const InputContext: MessageFns<InputContext>;
+export declare const FallbackRegistration: MessageFns<FallbackRegistration>;
+export declare const Params: MessageFns<Params>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/handle.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from 'effect';
+import { HexString } from './binary';
+export declare const HANDLE_VERSION = 0;
+export declare const handleTypes: Readonly<{
+    ebool: 0;
+    euint4: 1;
+    euint8: 2;
+    euint16: 3;
+    euint32: 4;
+    euint64: 5;
+    euint128: 6;
+    euint160: 7;
+    euint256: 8;
+    ebytes64: 9;
+    ebytes128: 10;
+    ebytes256: 11;
+}>;
+export declare const HandleTypeName: Schema.SchemaClass<"ebool" | "euint4" | "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "euint160" | "euint256" | "ebytes64" | "ebytes128" | "ebytes256", "ebool" | "euint4" | "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "euint160" | "euint256" | "ebytes64" | "ebytes128" | "ebytes256", never>;
+export type HandleTypeName = typeof HandleTypeName.Type;
+export type HandleTypes = typeof handleTypes;
+export type FheType = HandleTypes[keyof HandleTypes];
+export declare function isFheType(value: number): value is FheType;
+export declare const InputContext: Schema.Struct<{
+    hostChainId: typeof Schema.BigInt;
+    aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+    userAddress: Schema.TemplateLiteral<`0x${string}`>;
+    contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+}>;
+export type InputContext = typeof InputContext.Type;
+export type Handle = HexString;
+export declare function getHandleType(handle: HexString): FheType;
+export declare function computePrehandle({ ciphertext, indexHandle, handleType, handleVersion, }: {
+    ciphertext: Uint8Array;
+    indexHandle: number;
+    handleType: FheType;
+    handleVersion: number;
+}): Buffer;
+export declare function computeHandle({ prehandle, context }: {
+    prehandle: Uint8Array;
+    context: InputContext;
+}): Buffer;