@inco/js 0.6.0 → 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/generated/lightning.d.ts

@@ -1,4 +1,25 @@
 export declare const lightningDeployments: readonly [{
+    readonly name: "incoLightningPreview_1_0_2__725458969";
+    readonly majorVersion: 1;
+    readonly deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC";
+    readonly pepper: "alphanet";
+    readonly executorAddress: "0x28676Cd3b10b03b2FDF105Ba280425b45a674F2A";
+    readonly salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc004dfbe338c6966a22bcca19";
+    readonly chainId: 84532;
+    readonly chainName: "Base Sepolia";
+    readonly version: {
+        readonly major: 1;
+        readonly minor: 0;
+        readonly patch: 2;
+        readonly shortSalt: "725458969";
+    };
+    readonly decryptSigner: "0x4736F8CE685760017eEc130AC3FFc6187f5A1F95";
+    readonly eciesPublicKey: "0x038a582d29083c2f3fefe024bf4dd9ab913ab8973716977da5f01106e0b84095b1";
+    readonly blockNumber: 32124925;
+    readonly deployDate: "2025-10-09T13:55:42.997Z";
+    readonly commit: "v0.5.3-10-ga4f2312d";
+    readonly active: true;
+}, {
     readonly name: "incoLightningPreview_1_0_2__904635675";
     readonly majorVersion: 1;
     readonly deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC";

package/dist/types/generated/local-node.d.ts

@@ -16,12 +16,12 @@ export declare const localNodeLightningConfig: {
         readonly senderPrivateKey: "0x6f2539401f377d76bafd39b580e0f95b9bf7d39dec8fd3ada4abe41ad2ae1e18";
     };
     readonly alphanet: {
-        readonly executorAddress: "0x4651DfD7729aE5568092E7351fAaD872266d4CBd";
-        readonly eciesPublicKey: "0x02a95c1972adb4113edc7166a7acf4b4e3e81ae7d02179ab60ebeaa2d51660e6d8";
+        readonly executorAddress: "0x28676Cd3b10b03b2FDF105Ba280425b45a674F2A";
+        readonly eciesPublicKey: "0x034bc20c48ff1b8e86563dff8dd2ec3936bdea0ab570986780971cdc4c3871fe09";
         readonly chainId: 31337;
         readonly covalidatorUrl: "http://localhost:50055";
         readonly hostChainRpcUrl: "http://localhost:8545";
-        readonly senderPrivateKey: "0x1a62c795e7b0442a106dd8017a00af4461727b88df8834b2fca65558011f968a";
+        readonly senderPrivateKey: "0xa0b9f1fb7c6803e5692b73bd08ccc5c468b15eebe7df4398d048e9a58f785706";
     };
     readonly scratch: {
         readonly executorAddress: "0x195ec7fDf68fD835b9F78d6eb13E280cC2e25fdD";

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.0",
+  "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",