@inco/js 0.6.0 → 0.6.8

package/dist/esm/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/dist/types/binary.d.ts

@@ -5,6 +5,7 @@ export type HexString = typeof HexString.Type;
 export type BytesIsh = string | Uint8Array;
 export declare function bytesToBigInt(byteArray: Uint8Array): bigint;
 export declare function bufferToBigInt(buffer: Buffer): bigint;
+export declare function bigintToBytes(value: bigint): Buffer;
 export declare function bigintToBytes32(value: bigint): Bytes32;
 export declare function padLeft(bs: Uint8Array, n: number): Buffer;
 export declare function bytes32ToBigint(bs: BytesIsh): bigint;

package/dist/types/encryption/encryption.d.ts

@@ -1,8 +1,8 @@
 import { Schema } from 'effect';
+import { ByteArray, Hex } from 'viem';
 import { Bytes32 } from '../binary.js';
-import { InputContext } from '../handle.js';
 export type Encryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedFheType>(plaintext: PlaintextWithContextOf<S, T>) => Promise<EncryptResultOf<S, T>>;
-export type Decryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedFheType>(ciphertext: CiphertextOf<S, T>, context?: InputContext) => Promise<PlaintextOf<S, T>>;
+export type Decryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedFheType>(ciphertext: CiphertextOf<S, T>) => Promise<PlaintextOf<S, T>>;
 export declare const supportedFheTypes: {
     readonly euint64: 5;
     readonly euint160: 7;
@@ -16,38 +16,29 @@ export type SupportedFheType = typeof SupportedFheType.Type;
 export declare const encryptionSchemes: {
     readonly tfhe: 0;
     readonly ecies: 1;
-    readonly cryptobox: 2;
 };
 export declare function getEncryptionSchemeName(scheme: number): string;
 export type EncryptionSchemes = typeof encryptionSchemes;
 export type EciesScheme = EncryptionSchemes['ecies'];
 export type TfheScheme = EncryptionSchemes['tfhe'];
-export type CryptoboxScheme = EncryptionSchemes['cryptobox'];
-export declare const EncryptionScheme: Schema.Literal<[0, 1, 2]>;
+export declare const EncryptionScheme: Schema.Literal<[0, 1]>;
 export type EncryptionScheme = typeof EncryptionScheme.Type;
 type DistType<P, S extends EncryptionScheme, T extends SupportedFheType> = P extends any ? P & {
     scheme: S;
     type: T;
 } : never;
-export declare const ciphertextEnvelopes: {
-    readonly none: 0;
-    readonly hadu: 1;
-};
-export declare const CiphertextEnvelope: Schema.SchemaClass<0 | 1, 0 | 1, never>;
 export declare const Ciphertext: Schema.Struct<{
-    scheme: Schema.Literal<[0, 1, 2]>;
+    scheme: Schema.Literal<[0, 1]>;
     type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
     value: Schema.TemplateLiteral<`0x${string}`>;
-    envelope: Schema.optional<Schema.SchemaClass<0 | 1, 0 | 1, never>>;
 }>;
 export type Ciphertext = typeof Ciphertext.Type;
 export type CiphertextOf<S extends EncryptionScheme, T extends SupportedFheType> = DistType<Ciphertext, S, T>;
 export declare const CiphertextWithContext: Schema.Struct<{
     ciphertext: Schema.Struct<{
-        scheme: Schema.Literal<[0, 1, 2]>;
+        scheme: Schema.Literal<[0, 1]>;
         type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
         value: Schema.TemplateLiteral<`0x${string}`>;
-        envelope: Schema.optional<Schema.SchemaClass<0 | 1, 0 | 1, never>>;
     }>;
     context: Schema.Struct<{
         hostChainId: typeof Schema.BigInt;
@@ -62,10 +53,9 @@ export type CiphertextWithContextOf<S extends EncryptionScheme, T extends Suppor
 };
 export declare const EncryptResult: Schema.Struct<{
     ciphertext: Schema.Struct<{
-        scheme: Schema.Literal<[0, 1, 2]>;
+        scheme: Schema.Literal<[0, 1]>;
         type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
         value: Schema.TemplateLiteral<`0x${string}`>;
-        envelope: Schema.optional<Schema.SchemaClass<0 | 1, 0 | 1, never>>;
     }>;
     context: Schema.Struct<{
         hostChainId: typeof Schema.BigInt;
@@ -81,11 +71,11 @@ export type EncryptResultOf<S extends EncryptionScheme, T extends SupportedFheTy
     ciphertext: CiphertextOf<S, T>;
 };
 export declare const Plaintext: Schema.Union<[Schema.Struct<{
-    scheme: Schema.Literal<[0, 1, 2]>;
+    scheme: Schema.Literal<[0, 1]>;
     type: Schema.Literal<[5, 7, 8]>;
     value: typeof Schema.BigInt;
 }>, Schema.Struct<{
-    scheme: Schema.Literal<[0, 1, 2]>;
+    scheme: Schema.Literal<[0, 1]>;
     type: Schema.Literal<[0]>;
     value: typeof Schema.Boolean;
 }>]>;
@@ -93,11 +83,11 @@ export type Plaintext = typeof Plaintext.Type;
 export type PlaintextOf<S extends EncryptionScheme, T extends SupportedFheType> = DistType<Plaintext, S, T>;
 export declare const PlaintextWithContext: Schema.Struct<{
     plaintext: Schema.Union<[Schema.Struct<{
-        scheme: Schema.Literal<[0, 1, 2]>;
+        scheme: Schema.Literal<[0, 1]>;
         type: Schema.Literal<[5, 7, 8]>;
         value: typeof Schema.BigInt;
     }>, Schema.Struct<{
-        scheme: Schema.Literal<[0, 1, 2]>;
+        scheme: Schema.Literal<[0, 1]>;
         type: Schema.Literal<[0]>;
         value: typeof Schema.Boolean;
     }>]>;
@@ -113,7 +103,14 @@ export type PlaintextWithContextOf<S extends EncryptionScheme, T extends Support
     plaintext: PlaintextOf<S, T>;
 };
 export declare function bigintToPlaintext<S extends EncryptionScheme, T extends SupportedFheType>(scheme: S, type: T, bigPt: bigint): PlaintextOf<S, T>;
+export declare function decodeCiphertextInput(input: ByteArray | Hex): {
+    handle: Hex;
+    ciphertext: Hex;
+};
+export declare function encodeCiphertextInput(handle: Hex, ciphertext: Hex): Hex;
 export declare function plaintextToBigint(plaintext: Plaintext): bigint;
 export declare function plaintextToBytes32(plaintext: Plaintext): Bytes32;
+export declare function plaintextToBytes(plaintext: Plaintext): Buffer;
 export declare function bytes32ToPlaintext(plaintext: Bytes32, scheme: EncryptionScheme, type: SupportedFheType): Plaintext;
+export declare function bytesToPlaintext(plaintext: Uint8Array, scheme: EncryptionScheme, type: SupportedFheType): Plaintext;
 export {};

package/dist/types/generated/abis/lightning-preview.d.ts

@@ -813,28 +813,12 @@ export declare const iIncoLightningPreviewAbi: readonly [{
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "ciphertext";
-        readonly internalType: "bytes";
-        readonly type: "bytes";
-    }, {
-        readonly name: "user";
-        readonly internalType: "address";
-        readonly type: "address";
-    }, {
-        readonly name: "contractAddress";
-        readonly internalType: "address";
-        readonly type: "address";
-    }, {
-        readonly name: "inputType";
-        readonly internalType: "enum ETypes";
-        readonly type: "uint8";
-    }];
-    readonly name: "getInputHandle";
+    readonly inputs: readonly [];
+    readonly name: "getMajorVersion";
     readonly outputs: readonly [{
-        readonly name: "generatedHandle";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
+        readonly name: "";
+        readonly internalType: "string";
+        readonly type: "string";
     }];
     readonly stateMutability: "view";
 }, {
@@ -858,91 +842,9 @@ export declare const iIncoLightningPreviewAbi: readonly [{
         readonly internalType: "enum ETypes";
         readonly type: "uint8";
     }, {
-        readonly name: "value";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly name: "getOpResultHandle";
-    readonly outputs: readonly [{
-        readonly name: "generatedHandle";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly stateMutability: "pure";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "op";
-        readonly internalType: "enum EOps";
-        readonly type: "uint8";
-    }, {
-        readonly name: "returnType";
-        readonly internalType: "enum ETypes";
-        readonly type: "uint8";
-    }, {
-        readonly name: "inputA";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "inputB";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "inputC";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly name: "getOpResultHandle";
-    readonly outputs: readonly [{
-        readonly name: "generatedHandle";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly stateMutability: "pure";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "op";
-        readonly internalType: "enum EOps";
-        readonly type: "uint8";
-    }, {
-        readonly name: "returnType";
-        readonly internalType: "enum ETypes";
-        readonly type: "uint8";
-    }, {
-        readonly name: "counter";
-        readonly internalType: "uint256";
-        readonly type: "uint256";
-    }, {
-        readonly name: "upperBound";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly name: "getOpResultHandle";
-    readonly outputs: readonly [{
-        readonly name: "generatedHandle";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }];
-    readonly stateMutability: "pure";
-}, {
-    readonly type: "function";
-    readonly inputs: readonly [{
-        readonly name: "op";
-        readonly internalType: "enum EOps";
-        readonly type: "uint8";
-    }, {
-        readonly name: "returnType";
-        readonly internalType: "enum ETypes";
-        readonly type: "uint8";
-    }, {
-        readonly name: "lhs";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "rhs";
-        readonly internalType: "bytes32";
-        readonly type: "bytes32";
+        readonly name: "packedInputs";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
     }];
     readonly name: "getOpResultHandle";
     readonly outputs: readonly [{