@inco/js 0.2.17 → 0.3.0

package/dist/types/generated/ts/inco/preflight/v1/tx.d.ts

@@ -1,5 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import { type CallOptions, ChannelCredentials, Client, type ClientOptions, type ClientUnaryCall, type handleUnaryCall, Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+import { type CallOptions, type ChannelCredentials, Client, type ClientOptions, type ClientUnaryCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
 import { InputContext, Params } from "./types";
 export declare const protobufPackage = "inco.preflight.v1";
 /** MsgRegisterInput the Msg/RegisterInput request type. */
@@ -86,9 +86,9 @@ export declare const MsgService: {
         readonly path: "/inco.preflight.v1.Msg/RegisterInput";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: MsgRegisterInput) => Buffer<ArrayBuffer>;
+        readonly requestSerialize: (value: MsgRegisterInput) => Buffer;
         readonly requestDeserialize: (value: Buffer) => MsgRegisterInput;
-        readonly responseSerialize: (value: MsgRegisterInputResponse) => Buffer<ArrayBuffer>;
+        readonly responseSerialize: (value: MsgRegisterInputResponse) => Buffer;
         readonly responseDeserialize: (value: Buffer) => MsgRegisterInputResponse;
     };
     /**
@@ -99,9 +99,9 @@ export declare const MsgService: {
         readonly path: "/inco.preflight.v1.Msg/RegisterFallback";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: MsgRegisterFallback) => Buffer<ArrayBuffer>;
+        readonly requestSerialize: (value: MsgRegisterFallback) => Buffer;
         readonly requestDeserialize: (value: Buffer) => MsgRegisterFallback;
-        readonly responseSerialize: (value: MsgRegisterFallbackResponse) => Buffer<ArrayBuffer>;
+        readonly responseSerialize: (value: MsgRegisterFallbackResponse) => Buffer;
         readonly responseDeserialize: (value: Buffer) => MsgRegisterFallbackResponse;
     };
     /**
@@ -113,9 +113,9 @@ export declare const MsgService: {
         readonly path: "/inco.preflight.v1.Msg/UpdateParams";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: MsgUpdateParams) => Buffer<ArrayBuffer>;
+        readonly requestSerialize: (value: MsgUpdateParams) => Buffer;
         readonly requestDeserialize: (value: Buffer) => MsgUpdateParams;
-        readonly responseSerialize: (value: MsgUpdateParamsResponse) => Buffer<ArrayBuffer>;
+        readonly responseSerialize: (value: MsgUpdateParamsResponse) => Buffer;
         readonly responseDeserialize: (value: Buffer) => MsgUpdateParamsResponse;
     };
 };

package/dist/types/lite/attested-compute.d.ts

@@ -0,0 +1,4 @@
+import { type IncoLiteAttestedComputeArgs, incoLiteAttestedCompute } from '../attestedcompute/attested-compute.js';
+import { type AttestedComputeSupportedOps } from '../attestedcompute/types.js';
+export { incoLiteAttestedCompute };
+export type { AttestedComputeSupportedOps, IncoLiteAttestedComputeArgs };

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

@@ -12,7 +12,7 @@ export type DeploymentByName = DistributedPick<Deployment, 'name' | 'chainId'>;
 export type DeploymentByExecutor = DistributedPick<Deployment, 'executorAddress' | 'chainId'>;
 export type DeploymentId = DeploymentByName | DeploymentByExecutor;
 export type Pepper = Deployment['pepper'];
-export type LocalNodePepper = Pepper & keyof typeof localNodeLightningConfig;
+export type LocalNodePepper = keyof typeof localNodeLightningConfig;
 export type ChainId = Deployment['chainId'];
 export type SupportedNativeType = boolean | bigint | number;
 export type EncryptionContext = {
@@ -29,8 +29,10 @@ export type CustomConfig = {
     eciesPublicKey: string;
     chainId: number;
     covalidatorUrl: string;
+    hostChainRpcUrl?: string;
     senderPrivateKey?: HexString;
 };
+export type CustomDeployment = DeploymentSlice & CustomConfig;
 /**
  * The Lightning class provides a convenient way to interact with the Inco Lightning contract by binding to a specific
  * deployment.
@@ -64,7 +66,13 @@ export declare class Lightning<T extends DeploymentSlice = DeploymentSlice> {
      * corresponding Pepper.
      *
      */
-    static localNode(env?: LocalNodeEnv | LocalNodePepper): Lightning<DeploymentSlice & CustomConfig>;
+    static localNode(env?: LocalNodeEnv | LocalNodePepper): Lightning<CustomDeployment>;
+    /**
+     * Get a Lightning instance bound to a local node from a file containing a LocalNodeEnv environment .
+     *
+     * @param filePath the path to the file containing the environment variables in dotenv format
+     */
+    static localNodeFromEnv(filePath?: string): Promise<Lightning<CustomDeployment>>;
     /**
      * Get a Lightning deployment by name or executor address on a particular chain.
      *

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

@@ -14,6 +14,9 @@ export declare const LocalNodeEnv: Schema.Struct<{
     COVALIDATOR_ACL_ADDR: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
     COVALIDATOR_INCO_EXECUTOR_ADDR: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
     COVALIDATOR_DECRYPTION_HANDLER_ADDR: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
+    COVALIDATOR_HOST_CHAIN_ID: Schema.optional<typeof Schema.String>;
+    COVALIDATOR_GRPC_SERVER_ADDRESS: Schema.optional<typeof Schema.String>;
+    COVALIDATOR_HOST_CHAIN_RPC_URL: Schema.optional<typeof Schema.String>;
 }>;
 export type LocalNodeEnv = typeof LocalNodeEnv.Type;
-export declare function parseLocalEnv(envFileContents: string | Buffer): LocalNodeEnv;
+export declare function parseLocalEnv(envFileOrObj?: string | Buffer): LocalNodeEnv;

package/dist/types/viem.d.ts

@@ -8,6 +8,7 @@ export declare const chains: {
                 readonly apiUrl: "https://api-sepolia.etherscan.io/api";
             };
         };
+        blockTime?: number | undefined | undefined;
         contracts: {
             readonly multicall3: {
                 readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
@@ -21,6 +22,7 @@ export declare const chains: {
                 readonly blockCreated: 5317080;
             };
         };
+        ensTlds?: readonly string[] | undefined;
         id: 11155111;
         name: "Sepolia";
         nativeCurrency: {
@@ -28,6 +30,7 @@ export declare const chains: {
             readonly symbol: "ETH";
             readonly decimals: 18;
         };
+        experimental_preconfirmationTime?: number | undefined | undefined;
         rpcUrls: {
             readonly default: {
                 readonly http: readonly ["https://sepolia.drpc.org"];
@@ -48,6 +51,7 @@ export declare const chains: {
                 readonly apiUrl: "https://api-sepolia.basescan.org/api";
             };
         };
+        blockTime: 2000;
         contracts: {
             readonly disputeGameFactory: {
                 readonly 11155111: {
@@ -94,6 +98,7 @@ export declare const chains: {
                 readonly address: "0x4200000000000000000000000000000000000016";
             };
         };
+        ensTlds?: readonly string[] | undefined;
         id: 84532;
         name: "Base Sepolia";
         nativeCurrency: {
@@ -101,6 +106,7 @@ export declare const chains: {
             readonly symbol: "ETH";
             readonly decimals: 18;
         };
+        experimental_preconfirmationTime?: number | undefined | undefined;
         rpcUrls: {
             readonly default: {
                 readonly http: readonly ["https://sepolia.base.org"];
@@ -353,12 +359,14 @@ export declare const chains: {
                 readonly url: "https://testnet.monadexplorer.com";
             };
         };
+        blockTime?: number | undefined | undefined;
         contracts: {
             readonly multicall3: {
                 readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
                 readonly blockCreated: 251449;
             };
         };
+        ensTlds?: readonly string[] | undefined;
         id: 10143;
         name: "Monad Testnet";
         nativeCurrency: {
@@ -366,6 +374,7 @@ export declare const chains: {
             readonly symbol: "MON";
             readonly decimals: 18;
         };
+        experimental_preconfirmationTime?: number | undefined | undefined;
         rpcUrls: {
             readonly default: {
                 readonly http: readonly ["https://testnet-rpc.monad.xyz"];
@@ -378,6 +387,44 @@ export declare const chains: {
         formatters?: undefined;
         serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
     };
+    plasmaTestnet: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "RouteScan";
+                readonly url: "https://testnet.plasmaexplorer.io";
+            };
+        };
+        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;
+            universalSignatureVerifier?: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensTlds?: readonly string[] | undefined;
+        id: 9746;
+        name: "Plasma Testnet";
+        nativeCurrency: {
+            readonly name: "Testnet Plasma";
+            readonly symbol: "XPL";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://testnet-rpc.plasma.to"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    };
     anvil: {
         blockExplorers?: {
             [key: string]: {
@@ -391,6 +438,7 @@ export declare const chains: {
                 apiUrl?: string | undefined;
             };
         } | undefined | undefined;
+        blockTime?: number | undefined | undefined;
         contracts?: {
             [x: string]: import("viem").ChainContract | {
                 [sourceId: number]: import("viem").ChainContract | undefined;
@@ -400,6 +448,7 @@ export declare const chains: {
             multicall3?: import("viem").ChainContract | undefined;
             universalSignatureVerifier?: import("viem").ChainContract | undefined;
         } | undefined;
+        ensTlds?: readonly string[] | undefined;
         id: 31337;
         name: "Anvil";
         nativeCurrency: {
@@ -407,6 +456,7 @@ export declare const chains: {
             readonly name: "Ether";
             readonly symbol: "ETH";
         };
+        experimental_preconfirmationTime?: number | undefined | undefined;
         rpcUrls: {
             readonly default: {
                 readonly http: readonly ["http://127.0.0.1:8545"];
@@ -420,6 +470,318 @@ export declare const chains: {
         formatters?: undefined;
         serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
     };
+    worldchainSepolia: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Worldscan Sepolia";
+                readonly url: "https://sepolia.worldscan.org";
+                readonly apiUrl: "https://api-sepolia.worldscan.org/api";
+            };
+            readonly blockscout: {
+                readonly name: "Blockscout";
+                readonly url: "https://worldchain-sepolia.explorer.alchemy.com";
+                readonly apiUrl: "https://worldchain-sepolia.explorer.alchemy.com/api";
+            };
+        };
+        blockTime: 2000;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 0;
+            };
+            readonly disputeGameFactory: {
+                readonly 11155111: {
+                    readonly address: "0x8Ec1111f67Dad6b6A93B3F42DfBC92D81c98449A";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 11155111: {
+                    readonly address: "0xc8886f8BAb6Eaeb215aDB5f1c686BF699248300e";
+                };
+            };
+            readonly portal: {
+                readonly 11155111: {
+                    readonly address: "0xFf6EBa109271fe6d4237EeeD4bAb1dD9A77dD1A4";
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 11155111: {
+                    readonly address: "0xd7DF54b3989855eb66497301a4aAEc33Dbb3F8DE";
+                };
+            };
+            readonly gasPriceOracle: {
+                readonly address: "0x420000000000000000000000000000000000000F";
+            };
+            readonly l1Block: {
+                readonly address: "0x4200000000000000000000000000000000000015";
+            };
+            readonly l2CrossDomainMessenger: {
+                readonly address: "0x4200000000000000000000000000000000000007";
+            };
+            readonly l2Erc721Bridge: {
+                readonly address: "0x4200000000000000000000000000000000000014";
+            };
+            readonly l2StandardBridge: {
+                readonly address: "0x4200000000000000000000000000000000000010";
+            };
+            readonly l2ToL1MessagePasser: {
+                readonly address: "0x4200000000000000000000000000000000000016";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 4801;
+        name: "World Chain Sepolia";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://worldchain-sepolia.g.alchemy.com/public"];
+            };
+        };
+        sourceId: 11155111;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters: {
+            readonly block: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcBlock) => {
+                    baseFeePerGas: bigint | null;
+                    blobGasUsed: bigint;
+                    difficulty: bigint;
+                    excessBlobGas: bigint;
+                    extraData: import("viem").Hex;
+                    gasLimit: bigint;
+                    gasUsed: bigint;
+                    hash: `0x${string}` | null;
+                    logsBloom: `0x${string}` | null;
+                    miner: import("abitype").Address;
+                    mixHash: import("viem").Hash;
+                    nonce: `0x${string}` | null;
+                    number: bigint | null;
+                    parentBeaconBlockRoot?: `0x${string}` | undefined;
+                    parentHash: import("viem").Hash;
+                    receiptsRoot: import("viem").Hex;
+                    sealFields: import("viem").Hex[];
+                    sha3Uncles: import("viem").Hash;
+                    size: bigint;
+                    stateRoot: import("viem").Hash;
+                    timestamp: bigint;
+                    totalDifficulty: bigint | null;
+                    transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
+                    transactionsRoot: import("viem").Hash;
+                    uncles: import("viem").Hash[];
+                    withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
+                    withdrawalsRoot?: `0x${string}` | undefined;
+                } & {};
+                type: "block";
+            };
+            readonly transaction: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcTransaction) => ({
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").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;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: boolean;
+                    mint?: bigint | undefined | undefined;
+                    sourceHash: import("viem").Hex;
+                    type: "deposit";
+                } | {
+                    r: import("viem").Hex;
+                    s: import("viem").Hex;
+                    v: bigint;
+                    to: import("abitype").Address | null;
+                    from: import("abitype").Address;
+                    gas: bigint;
+                    nonce: number;
+                    value: bigint;
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    hash: import("viem").Hash;
+                    input: import("viem").Hex;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    accessList?: undefined | undefined;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId?: number | undefined;
+                    yParity?: undefined | undefined;
+                    type: "legacy";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").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;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip2930";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").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;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip1559";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").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;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes: readonly import("viem").Hex[];
+                    chainId: number;
+                    type: "eip4844";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas: bigint;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: import("abitype").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;
+                    transactionIndex: number | null;
+                    typeHex: import("viem").Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: import("viem").AccessList;
+                    authorizationList: import("viem").SignedAuthorizationList;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip7702";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                }) & {};
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: import("viem/chains").OpStackRpcTransactionReceipt) => {
+                    blobGasPrice?: bigint | undefined;
+                    blobGasUsed?: bigint | undefined;
+                    blockHash: import("viem").Hash;
+                    blockNumber: bigint;
+                    contractAddress: import("abitype").Address | null | undefined;
+                    cumulativeGasUsed: bigint;
+                    effectiveGasPrice: bigint;
+                    from: import("abitype").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;
+                    transactionHash: import("viem").Hash;
+                    transactionIndex: number;
+                    type: import("viem").TransactionType;
+                    l1GasPrice: bigint | null;
+                    l1GasUsed: bigint | null;
+                    l1Fee: bigint | null;
+                    l1FeeScalar: number | null;
+                } & {};
+                type: "transactionReceipt";
+            };
+        };
+        serializers: {
+            readonly transaction: typeof import("viem/chains").serializeTransactionOpStack;
+        };
+        readonly network: "worldchain-sepolia";
+    };
 };
 type ChainName = keyof typeof chains;
 export type ViemChain = (typeof chains)[ChainName];

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@inco/js",
-  "version": "0.2.17",
+  "version": "0.3.0",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "sideEffects": false,
   "scripts": {
     "test": "bun run lint && bun run test:tsc && bun run test:unit",
     "test:tsc": "tsc --noEmit",
     "test:unit": "bun vitest run --project unit",
+    "test:coverage": "bun vitest run --project unit --coverage",
     "test:update-snapshots": "bun vitest run --project unit --update",
     "test:e2e": "bun vitest run --project e2e",
     "lint": "bun prettier --check . && eslint .",
@@ -111,8 +112,10 @@
     "@pulumi/command": "^0.0.1-testwindows.signing",
     "@types/dedent": "^0.7.2",
     "@typescript-eslint/parser": "^8.35.1",
+    "@vitest/coverage-istanbul": "3.1.1",
     "bun-plugin-dts": "^0.3.0",
     "dedent": "^1.6.0",
+    "@dotenvx/dotenvx": "^1.48.4",
     "eslint": "^9.30.1",
     "node-tfhe": "^0.10.0",
     "node-tkms": "^0.9.0",

package/dist/cjs/generated/abis/index.d.ts

@@ -1,2 +0,0 @@
-export * from './lightning';
-export * from './addTwo';

package/dist/cjs/generated/abis/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lightning"), exports);
-__exportStar(require("./addTwo"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2FiaXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhDQUEyQjtBQUMzQiwyQ0FBd0IifQ==