@inco/js 0.6.1 → 0.6.8

package/dist/types/generated/es/inco/covalidator/compute/v1/types_pb.d.ts

@@ -0,0 +1,186 @@
+import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file inco/covalidator/compute/v1/types.proto.
+ */
+export declare const file_inco_covalidator_compute_v1_types: GenFile;
+/**
+ * @generated from message inco.covalidator.compute.v1.InputContext
+ */
+export type InputContext = Message<"inco.covalidator.compute.v1.InputContext"> & {
+    /**
+     * @generated from field: string host_chain_id = 1;
+     */
+    hostChainId: string;
+    /**
+     * @generated from field: string acl_address = 2;
+     */
+    aclAddress: string;
+    /**
+     * @generated from field: string user_address = 3;
+     */
+    userAddress: string;
+    /**
+     * @generated from field: string contract_address = 4;
+     */
+    contractAddress: string;
+};
+/**
+ * Describes the message inco.covalidator.compute.v1.InputContext.
+ * Use `create(InputContextSchema)` to create a new message.
+ */
+export declare const InputContextSchema: GenMessage<InputContext>;
+/**
+ * InputCryptogram is the outer encrypted content of the CiphertextInput
+ *
+ * @generated from message inco.covalidator.compute.v1.InputCryptogram
+ */
+export type InputCryptogram = Message<"inco.covalidator.compute.v1.InputCryptogram"> & {
+    /**
+     * The input context that should be collected from the ambient context (e.g. event fields and metadata). This will
+     * be compared with CiphertextInputPayload.context_hash to ensure that the ciphertext is being used in the correct context.
+     *
+     * @generated from field: inco.covalidator.compute.v1.InputContext context = 1;
+     */
+    context?: InputContext;
+    /**
+     * The CiphertextInput: an encrypted serialisation of InputPayload
+     *
+     * @generated from field: bytes payload = 2;
+     */
+    payload: Uint8Array;
+};
+/**
+ * Describes the message inco.covalidator.compute.v1.InputCryptogram.
+ * Use `create(InputCryptogramSchema)` to create a new message.
+ */
+export declare const InputCryptogramSchema: GenMessage<InputCryptogram>;
+/**
+ * InputPayload is the inner encrypted content of the CiphertextInput
+ *
+ * @generated from message inco.covalidator.compute.v1.InputPayload
+ */
+export type InputPayload = Message<"inco.covalidator.compute.v1.InputPayload"> & {
+    /**
+     * A canonical hash of the InputContext defined as:
+     *   keccak256(abi.encodePacked("evm/", hostChainId, aclAddress, userAddress, contractAddress))
+     *
+     * @generated from field: bytes context_hash = 1;
+     */
+    contextHash: Uint8Array;
+    /**
+     * Plaintexts all sharing a common context
+     *
+     * @generated from field: repeated inco.covalidator.compute.v1.AnyValue values = 2;
+     */
+    values: AnyValue[];
+};
+/**
+ * Describes the message inco.covalidator.compute.v1.InputPayload.
+ * Use `create(InputPayloadSchema)` to create a new message.
+ */
+export declare const InputPayloadSchema: GenMessage<InputPayload>;
+/**
+ * @generated from message inco.covalidator.compute.v1.AnyValue
+ */
+export type AnyValue = Message<"inco.covalidator.compute.v1.AnyValue"> & {
+    /**
+     * The plaintext bytes deserialisable according to the type
+     *
+     * @generated from oneof inco.covalidator.compute.v1.AnyValue.value
+     */
+    value: {
+        /**
+         * @generated from field: inco.covalidator.compute.v1.Scalar scalar = 2;
+         */
+        value: Scalar;
+        case: "scalar";
+    } | {
+        /**
+         * @generated from field: inco.covalidator.compute.v1.List list = 3;
+         */
+        value: List;
+        case: "list";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message inco.covalidator.compute.v1.AnyValue.
+ * Use `create(AnyValueSchema)` to create a new message.
+ */
+export declare const AnyValueSchema: GenMessage<AnyValue>;
+/**
+ * Scalar represents a single scalar value of a given type and only applies to inputs not store cryptograms
+ *
+ * @generated from message inco.covalidator.compute.v1.Scalar
+ */
+export type Scalar = Message<"inco.covalidator.compute.v1.Scalar"> & {
+    /**
+     * The type of the scalar
+     *
+     * @generated from field: int32 type = 1;
+     */
+    type: number;
+    /**
+     * The value of the scalar
+     *
+     * @generated from field: bytes value = 2;
+     */
+    value: Uint8Array;
+};
+/**
+ * Describes the message inco.covalidator.compute.v1.Scalar.
+ * Use `create(ScalarSchema)` to create a new message.
+ */
+export declare const ScalarSchema: GenMessage<Scalar>;
+/**
+ * List represents a list of values of a given type and only applies to inputs not store cryptograms
+ *
+ * @generated from message inco.covalidator.compute.v1.List
+ */
+export type List = Message<"inco.covalidator.compute.v1.List"> & {
+    /**
+     * The type of the elements of the list
+     *
+     * @generated from field: int32 elementType = 1;
+     */
+    elementType: number;
+    /**
+     * The values of the list
+     *
+     * @generated from field: repeated bytes values = 2;
+     */
+    values: Uint8Array[];
+};
+/**
+ * Describes the message inco.covalidator.compute.v1.List.
+ * Use `create(ListSchema)` to create a new message.
+ */
+export declare const ListSchema: GenMessage<List>;
+/**
+ * @generated from message inco.covalidator.compute.v1.StoredCryptogram
+ */
+export type StoredCryptogram = Message<"inco.covalidator.compute.v1.StoredCryptogram"> & {
+    /**
+     * The external handle for the ciphertext, this handle is indicative but not authoritative
+     * it should be compared with the internal handle in storage payload or verified against the HADU
+     * derived handle for InputCiphertextPayload before being trusted. A handle mismatch should trigger an error indicating
+     * some kind of bug or tampering.
+     *
+     * @generated from field: bytes handle = 1;
+     */
+    handle: Uint8Array;
+    /**
+     * An encrypted serialisation of the compute payload consisting of a deterministic serialisation of the value and internal handle defined in the computable sub-package
+     *
+     * @generated from field: bytes payload = 2;
+     */
+    payload: Uint8Array;
+};
+/**
+ * Describes the message inco.covalidator.compute.v1.StoredCryptogram.
+ * Use `create(StoredCryptogramSchema)` to create a new message.
+ */
+export declare const StoredCryptogramSchema: GenMessage<StoredCryptogram>;

package/dist/types/handle.d.ts

@@ -29,13 +29,29 @@ export declare const InputContext: Schema.Struct<{
 export type InputContext = typeof InputContext.Type;
 export type Handle = HexString;
 export declare function getHandleType(handle: HexString): FheType;
+/**
+ *  Computes the prehandle hash for an input based on the ciphertext
+ *
+ * @param ciphertextPayload Note this is the different from the input which has the external handle prepended
+ * @param indexHandle
+ * @param handleType
+ * @param handleVersion
+ */
 export declare function computePrehandle({ ciphertext, indexHandle, handleType, handleVersion, }: {
     ciphertext: Uint8Array;
     indexHandle: number;
     handleType: FheType;
     handleVersion: number;
 }): Buffer;
+/**
+ * Computes the final handle for an input based on the prehandle and the input context, matches the handle generation
+ * in Go and Solidity
+ *
+ * @param prehandle
+ * @param context
+ */
 export declare function computeHandle({ prehandle, context, }: {
     prehandle: Uint8Array;
     context: InputContext;
 }): Buffer;
+export declare function hashInputContext(context: InputContext): Buffer;

package/dist/types/lite/ecies.d.ts

@@ -13,14 +13,12 @@ export declare function decodeSecp256k1PublicKey(pubKeyCompressed: Uint8Array):
 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/types/lite/hadu.d.ts

@@ -1,24 +1,4 @@
-import { Schema } from 'effect';
 import { PlaintextWithContext } from '../encryption/index.js';
-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 | 7 | 8, 0 | 5 | 7 | 8, never>;
-}>>;
-export type HaduInput = typeof HaduInput.Type;
-export declare function encodeInput({ plaintext, context, }: PlaintextWithContext): string;
-export declare function decodeInput(json: string): PlaintextWithContext;
+import { InputPayload } from '../generated/es/inco/covalidator/compute/v1/types_pb.js';
+export declare function encodeInput({ plaintext, context, }: PlaintextWithContext): Uint8Array;
+export declare function decodeInput(input: Uint8Array): InputPayload;

package/dist/types/viem.d.ts

@@ -116,7 +116,7 @@ export declare const chains: {
         formatters: {
             readonly block: {
                 exclude: [] | undefined;
-                format: (args: import("viem/chains").OpStackRpcBlock) => {
+                format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
                     baseFeePerGas: bigint | null;
                     blobGasUsed: bigint;
                     difficulty: bigint;
@@ -126,7 +126,7 @@ export declare const chains: {
                     gasUsed: bigint;
                     hash: `0x${string}` | null;
                     logsBloom: `0x${string}` | null;
-                    miner: import("abitype").Address;
+                    miner: import("viem").Address;
                     mixHash: import("viem").Hash;
                     nonce: `0x${string}` | null;
                     number: bigint | null;
@@ -149,17 +149,17 @@ export declare const chains: {
             };
             readonly transaction: {
                 exclude: [] | undefined;
-                format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -179,8 +179,8 @@ export declare const chains: {
                     v: bigint;
                     value: bigint;
                     gas: bigint;
-                    to: import("abitype").Address | null;
-                    from: import("abitype").Address;
+                    to: import("viem").Address | null;
+                    from: import("viem").Address;
                     nonce: number;
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
@@ -204,14 +204,14 @@ export declare const chains: {
                 } | {
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -232,14 +232,14 @@ export declare const chains: {
                 } | {
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -260,14 +260,14 @@ export declare const chains: {
                 } | {
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -288,14 +288,14 @@ export declare const chains: {
                 } | {
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -318,21 +318,21 @@ export declare const chains: {
             };
             readonly transactionReceipt: {
                 exclude: [] | undefined;
-                format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
                     blobGasPrice?: bigint | undefined;
                     blobGasUsed?: bigint | undefined;
                     blockHash: import("viem").Hash;
                     blockNumber: bigint;
-                    contractAddress: import("abitype").Address | null | undefined;
+                    contractAddress: import("viem").Address | null | undefined;
                     cumulativeGasUsed: bigint;
                     effectiveGasPrice: bigint;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gasUsed: bigint;
                     logs: import("viem").Log<bigint, number, false>[];
                     logsBloom: import("viem").Hex;
                     root?: `0x${string}` | undefined;
                     status: "success" | "reverted";
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionHash: import("viem").Hash;
                     transactionIndex: number;
                     type: import("viem").TransactionType;
@@ -392,15 +392,12 @@ export declare const chains: {
             };
         };
         blockTime?: number | undefined | undefined;
-        contracts?: {
-            [x: string]: import("viem").ChainContract | {
-                [sourceId: number]: import("viem").ChainContract | undefined;
-            } | undefined;
-            ensRegistry?: import("viem").ChainContract | undefined;
-            ensUniversalResolver?: import("viem").ChainContract | undefined;
-            multicall3?: import("viem").ChainContract | undefined;
-            erc6492Verifier?: import("viem").ChainContract | undefined;
-        } | undefined;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                readonly blockCreated: 0;
+            };
+        };
         ensTlds?: readonly string[] | undefined;
         id: 9746;
         name: "Plasma Testnet";
@@ -546,7 +543,7 @@ export declare const chains: {
         formatters: {
             readonly block: {
                 exclude: [] | undefined;
-                format: (args: import("viem/chains").OpStackRpcBlock) => {
+                format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
                     baseFeePerGas: bigint | null;
                     blobGasUsed: bigint;
                     difficulty: bigint;
@@ -556,7 +553,7 @@ export declare const chains: {
                     gasUsed: bigint;
                     hash: `0x${string}` | null;
                     logsBloom: `0x${string}` | null;
-                    miner: import("abitype").Address;
+                    miner: import("viem").Address;
                     mixHash: import("viem").Hash;
                     nonce: `0x${string}` | null;
                     number: bigint | null;
@@ -579,17 +576,17 @@ export declare const chains: {
             };
             readonly transaction: {
                 exclude: [] | undefined;
-                format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -609,8 +606,8 @@ export declare const chains: {
                     v: bigint;
                     value: bigint;
                     gas: bigint;
-                    to: import("abitype").Address | null;
-                    from: import("abitype").Address;
+                    to: import("viem").Address | null;
+                    from: import("viem").Address;
                     nonce: number;
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
@@ -634,14 +631,14 @@ export declare const chains: {
                 } | {
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -662,14 +659,14 @@ export declare const chains: {
                 } | {
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -690,14 +687,14 @@ export declare const chains: {
                 } | {
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -718,14 +715,14 @@ export declare const chains: {
                 } | {
                     blockHash: `0x${string}` | null;
                     blockNumber: bigint | null;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gas: bigint;
                     hash: import("viem").Hash;
                     input: import("viem").Hex;
                     nonce: number;
                     r: import("viem").Hex;
                     s: import("viem").Hex;
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionIndex: number | null;
                     typeHex: import("viem").Hex | null;
                     v: bigint;
@@ -748,21 +745,21 @@ export declare const chains: {
             };
             readonly transactionReceipt: {
                 exclude: [] | undefined;
-                format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
                     blobGasPrice?: bigint | undefined;
                     blobGasUsed?: bigint | undefined;
                     blockHash: import("viem").Hash;
                     blockNumber: bigint;
-                    contractAddress: import("abitype").Address | null | undefined;
+                    contractAddress: import("viem").Address | null | undefined;
                     cumulativeGasUsed: bigint;
                     effectiveGasPrice: bigint;
-                    from: import("abitype").Address;
+                    from: import("viem").Address;
                     gasUsed: bigint;
                     logs: import("viem").Log<bigint, number, false>[];
                     logsBloom: import("viem").Hex;
                     root?: `0x${string}` | undefined;
                     status: "success" | "reverted";
-                    to: import("abitype").Address | null;
+                    to: import("viem").Address | null;
                     transactionHash: import("viem").Hash;
                     transactionIndex: number;
                     type: import("viem").TransactionType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inco/js",
-  "version": "0.6.1",
+  "version": "0.6.8",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -94,10 +94,12 @@
     "@types/elliptic": "^6.4.18",
     "ecies-geth": "^1.7.5",
     "effect": "^3.17.13",
+    "elliptic": "^6.6.1",
     "sha3": "^2.1.4",
     "viem": "^2.23.6"
   },
   "devDependencies": {
+    "@inco/pega": "0.1.0",
     "@bufbuild/protoc-gen-es": "^2.2.2",
     "@typescript-eslint/parser": "^8.35.1",
     "@vitest/coverage-istanbul": "3.1.1",