@cofhe/hardhat-plugin 0.0.0-alpha-20260409113701

package/dist/index.d.ts

@@ -0,0 +1,229 @@
+import { PublicClient, WalletClient } from 'viem';
+import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers';
+import { CofheInputConfig, CofheConfig, CofheClient } from '@cofhe/sdk';
+import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { MockArtifact, MockTaskManager, MockACL, MockThresholdNetwork, MockZkVerifier, TestBed } from '@cofhe/mock-contracts';
+import * as ethers from 'ethers';
+import { Contract, ethers as ethers$1 } from 'ethers';
+import { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider';
+
+/**
+ * Controls deploy-mocks console output.
+ * - `''`   — silent, no output
+ * - `'v'`  — single summary line (default)
+ * - `'vv'` — full per-contract deployment logs
+ */
+type LogMocksDeploy = '' | 'v' | 'vv';
+type DeployMocksArgs = {
+    deployTestBed?: boolean;
+    gasWarning?: boolean;
+    mocksDeployVerbosity?: LogMocksDeploy;
+};
+declare const deployMocks: (hre: HardhatRuntimeEnvironment, options?: DeployMocksArgs) => Promise<void>;
+
+declare const TASK_COFHE_USE_FAUCET = "task:cofhe:usefaucet";
+declare const TASK_COFHE_MOCKS_SET_LOG_OPS = "task:cofhe-mocks:setlogops";
+declare const TASK_COFHE_MOCKS_DEPLOY = "task:cofhe-mocks:deploy";
+
+declare const deployMockContractFromArtifact: (hre: HardhatRuntimeEnvironment, artifact: MockArtifact) => Promise<Contract>;
+declare const getFixedMockContract: (hre: HardhatRuntimeEnvironment, artifact: MockArtifact) => Promise<Contract>;
+declare const mock_getPlaintext: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint | string) => Promise<any>;
+declare const mock_getPlaintextExists: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint | string) => Promise<any>;
+declare const mock_expectPlaintext: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint | string, expectedValue: bigint) => Promise<void>;
+
+/**
+ * Sends funds to the specified address
+ * @param hre Hardhat Runtime Environment
+ * @param toAddress Address to send funds to
+ * @param amount Amount to send in ETH (default: 10)
+ * @returns Transaction receipt or null if failed
+ */
+declare function localcofheFundAccount(hre: HardhatRuntimeEnvironment, toAddress: string, amount?: string): Promise<ethers.TransactionReceipt | null>;
+/**
+ * Checks a wallet's balance and funds it if below 1 ETH
+ * @param hre Hardhat Runtime Environment
+ * @param walletAddress Address of the wallet to check and potentially fund
+ * @returns Promise that resolves when the funding operation completes (if needed)
+ */
+declare function localcofheFundWalletIfNeeded(hre: HardhatRuntimeEnvironment, walletAddress: string): Promise<void>;
+
+declare const mock_setLoggingEnabled: (hre: HardhatRuntimeEnvironment, enabled: boolean, closureName?: string) => Promise<void>;
+declare const mock_withLogs: (hre: HardhatRuntimeEnvironment, closureName: string, closure: () => Promise<void>) => Promise<void>;
+
+/**
+ * Configuration interface for the CoFHE Hardhat plugin.
+ * Allows users to configure mock logging and gas warning settings.
+ */
+declare module 'hardhat/types/config' {
+    interface HardhatUserConfig {
+        cofhe?: {
+            /** Whether to log mock operations (default: true) */
+            logMocks?: boolean;
+            /** Whether to show gas usage warnings for mock operations (default: true) */
+            gasWarning?: boolean;
+            /**
+             * Controls deploy-mocks console output.
+             * - `''`   — silent, no output
+             * - `'v'`  — single summary line (default)
+             * - `'vv'` — full per-contract deployment logs
+             */
+            mocksDeployVerbosity?: LogMocksDeploy;
+        };
+    }
+    interface HardhatConfig {
+        cofhe: {
+            /** Whether to log mock operations (default: true) */
+            logMocks: boolean;
+            /** Whether to show gas usage warnings for mock operations (default: true) */
+            gasWarning: boolean;
+            mocksDeployVerbosity: LogMocksDeploy;
+        };
+    }
+}
+
+/**
+ * Runtime environment extensions for the CoFHE Hardhat plugin.
+ * Provides access to CoFHE initialization, environment checks, and mock utilities.
+ */
+declare module 'hardhat/types/runtime' {
+    interface HardhatRuntimeEnvironment {
+        cofhe: {
+            /**
+             * Create a CoFHE configuration for use with hre.cofhe.createClient(...)
+             * @param {CofheInputConfig} config - The CoFHE input configuration
+             * @returns {CofheConfig} The CoFHE configuration
+             */
+            createConfig: (config: CofheInputConfig) => Promise<CofheConfig>;
+            /**
+             * Create a CoFHE client instance
+             * @param {CofheConfig} config - The CoFHE configuration (use createCofheConfig to create with Node.js defaults)
+             * @returns {Promise<CofheClient>} The CoFHE client instance
+             */
+            createClient: (config: CofheConfig) => CofheClient;
+            /**
+             * Create viem clients from a Hardhat ethers signer, to be used with `cofheClient.connect(...)`
+             * @param {HardhatEthersSigner} signer - The Hardhat ethers signer to use
+             * @returns {Promise<{ publicClient: PublicClient; walletClient: WalletClient }>} The viem clients
+             */
+            hardhatSignerAdapter: (signer: HardhatEthersSigner) => Promise<{
+                publicClient: PublicClient;
+                walletClient: WalletClient;
+            }>;
+            /**
+             * Connect a CoFHE client with a Hardhat ethers signer
+             * @param {CofheClient} client - The CoFHE client to connect
+             * @param {HardhatEthersSigner} signer - The Hardhat ethers signer to use
+             * @returns {Promise<void>}
+             */
+            connectWithHardhatSigner: (client: CofheClient, signer: HardhatEthersSigner) => Promise<void>;
+            /**
+             * Create and connect to a batteries included client.
+             * Also generates a self-usage a permit for the signer.
+             * If customization is needed, use createCofheClient and connectWithHardhatSigner.
+             * @param {HardhatEthersSigner} signer - The Hardhat ethers signer to use (optional - defaults to first signer)
+             * @returns {Promise<CofheClient>} The CoFHE client instance
+             */
+            createClientWithBatteries: (signer?: HardhatEthersSigner) => Promise<CofheClient>;
+            mocks: {
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Execute a block of code with cofhe mock contracts logging enabled.
+                 *
+                 * _(If logging only a function, we recommend passing the function name as the closureName (ex "counter.increment()"))_
+                 *
+                 * Example usage:
+                 *
+                 * ```ts
+                 * await hre.cofhe.mocks.withLogs("counter.increment()", async () => {
+                 *   await counter.increment();
+                 * });
+                 * ```
+                 *
+                 * Expected output:
+                 * ```
+                 * ┌──────────────────┬──────────────────────────────────────────────────
+                 * │ [COFHE-MOCKS]    │ "counter.increment()" logs:
+                 * ├──────────────────┴──────────────────────────────────────────────────
+                 * ├ FHE.add          | euint32(4473..3424)[0] + euint32(1157..3648)[1]  =>  euint32(1106..1872)[1]
+                 * ├ FHE.allowThis    | euint32(1106..1872)[1] -> 0x663f..6602
+                 * ├ FHE.allow        | euint32(1106..1872)[1] -> 0x3c44..93bc
+                 * └─────────────────────────────────────────────────────────────────────
+                 * ```
+                 * @param {string} closureName - Name of the code block to log within
+                 * @param {() => Promise<void>} closure - The async function to execute
+                 */
+                withLogs: (closureName: string, closure: () => Promise<void>) => Promise<void>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Enable logging from cofhe mock contracts
+                 * @param {string} closureName - Optional name of the code block to enable logging for
+                 */
+                enableLogs: (closureName?: string) => Promise<void>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Disable logging from cofhe mock contracts
+                 */
+                disableLogs: () => Promise<void>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Deploy the cofhe mock contracts (normally this is done automatically)
+                 * @param {DeployMocksArgs} options - Deployment options
+                 */
+                deployMocks: (options?: DeployMocksArgs) => Promise<void>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Get the plaintext value for a ciphertext hash
+                 * @param {bigint | string} ctHash - The ciphertext hash to look up
+                 * @returns {Promise<bigint>} The plaintext value
+                 */
+                getPlaintext: (ctHash: bigint | string) => Promise<bigint>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Assert that a ciphertext hash represents an expected plaintext value
+                 * @param {bigint | string} ctHash - The ciphertext hash to check
+                 * @param {bigint} expectedValue - The expected plaintext value
+                 */
+                expectPlaintext: (ctHash: bigint | string, expectedValue: bigint) => Promise<void>;
+                /**
+                 * Get the MockTaskManager contract (typed via typechain)
+                 * @returns {Promise<MockTaskManager>} The MockTaskManager contract
+                 */
+                getMockTaskManager: () => Promise<MockTaskManager>;
+                /**
+                 * Get the MockACL contract (typed via typechain)
+                 * @returns {Promise<MockACL>} The MockACL contract
+                 */
+                getMockACL: () => Promise<MockACL>;
+                /**
+                 * Get the MockThresholdNetwork contract (typed via typechain)
+                 * @returns {Promise<MockThresholdNetwork>} The MockThresholdNetwork contract
+                 */
+                getMockThresholdNetwork: () => Promise<MockThresholdNetwork>;
+                /**
+                 * Get the MockZkVerifier contract (typed via typechain)
+                 * @returns {Promise<MockZkVerifier>} The MockZkVerifier contract
+                 */
+                getMockZkVerifier: () => Promise<MockZkVerifier>;
+                /**
+                 * Get the TestBed contract (typed via typechain)
+                 * @returns {Promise<TestBed>} The TestBed contract
+                 */
+                getTestBed: () => Promise<TestBed>;
+            };
+        };
+    }
+}
+/**
+ * Builds the mocks config for the hardhat plugin.
+ * Defaults `encryptDelay` to `0` so tests run without artificial wait times,
+ * unless the user has explicitly provided a value.
+ */
+declare function buildHardhatPluginMocksConfig(mocksConfig: CofheInputConfig['mocks']): NonNullable<CofheInputConfig['mocks']>;
+
+export { type DeployMocksArgs, type LogMocksDeploy, TASK_COFHE_MOCKS_DEPLOY, TASK_COFHE_MOCKS_SET_LOG_OPS, TASK_COFHE_USE_FAUCET, buildHardhatPluginMocksConfig, deployMockContractFromArtifact, deployMocks, getFixedMockContract, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };