@inco/js 0.6.1 → 0.6.9

package/dist/esm/viem.d.ts

@@ -30,7 +30,7 @@ export declare const chains: {
         experimental_preconfirmationTime?: number | undefined | undefined;
         rpcUrls: {
             readonly default: {
-                readonly http: readonly ["https://sepolia.drpc.org"];
+                readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
             };
         };
         sourceId?: number | undefined | undefined;
@@ -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/advancedacl/session-key.d.ts

@@ -29,6 +29,11 @@ export interface SessionKeyReencryptorArgs {
     kmsConnectRpcEndpointOrClient: string | Client<typeof KmsService>;
     allowanceVoucherWithSig: AllowanceVoucherWithSig;
 }
+/**
+ * The sessionKeyReencryptor function is a reencryptor that uses a session key
+ * to reencrypt data.
+ *
+ */
 export declare function sessionKeyReencryptor({ chainId, kmsConnectRpcEndpointOrClient, ephemeralKeypair, allowanceVoucherWithSig, }: SessionKeyReencryptorArgs): Promise<(<T extends SupportedFheType>({ handle, }: ReencryptFnArgs<EciesScheme, T>) => Promise<import("../encryption/encryption.js").PlaintextOf<1, 0 | 5 | 7 | 8>>)>;
 export declare function updateActiveVouchersSessionNonce(incoLiteAddress: Address, sharerWalletClient: WalletClient<Transport, Chain, Account>): Promise<`0x${string}`>;
 export interface SessionKeyAttestedComputeArgs {
@@ -53,5 +58,7 @@ export interface SessionKeyAttestedDecryptArgs {
     allowanceVoucherWithSig: AllowanceVoucherWithSig;
     handles: HexString[];
     backoffConfig?: Partial<BackoffConfig> | undefined;
+    reencryptPubKey?: Uint8Array;
+    reencryptKeypair?: Secp256k1Keypair;
 }
-export declare function sessionKeyAttestedDecrypt({ chainId, kmsConnectRpcEndpointOrClient, handles, ephemeralKeypair, allowanceVoucherWithSig, backoffConfig, }: SessionKeyAttestedDecryptArgs): Promise<Array<DecryptionAttestation<EciesScheme, SupportedFheType>>>;
+export declare function sessionKeyAttestedDecrypt({ chainId, kmsConnectRpcEndpointOrClient, handles, ephemeralKeypair, allowanceVoucherWithSig, backoffConfig, reencryptPubKey, reencryptKeypair, }: SessionKeyAttestedDecryptArgs): Promise<Array<DecryptionAttestation<EciesScheme, SupportedFheType>>>;

package/dist/types/attesteddecrypt/attested-decrypt.d.ts

@@ -3,8 +3,9 @@ import { HexString } from '../binary.js';
 import { SupportedChainId } from '../chain.js';
 import { EciesScheme, SupportedFheType } from '../encryption/encryption.js';
 import type { KmsClient } from '../kms/client.js';
+import { Secp256k1Keypair } from '../lite/ecies.js';
 import type { BackoffConfig } from '../retry.js';
-import { DecryptionAttestation } from './types.js';
+import { DecryptionAttestation, EncryptedDecryptionAttestation } from './types.js';
 export declare const ATTESTED_DECRYPT_DOMAIN_NAME = "IncoAttestedDecrypt";
 export declare const ATTESTED_DECRYPT_DOMAIN_VERSION = "0.1.0";
 /**
@@ -24,6 +25,40 @@ export interface IncoLiteAttestedDecryptorArgs {
     /** The chain ID to use */
     chainId: SupportedChainId;
 }
+/**
+ * Decrypt multiple handles in a single attested request.
+ * Returns an array of attestations aligned with the response ordering.
+ *
+ * @param args - The arguments for creating the attested decrypt function
+ * @returns A function that can decrypt handles and return an attestation
+ * @throws {AttestedDecryptError} If the creation fails
+ */
+export declare function attestedDecrypt({ handles, backoffConfig, walletClient, chainId, reencryptPubKey, reencryptKeypair, kmsConnectRpcEndpointOrClient, }: {
+    handles: HexString[];
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    chainId: SupportedChainId;
+    reencryptPubKey: Uint8Array;
+    reencryptKeypair: Secp256k1Keypair;
+    kmsConnectRpcEndpointOrClient?: string | KmsClient;
+}): Promise<Array<DecryptionAttestation<EciesScheme, SupportedFheType>>>;
+/**
+ * Decrypt multiple handles in a single attested request.
+ * Returns an array of attestations aligned with the response ordering.
+ *
+ * @param args - The arguments for creating the attested decrypt function
+ * @returns A function that can decrypt handles and return an attestation
+ * @throws {AttestedDecryptError} If the creation fails
+ */
+export declare function attestedDecrypt({ handles, backoffConfig, walletClient, chainId, reencryptPubKey, kmsConnectRpcEndpointOrClient, }: {
+    handles: HexString[];
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    chainId: SupportedChainId;
+    reencryptPubKey: Uint8Array;
+    reencryptKeypair?: never;
+    kmsConnectRpcEndpointOrClient?: string | KmsClient;
+}): Promise<Array<EncryptedDecryptionAttestation<EciesScheme, SupportedFheType>>>;
 /**
  * Decrypt multiple handles in a single attested request.
  * Returns an array of attestations aligned with the response ordering.
@@ -37,5 +72,7 @@ export declare function attestedDecrypt({ handles, backoffConfig, walletClient,
     backoffConfig?: Partial<BackoffConfig> | undefined;
     walletClient: WalletClient<Transport, Chain, Account>;
     chainId: SupportedChainId;
+    reencryptPubKey?: never;
+    reencryptKeypair?: never;
     kmsConnectRpcEndpointOrClient?: string | KmsClient;
 }): Promise<Array<DecryptionAttestation<EciesScheme, SupportedFheType>>>;

package/dist/types/attesteddecrypt/types.d.ts

@@ -1,5 +1,5 @@
 import { HexString } from '../binary.js';
-import { EncryptionScheme, PlaintextOf, SupportedFheType } from '../encryption/encryption.js';
+import { EncryptionScheme, EncryptResultOf, PlaintextOf, SupportedFheType } from '../encryption/encryption.js';
 import type { BackoffConfig } from '../retry.js';
 /**
  * Custom error class for attested decrypt operations.
@@ -13,6 +13,11 @@ export type DecryptionAttestation<S extends EncryptionScheme, T extends Supporte
     plaintext: PlaintextOf<S, T>;
     covalidatorSignature: Uint8Array;
 };
+export type EncryptedDecryptionAttestation<S extends EncryptionScheme, T extends SupportedFheType> = {
+    handle: HexString;
+    encryptedPlaintext: EncryptResultOf<S, T>;
+    covalidatorSignature: Uint8Array;
+};
 export type AttestedDecryptor<S extends EncryptionScheme> = <T extends SupportedFheType>(args: AttestedDecryptFnArgs<S, T>) => Promise<DecryptionAttestation<S, T>>;
 export type AttestedDecryptFnArgs<S extends EncryptionScheme, T extends SupportedFheType> = {
     /** The handle to decrypt */

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;
@@ -14,40 +14,29 @@ export type SupportedFheTypeName = typeof SupportedFheTypeName.Type;
 export declare const SupportedFheType: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
 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<[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<[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<[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 +51,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<[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 +69,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<[1]>;
     type: Schema.Literal<[5, 7, 8]>;
     value: typeof Schema.BigInt;
 }>, Schema.Struct<{
-    scheme: Schema.Literal<[0, 1, 2]>;
+    scheme: Schema.Literal<[1]>;
     type: Schema.Literal<[0]>;
     value: typeof Schema.Boolean;
 }>]>;
@@ -93,11 +81,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<[1]>;
         type: Schema.Literal<[5, 7, 8]>;
         value: typeof Schema.BigInt;
     }>, Schema.Struct<{
-        scheme: Schema.Literal<[0, 1, 2]>;
+        scheme: Schema.Literal<[1]>;
         type: Schema.Literal<[0]>;
         value: typeof Schema.Boolean;
     }>]>;
@@ -113,7 +101,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/add-two.d.ts

@@ -44,7 +44,7 @@ export declare const addTwoAbi: readonly [{
         readonly internalType: "bytes";
         readonly type: "bytes";
     }];
-    readonly name: "addTwoEOA";
+    readonly name: "addTwoEoa";
     readonly outputs: readonly [{
         readonly name: "result";
         readonly internalType: "euint256";