@cofhe/foundry-plugin 0.6.1 → 0.7.1

package/README.md

@@ -1,6 +1,6 @@
 # @cofhe/foundry-plugin
 
-Foundry test utilities for [CoFHE](https://github.com/FhenixProtocol/cofhesdk). Provides `CofheTest` (base test contract with mock deployment) and `CofheClient` (SDK-like client for encrypting inputs, decrypting outputs, and managing permits).
+Foundry test utilities for [CoFHE](https://github.com/FhenixProtocol/cofhesdk). Provides `CofheTest` (base test contract with mock deployment) and `CofheClient` (SDK-like client for encrypting inputs, decrypting outputs, and managing acps).
 
 ## Installation
 
@@ -53,10 +53,13 @@ contract MyTest is CofheTest {
     }
 
     function testEncryptAndStore() public {
-        InEuint32 memory enc = client.createInEuint32(42);
+        // The last argument binds the input to the contract that will consume it.
+        (externalEuint32 hash, bytes memory signature) = client.createExternalEuint32(42, address(target));
+        externalEuint32[] memory hashes = new externalEuint32[](1);
+        hashes[0] = hash;
 
         vm.prank(client.account());
-        target.store(enc);
+        target.storeBatch(hashes, signature);
 
         expectPlaintext(target.eValue(), uint32(42));
     }
@@ -79,15 +82,16 @@ contract MyTest is CofheTest {
 
 ### `CofheClient`
 
-| Function                                      | Description                                                                      |
-| --------------------------------------------- | -------------------------------------------------------------------------------- |
-| `connect(pkey)`                               | Sets the active account from a private key                                       |
-| `account()`                                   | Returns the connected account address                                            |
-| `createInEbool/8/16/32/64/128/address(value)` | Creates a signed encrypted input                                                 |
-| `decryptForTx_withoutPermit(ctHash)`          | Decrypts a globally-allowed ciphertext; returns `(ctHash, plaintext, signature)` |
-| `decryptForTx_withPermit(ctHash, permit)`     | Decrypts with a permission; returns `(ctHash, plaintext, signature)`             |
-| `decryptForView(ctHash, sealingKey, permit)`  | Seals and unseals for off-chain reading                                          |
-| `permit_createSelf()`                         | Creates a self-permit for the connected account                                  |
-| `permit_createShared(recipient)`              | Creates the issuer half of a shared permit                                       |
-| `permit_exportShared(permit)`                 | Strips recipient fields for safe transmission                                    |
-| `permit_importShared(export)`                 | Completes a shared permit as the recipient                                       |
+| Function                                                               | Description                                                                                                     |
+| ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `connect(pkey)`                                                        | Sets the active account from a private key                                                                      |
+| `account()`                                                            | Returns the connected account address                                                                           |
+| `createExternalEbool/8/16/32/64/128/address(value, consumingContract)` | Creates a batch-signed encrypted input bound to `consumingContract`; returns `(external*Hash, bytes signature)` |
+| `createEuint32sBatch(values, consumingContract)`                       | Creates a batch of encrypted uint32s sharing one signature                                                      |
+| `decryptForTx_withoutACP(ctHash)`                                      | Decrypts a globally-allowed ciphertext; returns `(ctHash, plaintext, signature)`                                |
+| `decryptForTx_withACP(ctHash, acp)`                                    | Decrypts with a permission; returns `(ctHash, plaintext, signature)`                                            |
+| `decryptForView(ctHash, sealingKey, acp)`                              | Seals and unseals for off-chain reading                                                                         |
+| `acp_createSelf()`                                                     | Creates a self-acp for the connected account                                                                    |
+| `acp_createShared(recipient)`                                          | Creates the issuer half of a shared acp                                                                         |
+| `acp_exportShared(acp)`                                                | Strips recipient fields for safe transmission                                                                   |
+| `acp_importShared(export)`                                             | Completes a shared acp as the recipient                                                                         |

package/contracts/CofheClient.sol

@@ -10,19 +10,23 @@ import { MockZkVerifier } from '@cofhe/mock-contracts/contracts/MockZkVerifier.s
 import { MockZkVerifierSigner } from './MockZkVerifierSigner.sol';
 import { MockThresholdNetwork } from '@cofhe/mock-contracts/contracts/MockThresholdNetwork.sol';
 import { MockThresholdNetworkSigner } from './MockThresholdNetworkSigner.sol';
-import { Permission, PermissionUtils } from '@cofhe/mock-contracts/contracts/Permissioned.sol';
+import { ACP, ACPUtils, SCOPE_GLOBAL } from '@cofhe/mock-contracts/contracts/Permissioned.sol';
 import {
   ZK_VERIFIER_SIGNER_ADDRESS,
   DECRYPT_RESULT_SIGNER_ADDRESS
 } from '@cofhe/mock-contracts/contracts/MockCoFHE.sol';
 
-/// @notice Portable representation of the issuer's half of a shared permit, safe to transmit as cleartext.
-struct SharedPermitExport {
+/// @notice Portable representation of the issuer's half of a shared acp, safe to transmit as cleartext.
+struct SharedACPExport {
   address issuer;
   uint64 expiration;
   address recipient;
-  uint256 validatorId;
-  address validatorContract;
+  uint256 revokerData;
+  address revokerContract;
+  // (scope) part of the issuer signature — the recipient needs them to reconstruct it
+  uint8 scope;
+  address[] contracts;
+  bytes32[] handles;
   bytes issuerSignature;
 }
 
@@ -74,98 +78,186 @@ contract CofheClient is Test {
   // =====================
   //       ENCRYPT
   // =====================
-
-  /// @notice Creates a signed encrypted input for the connected account (security zone 0).
-  function createEncryptedInput(
+  // Every encryption helper takes the consuming contract explicitly as its last parameter - i.e.
+  // the contract that will call `FHE.asEuint*`/`FHE.asEuint*s` with the resulting hashes. The
+  // verifier binds this address into the signed digest (cofhe-contracts#77), so a batch signed
+  // for one contract cannot be replayed into another. It is a required argument rather than
+  // client-level state so that a single test can encrypt for several contracts without a
+  // stateful setter to keep track of.
+
+  /// @notice Computes, stores, and signs a single-item encrypted input via the canonical batch
+  ///         path (createEncryptedInputsBatch, with a batch of size 1) - the root of all
+  ///         encryption helpers on this client, single-item or not.
+  function _createSingleEncryptedInput(
     uint8 utype,
-    uint256 value
-  ) internal onlyConnected returns (EncryptedInput memory input) {
-    input = mockZkVerifier.zkVerify(value, utype, _account, 0, block.chainid);
-    input = mockZkVerifierSigner.zkVerifySign(input, _account);
-  }
-
-  /// @notice Creates an encrypted boolean input.
-  function createInEbool(bool value) public returns (InEbool memory) {
-    return abi.decode(abi.encode(createEncryptedInput(Utils.EBOOL_TFHE, value ? 1 : 0)), (InEbool));
-  }
-
-  /// @notice Creates an encrypted uint8 input.
-  function createInEuint8(uint8 value) public returns (InEuint8 memory) {
-    return abi.decode(abi.encode(createEncryptedInput(Utils.EUINT8_TFHE, value)), (InEuint8));
-  }
-
-  /// @notice Creates an encrypted uint16 input.
-  function createInEuint16(uint16 value) public returns (InEuint16 memory) {
-    return abi.decode(abi.encode(createEncryptedInput(Utils.EUINT16_TFHE, value)), (InEuint16));
-  }
-
-  /// @notice Creates an encrypted uint32 input.
-  function createInEuint32(uint32 value) public returns (InEuint32 memory) {
-    return abi.decode(abi.encode(createEncryptedInput(Utils.EUINT32_TFHE, value)), (InEuint32));
-  }
-
-  /// @notice Creates an encrypted uint64 input.
-  function createInEuint64(uint64 value) public returns (InEuint64 memory) {
-    return abi.decode(abi.encode(createEncryptedInput(Utils.EUINT64_TFHE, value)), (InEuint64));
-  }
-
-  /// @notice Creates an encrypted uint128 input.
-  function createInEuint128(uint128 value) public returns (InEuint128 memory) {
-    return abi.decode(abi.encode(createEncryptedInput(Utils.EUINT128_TFHE, value)), (InEuint128));
-  }
-
-  /// @notice Creates an encrypted address input.
-  function createInEaddress(address value) public returns (InEaddress memory) {
-    return abi.decode(abi.encode(createEncryptedInput(Utils.EADDRESS_TFHE, uint256(uint160(value)))), (InEaddress));
-  }
-
-  /// @notice Creates an encrypted boolean input as hash plus proof.
-  function createInEbool_asHashPlusProof(bool value) public returns (externalEbool hash, bytes memory proof) {
-    InEbool memory input = createInEbool(value);
-    hash = externalEbool.wrap(bytes32(input.ctHash));
-    proof = input.signature;
-  }
-
-  /// @notice Creates an encrypted uint8 input as hash plus proof.
-  function createInEuint8_asHashPlusProof(uint8 value) public returns (externalEuint8 hash, bytes memory proof) {
-    InEuint8 memory input = createInEuint8(value);
-    hash = externalEuint8.wrap(bytes32(input.ctHash));
-    proof = input.signature;
-  }
-
-  /// @notice Creates an encrypted uint16 input as hash plus proof.
-  function createInEuint16_asHashPlusProof(uint16 value) public returns (externalEuint16 hash, bytes memory proof) {
-    InEuint16 memory input = createInEuint16(value);
-    hash = externalEuint16.wrap(bytes32(input.ctHash));
-    proof = input.signature;
-  }
-
-  /// @notice Creates an encrypted uint32 input as hash plus proof.
-  function createInEuint32_asHashPlusProof(uint32 value) public returns (externalEuint32 hash, bytes memory proof) {
-    InEuint32 memory input = createInEuint32(value);
-    hash = externalEuint32.wrap(bytes32(input.ctHash));
-    proof = input.signature;
-  }
-
-  /// @notice Creates an encrypted uint64 input as hash plus proof.
-  function createInEuint64_asHashPlusProof(uint64 value) public returns (externalEuint64 hash, bytes memory proof) {
-    InEuint64 memory input = createInEuint64(value);
-    hash = externalEuint64.wrap(bytes32(input.ctHash));
-    proof = input.signature;
+    uint256 value,
+    address consumingContract
+  ) internal onlyConnected returns (uint256 ctHash, bytes memory signature) {
+    uint8[] memory utypes = new uint8[](1);
+    uint256[] memory values = new uint256[](1);
+    utypes[0] = utype;
+    values[0] = value;
+
+    (UnsignedEncryptedInput[] memory inputs, bytes memory sig) = createEncryptedInputsBatch(
+      utypes,
+      values,
+      consumingContract
+    );
+    ctHash = inputs[0].ctHash;
+    signature = sig;
+  }
+
+  /// @notice Creates an encrypted boolean input as hash plus proof, bound to `consumingContract`.
+  function createExternalEbool(
+    bool value,
+    address consumingContract
+  ) public returns (externalEbool hash, bytes memory proof) {
+    (uint256 ctHash, bytes memory signature) = _createSingleEncryptedInput(
+      Utils.EBOOL_TFHE,
+      value ? 1 : 0,
+      consumingContract
+    );
+    hash = externalEbool.wrap(bytes32(ctHash));
+    proof = signature;
+  }
+
+  /// @notice Creates an encrypted uint8 input as hash plus proof, bound to `consumingContract`.
+  function createExternalEuint8(
+    uint8 value,
+    address consumingContract
+  ) public returns (externalEuint8 hash, bytes memory proof) {
+    (uint256 ctHash, bytes memory signature) = _createSingleEncryptedInput(
+      Utils.EUINT8_TFHE,
+      value,
+      consumingContract
+    );
+    hash = externalEuint8.wrap(bytes32(ctHash));
+    proof = signature;
+  }
+
+  /// @notice Creates an encrypted uint16 input as hash plus proof, bound to `consumingContract`.
+  function createExternalEuint16(
+    uint16 value,
+    address consumingContract
+  ) public returns (externalEuint16 hash, bytes memory proof) {
+    (uint256 ctHash, bytes memory signature) = _createSingleEncryptedInput(
+      Utils.EUINT16_TFHE,
+      value,
+      consumingContract
+    );
+    hash = externalEuint16.wrap(bytes32(ctHash));
+    proof = signature;
+  }
+
+  /// @notice Creates an encrypted uint32 input as hash plus proof, bound to `consumingContract`.
+  function createExternalEuint32(
+    uint32 value,
+    address consumingContract
+  ) public returns (externalEuint32 hash, bytes memory proof) {
+    (uint256 ctHash, bytes memory signature) = _createSingleEncryptedInput(
+      Utils.EUINT32_TFHE,
+      value,
+      consumingContract
+    );
+    hash = externalEuint32.wrap(bytes32(ctHash));
+    proof = signature;
+  }
+
+  /// @notice Creates an encrypted uint64 input as hash plus proof, bound to `consumingContract`.
+  function createExternalEuint64(
+    uint64 value,
+    address consumingContract
+  ) public returns (externalEuint64 hash, bytes memory proof) {
+    (uint256 ctHash, bytes memory signature) = _createSingleEncryptedInput(
+      Utils.EUINT64_TFHE,
+      value,
+      consumingContract
+    );
+    hash = externalEuint64.wrap(bytes32(ctHash));
+    proof = signature;
+  }
+
+  /// @notice Creates an encrypted uint128 input as hash plus proof, bound to `consumingContract`.
+  function createExternalEuint128(
+    uint128 value,
+    address consumingContract
+  ) public returns (externalEuint128 hash, bytes memory proof) {
+    (uint256 ctHash, bytes memory signature) = _createSingleEncryptedInput(
+      Utils.EUINT128_TFHE,
+      value,
+      consumingContract
+    );
+    hash = externalEuint128.wrap(bytes32(ctHash));
+    proof = signature;
+  }
+
+  /// @notice Creates an encrypted address input as hash plus proof, bound to `consumingContract`.
+  function createExternalEaddress(
+    address value,
+    address consumingContract
+  ) public returns (externalEaddress hash, bytes memory proof) {
+    (uint256 ctHash, bytes memory signature) = _createSingleEncryptedInput(
+      Utils.EADDRESS_TFHE,
+      uint256(uint160(value)),
+      consumingContract
+    );
+    hash = externalEaddress.wrap(bytes32(ctHash));
+    proof = signature;
   }
 
-  /// @notice Creates an encrypted uint128 input as hash plus proof.
-  function createInEuint128_asHashPlusProof(uint128 value) public returns (externalEuint128 hash, bytes memory proof) {
-    InEuint128 memory input = createInEuint128(value);
-    hash = externalEuint128.wrap(bytes32(input.ctHash));
-    proof = input.signature;
-  }
+  // =====================
+  //   ENCRYPT (BATCH)
+  // =====================
+  // The canonical batch verification path - a whole batch of inputs authenticated by a single
+  // signature over keccak256(h_0 || ... || h_n) (see MockZkVerifierSigner.zkVerifyBatchSign /
+  // MockTaskManager.batchVerifyInputs). This is the root of every encryption helper on this
+  // client - the single-item createExternalEuintX helpers above are thin wrappers over a batch of
+  // size 1, not a separate signing scheme.
+
+  /// @notice Creates a batch of encrypted inputs (mixed utypes allowed) sharing one signature,
+  ///         all bound to `consumingContract`.
+  function createEncryptedInputsBatch(
+    uint8[] memory utypes,
+    uint256[] memory values,
+    address consumingContract
+  ) internal onlyConnected returns (UnsignedEncryptedInput[] memory inputs, bytes memory signature) {
+    require(utypes.length == values.length, 'CofheClient: length mismatch');
+    require(consumingContract != address(0), 'CofheClient: consuming contract must not be the zero address');
+
+    inputs = new UnsignedEncryptedInput[](utypes.length);
+    for (uint256 i = 0; i < utypes.length; i++) {
+      uint256 ctHash = mockZkVerifier.zkVerifyCalcCtHash(values[i], utypes[i], _account, 0, block.chainid);
+      mockZkVerifier.insertCtHash(ctHash, values[i]);
+      inputs[i] = UnsignedEncryptedInput({ ctHash: ctHash, securityZone: 0, utype: utypes[i] });
+    }
+
+    signature = mockZkVerifierSigner.zkVerifyBatchSign(inputs, _account, consumingContract);
+  }
+
+  /// @notice Creates a batch of encrypted uint32 inputs sharing one signature, all bound to
+  ///         `consumingContract`.
+  function createEuint32sBatch(
+    uint32[] memory values,
+    address consumingContract
+  ) public returns (externalEuint32[] memory hashes, bytes memory signature) {
+    uint8[] memory utypes = new uint8[](values.length);
+    uint256[] memory rawValues = new uint256[](values.length);
+    for (uint256 i = 0; i < values.length; i++) {
+      utypes[i] = Utils.EUINT32_TFHE;
+      rawValues[i] = values[i];
+    }
+
+    (UnsignedEncryptedInput[] memory inputs, bytes memory sig) = createEncryptedInputsBatch(
+      utypes,
+      rawValues,
+      consumingContract
+    );
 
-  /// @notice Creates an encrypted address input as hash plus proof.
-  function createInEaddress_asHashPlusProof(address value) public returns (externalEaddress hash, bytes memory proof) {
-    InEaddress memory input = createInEaddress(value);
-    hash = externalEaddress.wrap(bytes32(input.ctHash));
-    proof = input.signature;
+    hashes = new externalEuint32[](inputs.length);
+    for (uint256 i = 0; i < inputs.length; i++) {
+      hashes[i] = externalEuint32.wrap(bytes32(inputs[i].ctHash));
+    }
+    signature = sig;
   }
 
   // =====================
@@ -173,28 +265,28 @@ contract CofheClient is Test {
   // =====================
 
   /// @notice Decrypts a globally-allowed ciphertext and returns the plaintext with a publishable signature.
-  function decryptForTx_withoutPermit(
+  function decryptForTx_withoutACP(
     bytes32 ctHash
   ) public view onlyConnected returns (bytes32, uint256, bytes memory) {
     uint256 ct = uint256(ctHash);
 
-    (bool allowed, string memory error, uint256 decryptedValue) = mockThresholdNetwork.decryptForTxWithoutPermit(ct);
+    (bool allowed, string memory error, uint256 decryptedValue) = mockThresholdNetwork.decryptForTxWithoutACP(ct);
     require(allowed, string.concat('CofheClient: decryptForTx failed: ', error));
 
     bytes memory signature = mockThresholdNetworkSigner.signDecryptResult(ct, decryptedValue);
     return (ctHash, decryptedValue, signature);
   }
 
-  /// @notice Decrypts a ciphertext using a permit and returns the plaintext with a publishable signature.
-  function decryptForTx_withPermit(
+  /// @notice Decrypts a ciphertext using an ACP and returns the plaintext with a publishable signature.
+  function decryptForTx_withACP(
     bytes32 ctHash,
-    Permission memory permission
+    ACP memory acp
   ) public view onlyConnected returns (bytes32, uint256, bytes memory) {
     uint256 ct = uint256(ctHash);
 
-    (bool allowed, string memory error, uint256 decryptedValue) = mockThresholdNetwork.decryptForTxWithPermit(
+    (bool allowed, string memory error, uint256 decryptedValue) = mockThresholdNetwork.decryptForTxWithACP(
       ct,
-      permission
+      acp
     );
     require(allowed, string.concat('CofheClient: decryptForTx failed: ', error));
 
@@ -206,22 +298,22 @@ contract CofheClient is Test {
   //   DECRYPT FOR VIEW
   // =====================
 
-  /// @notice Decrypts a ciphertext for off-chain reading by sealing/unsealing with the permit's sealing key.
-  function decryptForView(bytes32 ctHash, Permission memory permission) public view onlyConnected returns (uint256) {
+  /// @notice Decrypts a ciphertext for off-chain reading by sealing/unsealing with the acp's sealing key.
+  function decryptForView(bytes32 ctHash, ACP memory acp) public view onlyConnected returns (uint256) {
     uint256 ct = uint256(ctHash);
 
     (bool allowed, string memory error, bytes32 sealedOutput) = mockThresholdNetwork.querySealOutput(
       ct,
       block.chainid,
-      permission
+      acp
     );
     require(allowed, string.concat('CofheClient: decryptForView failed: ', error));
 
-    return mockThresholdNetwork.unseal(sealedOutput, permission.sealingKey);
+    return mockThresholdNetwork.unseal(sealedOutput, acp.sealingKey);
   }
 
   // =====================
-  //      PERMITS
+  //      ACPS
   // =====================
 
   bytes32 private constant PERMISSION_TYPE_HASH =
@@ -233,6 +325,7 @@ contract CofheClient is Test {
     uint256 chainId;
     address verifyingContract;
 
+    // ACP (V3): the signing domain lives on the ACL (name "ACL", version "2")
     (, name, version, chainId, verifyingContract, , ) = mockAcl.eip712Domain();
 
     return
@@ -251,35 +344,38 @@ contract CofheClient is Test {
     return abi.encodePacked(r, s, v);
   }
 
-  function _signIssuerSelf(Permission memory permission, uint256 pkey) internal view returns (Permission memory) {
-    bytes32 permissionHash = PermissionUtils.issuerSelfHash(permission);
+  function _signIssuerSelf(ACP memory acp, uint256 pkey) internal view returns (ACP memory) {
+    bytes32 permissionHash = ACPUtils.issuerSelfHash(acp);
     bytes32 structHash = permissionHashTypedDataV4(permissionHash);
-    permission.issuerSignature = _signPermission(structHash, pkey);
-    return permission;
+    acp.issuerSignature = _signPermission(structHash, pkey);
+    return acp;
   }
 
-  function _signIssuerShared(Permission memory permission, uint256 pkey) internal view returns (Permission memory) {
-    bytes32 permissionHash = PermissionUtils.issuerSharedHash(permission);
+  function _signIssuerShared(ACP memory acp, uint256 pkey) internal view returns (ACP memory) {
+    bytes32 permissionHash = ACPUtils.issuerSharedHash(acp);
     bytes32 structHash = permissionHashTypedDataV4(permissionHash);
-    permission.issuerSignature = _signPermission(structHash, pkey);
-    return permission;
+    acp.issuerSignature = _signPermission(structHash, pkey);
+    return acp;
   }
 
-  function _signRecipient(Permission memory permission, uint256 pkey) internal view returns (Permission memory) {
-    bytes32 permissionHash = PermissionUtils.recipientHash(permission);
+  function _signRecipient(ACP memory acp, uint256 pkey) internal view returns (ACP memory) {
+    bytes32 permissionHash = ACPUtils.recipientHash(acp);
     bytes32 structHash = permissionHashTypedDataV4(permissionHash);
-    permission.recipientSignature = _signPermission(structHash, pkey);
-    return permission;
+    acp.recipientSignature = _signPermission(structHash, pkey);
+    return acp;
   }
 
-  /// @notice Returns a blank Permission with default field values.
-  function createBasePermission() public pure returns (Permission memory permission) {
-    permission = Permission({
+  /// @notice Returns a blank ACP with default field values.
+  function createBaseACP() public pure returns (ACP memory acp) {
+    acp = ACP({
       issuer: address(0),
       expiration: 1000000000000,
       recipient: address(0),
-      validatorId: 0,
-      validatorContract: address(0),
+      revokerData: 0,
+      revokerContract: address(0),
+      scope: SCOPE_GLOBAL,
+      contracts: new address[](0),
+      handles: new bytes32[](0),
       sealingKey: bytes32(0),
       issuerSignature: new bytes(0),
       recipientSignature: new bytes(0)
@@ -291,50 +387,56 @@ contract CofheClient is Test {
     return keccak256(abi.encodePacked(seed));
   }
 
-  /// @notice Creates a self-permit for the connected account, signed with the stored private key.
-  function permit_createSelf() public view onlyConnected returns (Permission memory permission) {
-    permission = createBasePermission();
-    permission.issuer = _account;
-    permission.sealingKey = createSealingKey(uint256(uint160(_account)));
-    permission = _signIssuerSelf(permission, _pkey);
-  }
-
-  /// @notice Creates the issuer side of a shared permit. The result has no sealingKey (added by recipient on import).
-  function permit_createShared(address recipient) public view onlyConnected returns (Permission memory permission) {
-    permission = createBasePermission();
-    permission.issuer = _account;
-    permission.recipient = recipient;
-    permission = _signIssuerShared(permission, _pkey);
-  }
-
-  /// @notice Exports a shared permit, stripping sensitive/recipient-specific fields.
-  function permit_exportShared(Permission memory permission) public pure returns (SharedPermitExport memory exported) {
-    exported = SharedPermitExport({
-      issuer: permission.issuer,
-      expiration: permission.expiration,
-      recipient: permission.recipient,
-      validatorId: permission.validatorId,
-      validatorContract: permission.validatorContract,
-      issuerSignature: permission.issuerSignature
+  /// @notice Creates a self-acp for the connected account, signed with the stored private key.
+  function ACP_createSelf() public view onlyConnected returns (ACP memory acp) {
+    acp = createBaseACP();
+    acp.issuer = _account;
+    acp.sealingKey = createSealingKey(uint256(uint160(_account)));
+    acp = _signIssuerSelf(acp, _pkey);
+  }
+
+  /// @notice Creates the issuer side of a shared acp. The result has no sealingKey (added by recipient on import).
+  function ACP_createShared(address recipient) public view onlyConnected returns (ACP memory acp) {
+    acp = createBaseACP();
+    acp.issuer = _account;
+    acp.recipient = recipient;
+    acp = _signIssuerShared(acp, _pkey);
+  }
+
+  /// @notice Exports a shared acp, stripping sensitive/recipient-specific fields.
+  function ACP_exportShared(ACP memory acp) public pure returns (SharedACPExport memory exported) {
+    exported = SharedACPExport({
+      issuer: acp.issuer,
+      expiration: acp.expiration,
+      recipient: acp.recipient,
+      revokerData: acp.revokerData,
+      revokerContract: acp.revokerContract,
+      scope: acp.scope,
+      contracts: acp.contracts,
+      handles: acp.handles,
+      issuerSignature: acp.issuerSignature
     });
   }
 
-  /// @notice Imports a shared permit export, adds the recipient's sealing key and signature.
-  function permit_importShared(
-    SharedPermitExport memory data
-  ) public view onlyConnected returns (Permission memory permission) {
+  /// @notice Imports a shared acp export, adds the recipient's sealing key and signature.
+  function ACP_importShared(
+    SharedACPExport memory data
+  ) public view onlyConnected returns (ACP memory acp) {
     require(data.recipient == _account, 'CofheClient: recipient mismatch');
 
-    permission = Permission({
+    acp = ACP({
       issuer: data.issuer,
       expiration: data.expiration,
       recipient: data.recipient,
-      validatorId: data.validatorId,
-      validatorContract: data.validatorContract,
+      revokerData: data.revokerData,
+      revokerContract: data.revokerContract,
+      scope: data.scope,
+      contracts: data.contracts,
+      handles: data.handles,
       sealingKey: createSealingKey(uint256(uint160(_account))),
       issuerSignature: data.issuerSignature,
       recipientSignature: new bytes(0)
     });
-    permission = _signRecipient(permission, _pkey);
+    acp = _signRecipient(acp, _pkey);
   }
 }

package/contracts/CofheTest.sol

@@ -5,6 +5,8 @@ import { Test } from 'forge-std/Test.sol';
 import '@fhenixprotocol/cofhe-contracts/FHE.sol';
 import { MockTaskManager } from '@cofhe/mock-contracts/contracts/MockTaskManager.sol';
 import { MockACL } from '@cofhe/mock-contracts/contracts/MockACL.sol';
+import { ACPTimestampRevoker } from '@cofhe/mock-contracts/contracts/ACPTimestampRevoker.sol';
+import { ACPShareRegistry } from '@cofhe/mock-contracts/contracts/ACPShareRegistry.sol';
 import { MockZkVerifier } from '@cofhe/mock-contracts/contracts/MockZkVerifier.sol';
 import { MockZkVerifierSigner } from './MockZkVerifierSigner.sol';
 import { MockThresholdNetwork } from '@cofhe/mock-contracts/contracts/MockThresholdNetwork.sol';
@@ -21,6 +23,8 @@ import {
 abstract contract CofheTest is Test {
   MockTaskManager public mockTaskManager;
   MockACL public mockAcl;
+  ACPTimestampRevoker public acpRevoker;
+  ACPShareRegistry public acpShareRegistry;
   MockZkVerifier public mockZkVerifier;
   MockZkVerifierSigner public mockZkVerifierSigner;
   MockThresholdNetwork public mockThresholdNetwork;
@@ -49,6 +53,16 @@ abstract contract CofheTest is Test {
     mockAcl = new MockACL();
     vm.label(address(mockAcl), 'MockACL');
 
+    // ACP (ACP V3): default revoker (verification inherited by the ACL)
+    acpRevoker = new ACPTimestampRevoker();
+    vm.label(address(acpRevoker), 'ACPTimestampRevoker');
+    mockAcl.setDefaultRevokerContract(address(acpRevoker));
+
+    // ACP: on-chain hand-off for sharing ACPs
+    acpShareRegistry = new ACPShareRegistry();
+    vm.label(address(acpShareRegistry), 'ACPShareRegistry');
+    mockAcl.setShareRegistry(address(acpShareRegistry));
+
     // 3. Link Task Manager <-> ACL, configure signers
     vm.startPrank(TM_ADMIN);
     mockTaskManager.setACLContract(address(mockAcl));

package/contracts/MockZkVerifierSigner.sol

@@ -3,38 +3,44 @@
 
 pragma solidity >=0.8.19 <0.9.0;
 
-import { console } from 'forge-std/console.sol';
 import { Test } from 'forge-std/Test.sol';
-import { MessageHashUtils } from '@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol';
-import { EncryptedInput } from '@fhenixprotocol/cofhe-contracts/ICofhe.sol';
+import { UnsignedEncryptedInput } from '@fhenixprotocol/cofhe-contracts/ICofhe.sol';
 import { ZK_VERIFIER_SIGNER_PRIVATE_KEY } from '@cofhe/mock-contracts/contracts/MockCoFHE.sol';
 
 /**
  * @dev Generates valid signatures for encrypted inputs.
  * Uses vm.sign to generate the signatures (only available in foundry tests)
- * Should not need to be interacted with directly, is part of the `createEncryptedInput` function set
+ * Should not need to be interacted with directly, is part of the `CofheClient.createExternal*` function set
  */
 contract MockZkVerifierSigner is Test {
-  function zkVerifySignPacked(
-    EncryptedInput[] memory inputs,
-    address sender
-  ) public view returns (EncryptedInput[] memory) {
-    EncryptedInput[] memory signedInputs = new EncryptedInput[](inputs.length);
+  /// @notice The canonical batch signer: one signature over a whole batch of inputs, matching
+  ///         `MockTaskManager.batchVerifyInputs`/`extractBatchSigner`'s digest -
+  ///         keccak256(h_0 || h_1 || ... || h_n), where each h_i is the per-input message hash
+  ///         (`ctHash || utype || securityZone || sender || chainid || contractAddress`).
+  ///         `contractAddress` binds the batch to the specific contract that will consume it
+  ///         (matching cofhe-contracts#77's contract-binding fix) - the caller must know in
+  ///         advance which contract will call `FHE.asEuint*s` with the resulting hashes.
+  function zkVerifyBatchSign(
+    UnsignedEncryptedInput[] memory inputs,
+    address sender,
+    address contractAddress
+  ) public view returns (bytes memory signature) {
+    bytes memory concatenatedHashes;
     for (uint256 i = 0; i < inputs.length; i++) {
-      signedInputs[i] = zkVerifySign(inputs[i], sender);
+      bytes memory combined = abi.encodePacked(
+        inputs[i].ctHash,
+        inputs[i].utype,
+        inputs[i].securityZone,
+        sender,
+        block.chainid,
+        contractAddress
+      );
+      concatenatedHashes = abi.encodePacked(concatenatedHashes, keccak256(combined));
     }
-    return signedInputs;
-  }
-
-  function zkVerifySign(EncryptedInput memory input, address sender) public view returns (EncryptedInput memory) {
-    bytes memory combined = abi.encodePacked(input.ctHash, input.utype, input.securityZone, sender, block.chainid);
-
-    bytes32 expectedHash = keccak256(combined);
 
-    (uint8 v, bytes32 r, bytes32 s) = vm.sign(ZK_VERIFIER_SIGNER_PRIVATE_KEY, expectedHash);
-    bytes memory signature = abi.encodePacked(r, s, v); // note the order here is different from line above.
+    bytes32 batchHash = keccak256(concatenatedHashes);
 
-    input.signature = signature;
-    return input;
+    (uint8 v, bytes32 r, bytes32 s) = vm.sign(ZK_VERIFIER_SIGNER_PRIVATE_KEY, batchHash);
+    signature = abi.encodePacked(r, s, v);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/foundry-plugin",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "Foundry plugin for CoFHE — Write and test FHE enabled contracts",
   "license": "MIT",
   "repository": {
@@ -24,9 +24,9 @@
     "fhenix"
   ],
   "dependencies": {
-    "@fhenixprotocol/cofhe-contracts": "0.1.4",
+    "@fhenixprotocol/cofhe-contracts": "0.2.0",
     "@openzeppelin/contracts": "5.4.0",
-    "@cofhe/mock-contracts": "0.6.1"
+    "@cofhe/mock-contracts": "0.7.1"
   },
   "devDependencies": {
     "forge-std": "github:foundry-rs/forge-std#c0f966cb111f621bfb283b2a388bc7be18953bba",