@cofhe/mock-contracts 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @cofhe/mock-contracts Changelog
 
+## 0.6.0
+
+### Minor Changes
+
+- 566f126: Remove the legacy `TestBed` mock surface and stop auto-deploying `SimpleTest` through the Hardhat plugins. Core mock contracts still deploy automatically, while tests that need `SimpleTest` should deploy it explicitly from their own artifacts.
+
+  This also removes `TEST_BED_ADDRESS` and cleans up duplicate `SimpleTest` exports from `@cofhe/mock-contracts`.
+
+## 0.5.2
+
 ## 0.5.1
 
 ### Patch Changes

package/README.md

@@ -112,11 +112,11 @@ In `cofhe-mock-contracts` the symbolic execution is preserved. In the case of th
 
 During the execution of a mock FHE operation, say `FHE.add(euint8 ctHashA, euint8 ctHashB) -> euint8 ctHashC`, rather than being performed off-chain by the FHE computation engine, the input `ctHashes` are mapped to their plaintext value, and the operation performed as plaintext math on-chain. The result is inserted into the symbolic value position of `ctHashC`.
 
-### On-chain Decryption
+### Decryption for On-chain Use
 
-CoFHE coprocessor handles on-chain decryption requests asynchronously. Once the decryption is requested with `FHE.decrypt(...)` the decryption will be performed off-chain by CoFHE, and the result posted on-chain in the `PlaintextStorage` module of `TaskManager`. The decryption result can then checked using either `FHE.getDecryptResult(...)` or `FHE.getDecryptResultSafe(...)`.
+For tx-oriented decryption, the consumer calls the Threshold Network decrypt endpoint and receives the plaintext together with a signature binding that plaintext to the `ctHash`. Contracts can then use that signature with `FHE.publishDecryptResult(...)` or `FHE.verifyDecryptResult(...)`.
 
-When a mock decryption is requested, a random number between 1 and 10 is generated to determine how many seconds the mock decryption async duration. Though the decryption result is available immediately within the mock contracts, the async duration is added to mimic the off-chain decryption and posting time.
+When working with the mocks, the equivalent result is produced by the mock contracts. A random number between 1 and 10 is generated to simulate async delay, but the flow still resolves to the same kind of tx-ready decrypt result.
 
 ### ZkVerifying
 
@@ -131,11 +131,11 @@ The `MockZkVerifier` contract handles the on-chain storage of encrypted inputs.
 
 ### Off-chain Decryption / Sealing
 
-Off-chain decryption is performed by calling the `cofheClient.decryptHandle` function with a valid `ctHash` and a valid `permit` [todo link].
+For view-oriented decryption, use the SDK flow `cofheClient.decryptForView(...)` (also exposed as `decryptHandle(...)`) with a valid `ctHash`, the matching FHE type, and a valid `permit` when required.
 
-When interacting with CoFHE this request is routed to the Threshold Network, which will perform the decryption operation, ultimately returning a decrypted result.
+When interacting with CoFHE this request is routed to the Threshold Network, which returns the plaintext to the consumer for local use.
 
-When working with the mocks, the `cofheClient` will instead query the `MockThresholdNetwork` contract, which will verify the request `permit`, and return the decrypted result.
+When working with the mocks, the `cofheClient` instead queries the `MockThresholdNetwork` contract, which verifies the request `permit` and returns the decrypted result.
 
 ### Using Foundry
 
@@ -145,16 +145,18 @@ CoFheTest also exposes useful test methods such as
 
 - `assertHashValue(euint, uint)` - asserting an encrypted value is equal to an expected plaintext value
 - `createInEuint..(number, user)` - for creating encrypted inputs (8-256bits) for a given user
+- `createInEuint*_asHashPlusProof(number, user)` - for creating encrypted inputs in the hash plus proof format
 
-see `contracts/TestBed.sol` for the original contract
+Example:
 
 ```solidity
 import {Test} from "forge-std/Test.sol";
 import {CoFheTest} from "@fhenixprotocol/cofhe-contracts/FHE.sol";
+import {MyFheContract} from "./MyFheContract.sol";
 ...
-contract TestBed is Test, CoFheTest {
+contract MyFheContractExample is Test, CoFheTest {
 
-  TestBed private testbed;
+  MyFheContract private target;
 
   address private user = makeAddr("user");
 
@@ -162,19 +164,19 @@ contract TestBed is Test, CoFheTest {
     // optional ... enable verbose logging for fhe mocks
     // setLog(true);
 
-    testbed = new TestBed();
+    target = new MyFheContract();
   }
 
-  function testSetNumber() public {
+  function testSetValue() public {
     uint32 n = 10;
     InEuint32 memory number = createInEuint32(n, user);
 
     //must be the user who sends transaction
     //or else invalid permissions from fhe allow
     vm.prank(user);
-    testbed.setNumber(number);
+    target.setValue(number);
 
-    assertHashValue(testbed.eNumber(), n);
+    assertHashValue(target.getValue(), n);
   }
 }
 ```

package/dist/index.d.mts

@@ -2005,243 +2005,6 @@ declare const MockThresholdNetworkArtifact: {
     }];
 };
 
-declare const TestBedArtifact: {
-    readonly contractName: "TestBed";
-    readonly isFixed: true;
-    readonly fixedAddress: "0x0000000000000000000000000000000000005003";
-    readonly abi: readonly [{
-        readonly type: "function";
-        readonly name: "add";
-        readonly inputs: readonly [{
-            readonly name: "inNumber";
-            readonly type: "tuple";
-            readonly internalType: "struct InEuint32";
-            readonly components: readonly [{
-                readonly name: "ctHash";
-                readonly type: "uint256";
-                readonly internalType: "uint256";
-            }, {
-                readonly name: "securityZone";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "utype";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "signature";
-                readonly type: "bytes";
-                readonly internalType: "bytes";
-            }];
-        }];
-        readonly outputs: readonly [];
-        readonly stateMutability: "nonpayable";
-    }, {
-        readonly type: "function";
-        readonly name: "decrypt";
-        readonly inputs: readonly [];
-        readonly outputs: readonly [];
-        readonly stateMutability: "nonpayable";
-    }, {
-        readonly type: "function";
-        readonly name: "eNumber";
-        readonly inputs: readonly [];
-        readonly outputs: readonly [{
-            readonly name: "";
-            readonly type: "bytes32";
-            readonly internalType: "euint32";
-        }];
-        readonly stateMutability: "view";
-    }, {
-        readonly type: "function";
-        readonly name: "exists";
-        readonly inputs: readonly [];
-        readonly outputs: readonly [{
-            readonly name: "";
-            readonly type: "bool";
-            readonly internalType: "bool";
-        }];
-        readonly stateMutability: "pure";
-    }, {
-        readonly type: "function";
-        readonly name: "getDecryptResult";
-        readonly inputs: readonly [{
-            readonly name: "input1";
-            readonly type: "bytes32";
-            readonly internalType: "euint32";
-        }];
-        readonly outputs: readonly [{
-            readonly name: "";
-            readonly type: "uint32";
-            readonly internalType: "uint32";
-        }];
-        readonly stateMutability: "view";
-    }, {
-        readonly type: "function";
-        readonly name: "getDecryptResultSafe";
-        readonly inputs: readonly [{
-            readonly name: "input1";
-            readonly type: "bytes32";
-            readonly internalType: "euint32";
-        }];
-        readonly outputs: readonly [{
-            readonly name: "value";
-            readonly type: "uint32";
-            readonly internalType: "uint32";
-        }, {
-            readonly name: "decrypted";
-            readonly type: "bool";
-            readonly internalType: "bool";
-        }];
-        readonly stateMutability: "view";
-    }, {
-        readonly type: "function";
-        readonly name: "increment";
-        readonly inputs: readonly [];
-        readonly outputs: readonly [];
-        readonly stateMutability: "nonpayable";
-    }, {
-        readonly type: "function";
-        readonly name: "mul";
-        readonly inputs: readonly [{
-            readonly name: "inNumber";
-            readonly type: "tuple";
-            readonly internalType: "struct InEuint32";
-            readonly components: readonly [{
-                readonly name: "ctHash";
-                readonly type: "uint256";
-                readonly internalType: "uint256";
-            }, {
-                readonly name: "securityZone";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "utype";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "signature";
-                readonly type: "bytes";
-                readonly internalType: "bytes";
-            }];
-        }];
-        readonly outputs: readonly [];
-        readonly stateMutability: "nonpayable";
-    }, {
-        readonly type: "function";
-        readonly name: "numberHash";
-        readonly inputs: readonly [];
-        readonly outputs: readonly [{
-            readonly name: "";
-            readonly type: "bytes32";
-            readonly internalType: "bytes32";
-        }];
-        readonly stateMutability: "view";
-    }, {
-        readonly type: "function";
-        readonly name: "publishDecryptResult";
-        readonly inputs: readonly [{
-            readonly name: "input";
-            readonly type: "bytes32";
-            readonly internalType: "euint32";
-        }, {
-            readonly name: "result";
-            readonly type: "uint32";
-            readonly internalType: "uint32";
-        }, {
-            readonly name: "signature";
-            readonly type: "bytes";
-            readonly internalType: "bytes";
-        }];
-        readonly outputs: readonly [];
-        readonly stateMutability: "nonpayable";
-    }, {
-        readonly type: "function";
-        readonly name: "setNumber";
-        readonly inputs: readonly [{
-            readonly name: "inNumber";
-            readonly type: "tuple";
-            readonly internalType: "struct InEuint32";
-            readonly components: readonly [{
-                readonly name: "ctHash";
-                readonly type: "uint256";
-                readonly internalType: "uint256";
-            }, {
-                readonly name: "securityZone";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "utype";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "signature";
-                readonly type: "bytes";
-                readonly internalType: "bytes";
-            }];
-        }];
-        readonly outputs: readonly [];
-        readonly stateMutability: "nonpayable";
-    }, {
-        readonly type: "function";
-        readonly name: "setNumberTrivial";
-        readonly inputs: readonly [{
-            readonly name: "inNumber";
-            readonly type: "uint32";
-            readonly internalType: "uint32";
-        }];
-        readonly outputs: readonly [];
-        readonly stateMutability: "nonpayable";
-    }, {
-        readonly type: "function";
-        readonly name: "sub";
-        readonly inputs: readonly [{
-            readonly name: "inNumber";
-            readonly type: "tuple";
-            readonly internalType: "struct InEuint32";
-            readonly components: readonly [{
-                readonly name: "ctHash";
-                readonly type: "uint256";
-                readonly internalType: "uint256";
-            }, {
-                readonly name: "securityZone";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "utype";
-                readonly type: "uint8";
-                readonly internalType: "uint8";
-            }, {
-                readonly name: "signature";
-                readonly type: "bytes";
-                readonly internalType: "bytes";
-            }];
-        }];
-        readonly outputs: readonly [];
-        readonly stateMutability: "nonpayable";
-    }, {
-        readonly type: "error";
-        readonly name: "InvalidEncryptedInput";
-        readonly inputs: readonly [{
-            readonly name: "got";
-            readonly type: "uint8";
-            readonly internalType: "uint8";
-        }, {
-            readonly name: "expected";
-            readonly type: "uint8";
-            readonly internalType: "uint8";
-        }];
-    }, {
-        readonly type: "error";
-        readonly name: "SecurityZoneOutOfBounds";
-        readonly inputs: readonly [{
-            readonly name: "value";
-            readonly type: "int32";
-            readonly internalType: "int32";
-        }];
-    }];
-};
-
 interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> extends DeferredTopicFilter {
 }
 interface TypedContractEvent<InputTuple extends Array<any> = any, OutputTuple extends Array<any> = any, OutputObject = any> {
@@ -3165,98 +2928,4 @@ interface MockZkVerifier extends BaseContract {
     filters: {};
 }
 
-type InEuint32Struct = {
-    ctHash: BigNumberish;
-    securityZone: BigNumberish;
-    utype: BigNumberish;
-    signature: BytesLike;
-};
-interface TestBedInterface extends Interface {
-    getFunction(nameOrSignature: 'add' | 'decrypt' | 'eNumber' | 'exists' | 'getDecryptResult' | 'getDecryptResultSafe' | 'increment' | 'mul' | 'numberHash' | 'publishDecryptResult' | 'setNumber' | 'setNumberTrivial' | 'sub'): FunctionFragment;
-    encodeFunctionData(functionFragment: 'add', values: [InEuint32Struct]): string;
-    encodeFunctionData(functionFragment: 'decrypt', values?: undefined): string;
-    encodeFunctionData(functionFragment: 'eNumber', values?: undefined): string;
-    encodeFunctionData(functionFragment: 'exists', values?: undefined): string;
-    encodeFunctionData(functionFragment: 'getDecryptResult', values: [BytesLike]): string;
-    encodeFunctionData(functionFragment: 'getDecryptResultSafe', values: [BytesLike]): string;
-    encodeFunctionData(functionFragment: 'increment', values?: undefined): string;
-    encodeFunctionData(functionFragment: 'mul', values: [InEuint32Struct]): string;
-    encodeFunctionData(functionFragment: 'numberHash', values?: undefined): string;
-    encodeFunctionData(functionFragment: 'publishDecryptResult', values: [BytesLike, BigNumberish, BytesLike]): string;
-    encodeFunctionData(functionFragment: 'setNumber', values: [InEuint32Struct]): string;
-    encodeFunctionData(functionFragment: 'setNumberTrivial', values: [BigNumberish]): string;
-    encodeFunctionData(functionFragment: 'sub', values: [InEuint32Struct]): string;
-    decodeFunctionResult(functionFragment: 'add', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'decrypt', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'eNumber', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'getDecryptResult', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'getDecryptResultSafe', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'increment', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'mul', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'numberHash', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'publishDecryptResult', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'setNumber', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'setNumberTrivial', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'sub', data: BytesLike): Result;
-}
-interface TestBed extends BaseContract {
-    connect(runner?: ContractRunner | null): TestBed;
-    waitForDeployment(): Promise<this>;
-    interface: TestBedInterface;
-    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
-    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
-    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
-    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
-    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
-    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
-    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
-    listeners(eventName?: string): Promise<Array<Listener>>;
-    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
-    add: TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
-    decrypt: TypedContractMethod<[], [void], 'nonpayable'>;
-    eNumber: TypedContractMethod<[], [string], 'view'>;
-    exists: TypedContractMethod<[], [boolean], 'view'>;
-    getDecryptResult: TypedContractMethod<[input1: BytesLike], [bigint], 'view'>;
-    getDecryptResultSafe: TypedContractMethod<[
-        input1: BytesLike
-    ], [
-        [bigint, boolean] & {
-            value: bigint;
-            decrypted: boolean;
-        }
-    ], 'view'>;
-    increment: TypedContractMethod<[], [void], 'nonpayable'>;
-    mul: TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
-    numberHash: TypedContractMethod<[], [string], 'view'>;
-    publishDecryptResult: TypedContractMethod<[
-        input: BytesLike,
-        result: BigNumberish,
-        signature: BytesLike
-    ], [
-        void
-    ], 'nonpayable'>;
-    setNumber: TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
-    setNumberTrivial: TypedContractMethod<[inNumber: BigNumberish], [void], 'nonpayable'>;
-    sub: TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
-    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    getFunction(nameOrSignature: 'add'): TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
-    getFunction(nameOrSignature: 'decrypt'): TypedContractMethod<[], [void], 'nonpayable'>;
-    getFunction(nameOrSignature: 'eNumber'): TypedContractMethod<[], [string], 'view'>;
-    getFunction(nameOrSignature: 'exists'): TypedContractMethod<[], [boolean], 'view'>;
-    getFunction(nameOrSignature: 'getDecryptResult'): TypedContractMethod<[input1: BytesLike], [bigint], 'view'>;
-    getFunction(nameOrSignature: 'getDecryptResultSafe'): TypedContractMethod<[input1: BytesLike], [[bigint, boolean] & {
-        value: bigint;
-        decrypted: boolean;
-    }], 'view'>;
-    getFunction(nameOrSignature: 'increment'): TypedContractMethod<[], [void], 'nonpayable'>;
-    getFunction(nameOrSignature: 'mul'): TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
-    getFunction(nameOrSignature: 'numberHash'): TypedContractMethod<[], [string], 'view'>;
-    getFunction(nameOrSignature: 'publishDecryptResult'): TypedContractMethod<[input: BytesLike, result: BigNumberish, signature: BytesLike], [void], 'nonpayable'>;
-    getFunction(nameOrSignature: 'setNumber'): TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
-    getFunction(nameOrSignature: 'setNumberTrivial'): TypedContractMethod<[inNumber: BigNumberish], [void], 'nonpayable'>;
-    getFunction(nameOrSignature: 'sub'): TypedContractMethod<[inNumber: InEuint32Struct], [void], 'nonpayable'>;
-    filters: {};
-}
-
-export { type MockACL, MockACLArtifact, type MockArtifact, type MockTaskManager, MockTaskManagerArtifact, type MockThresholdNetwork, MockThresholdNetworkArtifact, type MockZkVerifier, MockZkVerifierArtifact, type TestBed, TestBedArtifact };
+export { type MockACL, MockACLArtifact, type MockArtifact, type MockTaskManager, MockTaskManagerArtifact, type MockThresholdNetwork, MockThresholdNetworkArtifact, type MockZkVerifier, MockZkVerifierArtifact };