@inco/js 0.1.9

package/dist/l1/client.d.ts

@@ -0,0 +1,35 @@
+import { Client } from '@connectrpc/connect';
+import { DirectSecp256k1HdWallet, type OfflineSigner } from '@cosmjs/proto-signing';
+import { DeliverTxResponse } from '@cosmjs/stargate';
+import * as fhe from '../generated/es/inco/fhe/v1/query_pb';
+import * as preflight from '../generated/es/inco/preflight/v1/query_pb';
+import { MsgAddCovalidator, MsgAddFheEnv } from '../generated/ts/inco/fhe/v1/tx';
+import { MessageFns, MsgRegisterInput } from '../generated/ts/inco/preflight/v1/tx';
+export interface L1ClientArgs {
+    cometRpcEndpoint: string;
+    grpcEndpoint: string;
+    wallet: OfflineSigner;
+    waitTimeForTxInclusion?: number;
+}
+declare const supportedMsgs: {
+    "/inco.preflight.v1.MsgRegisterInput": MessageFns<MsgRegisterInput>;
+    "/inco.fhe.v1.MsgAddCovalidator": import("../generated/ts/inco/fhe/v1/tx").MessageFns<MsgAddCovalidator>;
+    "/inco.fhe.v1.MsgAddFheEnv": import("../generated/ts/inco/fhe/v1/tx").MessageFns<MsgAddFheEnv>;
+};
+type GetInner<T> = T extends MessageFns<infer U> ? U : never;
+export type SupportedMsgTypes = keyof typeof supportedMsgs;
+export type SupportedMsg<T extends SupportedMsgTypes> = GetInner<(typeof supportedMsgs)[T]>;
+declare const supportedQueries: {
+    fhe: typeof fhe;
+    preflight: typeof preflight;
+};
+export type L1ClientQuery = {
+    [K in keyof typeof supportedQueries]: Client<(typeof supportedQueries)[K]['Query']>;
+};
+export interface L1Client {
+    get q(): L1ClientQuery;
+    sendTx<T extends SupportedMsgTypes>(signerAddress: string, msgType: T, msgBody: SupportedMsg<T>): Promise<DeliverTxResponse>;
+}
+export declare function createL1Wallet(mnemonic: string): Promise<DirectSecp256k1HdWallet>;
+export declare function createL1Client({ cometRpcEndpoint, grpcEndpoint, wallet, waitTimeForTxInclusion, }: L1ClientArgs): Promise<L1Client>;
+export {};

package/dist/l1/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './preflight';

package/dist/l1/preflight.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from 'effect';
+import { Bytes32 } from '../binary';
+import { CiphertextWithContext } from '../encryption/encryption';
+import { type L1ClientArgs } from './client';
+declare const Handle: Schema.brand<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">;
+export type Handle = typeof Handle.Type;
+export type PreflightRequest = CiphertextWithContext & {
+    prehandle: Bytes32;
+};
+export type PreflightResult = {
+    transactionHash: string;
+    handle: Handle;
+};
+export interface PreflightSender {
+    send(encResult: PreflightRequest): Promise<PreflightResult>;
+}
+export declare function cosmJSPreflight({ cometRpcEndpoint, grpcEndpoint, wallet, signerAddress, }: L1ClientArgs & {
+    signerAddress: string;
+}): Promise<PreflightSender>;
+export {};

package/dist/lite/deployments.d.ts

@@ -0,0 +1,6 @@
+import { Chainish } from '../chain';
+import { incoLiteDeployments } from '../generated/inco-lite';
+export type Address = `0x${string}`;
+export type IncoLiteDeployment = (typeof incoLiteDeployments)[number];
+export declare function getActiveIncoLiteDeployment(chain: Chainish): IncoLiteDeployment;
+export declare function getIncoLiteDeployments(chainId: Chainish): readonly IncoLiteDeployment[];

package/dist/lite/ecies.d.ts

@@ -0,0 +1,26 @@
+import { curve, ec } from 'elliptic';
+import { Decryptor, EciesScheme, Encryptor } from '../encryption/encryption';
+import { PubKeyEncodable } from '../reencryption';
+export interface Secp256k1Keypair extends PubKeyEncodable {
+    scheme: EciesScheme;
+    kp: ec.KeyPair;
+}
+export type Secp256k1PubKey = curve.base.BasePoint;
+export declare function toSecp256k1Keypair(kp: ec.KeyPair): Secp256k1Keypair;
+export declare function generateSecp256k1Keypair(): Promise<Secp256k1Keypair>;
+export declare function encodeSecp256k1PublicKey(pub: Secp256k1PubKey): Uint8Array;
+export declare function decodeSecp256k1PublicKey(pubKeyCompressed: Uint8Array): Secp256k1PubKey;
+export declare function decodeSecp256k1PrivateKey(privKey: Uint8Array): Secp256k1Keypair;
+export declare function encrypt(pubKeyA: Secp256k1PubKey, plaintext: Uint8Array, privKeyB: Secp256k1Keypair): Promise<Uint8Array>;
+export type EciesEncryptorArgs = {
+    scheme: EciesScheme;
+    pubKeyA: Secp256k1PubKey;
+    privKeyB: Secp256k1Keypair;
+};
+export declare function getEciesEncryptor({ pubKeyA, privKeyB }: EciesEncryptorArgs): Encryptor<EciesScheme>;
+export declare function decrypt(privKeyA: Secp256k1Keypair, ciphertext: Uint8Array): Promise<Uint8Array>;
+export type EciesDecryptorArgs = {
+    scheme: EciesScheme;
+    privKeyA: Secp256k1Keypair;
+};
+export declare function getEciesDecryptor({ privKeyA }: EciesDecryptorArgs): Decryptor<EciesScheme>;

package/dist/lite/hadu.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from 'effect';
+import { PlaintextWithContext } from '../encryption';
+export declare const encryptionEnvelopes: {
+    readonly none: 0;
+    readonly hadu: 1;
+};
+export type NoneEnvelope = (typeof encryptionEnvelopes)['none'];
+export type HaduEnvelope = (typeof encryptionEnvelopes)['hadu'];
+export declare const EncryptionEnvelope: Schema.SchemaClass<0 | 1, 0 | 1, never>;
+export declare const HaduInput: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
+    envelope: Schema.Literal<[1]>;
+    scheme: Schema.Literal<[0, 1, 2]>;
+    context: Schema.Struct<{
+        hostChainId: typeof Schema.BigInt;
+        aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+        userAddress: Schema.TemplateLiteral<`0x${string}`>;
+        contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+    }>;
+    plaintext: 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">;
+    type: Schema.SchemaClass<0 | 5 | 8, 0 | 5 | 8, never>;
+}>>;
+export type HaduInput = typeof HaduInput.Type;
+export declare function encodeInput({ plaintext, context }: PlaintextWithContext): string;
+export declare function decodeInput(json: string): PlaintextWithContext;