Add BatcherConfidential

.changeset/modern-snakes-return.md

@@ -0,0 +1,5 @@
+---
+'openzeppelin-confidential-contracts': minor
+---
+
+`BatcherConfidential`: A batching primitive that enables routing between two {ERC7984ERC20Wrapper} contracts via a non-confidential route.

contracts/finance/README.adoc

@@ -8,6 +8,7 @@ This directory includes primitives for on-chain confidential financial systems:
 
 - {VestingWalletConfidential}: Handles the vesting of confidential tokens for a given beneficiary. Custody of multiple tokens can be given to this contract, which will release the token to the beneficiary following a given, customizable, vesting schedule.
 - {VestingWalletCliffConfidential}: Variant of {VestingWalletConfidential} which adds a cliff period to the vesting schedule.
+- {BatcherConfidential}: A batching primitive that enables routing between two {ERC7984ERC20Wrapper} contracts via a non-confidential route.
 
 For convenience, this directory also includes:
 
@@ -18,3 +19,4 @@ For convenience, this directory also includes:
 {{VestingWalletConfidential}}
 {{VestingWalletCliffConfidential}}
 {{VestingWalletConfidentialFactory}}
+{{BatcherConfidential}}

contracts/mocks/finance/BatcherConfidentialSwapMock.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.27;
+
+import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+import {FHE, externalEuint64, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {BatcherConfidential} from "./../../finance/BatcherConfidential.sol";
+import {ExchangeMock} from "./../finance/ExchangeMock.sol";
+
+abstract contract BatcherConfidentialSwapMock is ZamaEthereumConfig, BatcherConfidential {
+    ExchangeMock public exchange;
+    address public admin;
+    ExecuteOutcome public outcome = ExecuteOutcome.Complete;
+
+    constructor(ExchangeMock exchange_, address admin_) {
+        exchange = exchange_;
+        admin = admin_;
+    }
+
+    function routeDescription() public pure override returns (string memory) {
+        return "Exchange fromToken for toToken by swapping through the mock exchange.";
+    }
+
+    function setExecutionOutcome(ExecuteOutcome outcome_) public {
+        outcome = outcome_;
+    }
+
+    /// @dev Join the current batch with `externalAmount` and `inputProof`.
+    function join(externalEuint64 externalAmount, bytes calldata inputProof) public virtual returns (euint64) {
+        euint64 amount = FHE.fromExternal(externalAmount, inputProof);
+        FHE.allowTransient(amount, address(fromToken()));
+        euint64 transferred = fromToken().confidentialTransferFrom(msg.sender, address(this), amount);
+
+        euint64 joinedAmount = _join(msg.sender, transferred);
+        euint64 refundAmount = FHE.sub(transferred, joinedAmount);
+
+        FHE.allowTransient(refundAmount, address(fromToken()));
+
+        fromToken().confidentialTransfer(msg.sender, refundAmount);
+
+        return joinedAmount;
+    }
+
+    function join(uint64 amount) public {
+        euint64 ciphertext = FHE.asEuint64(amount);
+        FHE.allowTransient(ciphertext, msg.sender);
+
+        bytes memory callData = abi.encodeWithSignature(
+            "join(bytes32,bytes)",
+            externalEuint64.wrap(euint64.unwrap(ciphertext)),
+            hex""
+        );
+
+        Address.functionDelegateCall(address(this), callData);
+    }
+
+    function quit(uint256 batchId) public virtual override returns (euint64) {
+        euint64 amount = super.quit(batchId);
+        FHE.allow(totalDeposits(batchId), admin);
+        return amount;
+    }
+
+    function _join(address to, euint64 amount) internal virtual override returns (euint64) {
+        euint64 joinedAmount = super._join(to, amount);
+        FHE.allow(totalDeposits(currentBatchId()), admin);
+        return joinedAmount;
+    }
+
+    function _executeRoute(uint256, uint256 unwrapAmount) internal override returns (ExecuteOutcome) {
+        if (outcome == ExecuteOutcome.Complete) {
+            // Approve exchange to spend unwrapped tokens
+            uint256 rawAmount = unwrapAmount * fromToken().rate();
+            IERC20(fromToken().underlying()).approve(address(exchange), rawAmount);
+
+            // Swap unwrapped tokens via exchange
+            exchange.swapAToB(rawAmount);
+        }
+        return outcome;
+    }
+}

contracts/mocks/finance/ExchangeMock.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
+
+contract ExchangeMock {
+    IERC20 public tokenA;
+    IERC20 public tokenB;
+    uint256 public exchangeRate;
+
+    event ExchangeRateSet(uint256 oldExchangeRate, uint256 newExchangeRate);
+
+    constructor(IERC20 tokenA_, IERC20 tokenB_, uint256 initialExchangeRate) {
+        tokenA = tokenA_;
+        tokenB = tokenB_;
+        exchangeRate = initialExchangeRate;
+    }
+
+    function swapAToB(uint256 amount) public returns (uint256) {
+        uint256 amountOut = (amount * exchangeRate) / 1e18;
+        require(tokenA.transferFrom(msg.sender, address(this), amount), "Transfer of token A failed");
+        require(tokenB.transfer(msg.sender, amountOut), "Transfer of token B failed");
+        return amountOut;
+    }
+
+    function swapBToA(uint256 amount) public returns (uint256) {
+        uint256 amountOut = (amount * 1e18) / exchangeRate;
+        require(tokenB.transferFrom(msg.sender, address(this), amount), "Transfer of token B failed");
+        require(tokenA.transfer(msg.sender, amountOut), "Transfer of token A failed");
+        return amountOut;
+    }
+
+    function setExchangeRate(uint256 newExchangeRate) public {
+        emit ExchangeRateSet(exchangeRate, newExchangeRate);
+
+        exchangeRate = newExchangeRate;
+    }
+}

contracts/mocks/token/ERC7984ERC20WrapperMock.sol

@@ -2,14 +2,32 @@
 pragma solidity ^0.8.27;
 
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+import {euint64} from "@fhevm/solidity/lib/FHE.sol";
 import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
-import {ERC7984ERC20Wrapper, ERC7984} from "../../token/ERC7984/extensions/ERC7984ERC20Wrapper.sol";
+import {ERC7984ERC20Wrapper, ERC7984} from "./../../token/ERC7984/extensions/ERC7984ERC20Wrapper.sol";
+import {ERC7984Mock} from "./ERC7984Mock.sol";
 
-contract ERC7984ERC20WrapperMock is ERC7984ERC20Wrapper, ZamaEthereumConfig {
+contract ERC7984ERC20WrapperMock is ERC7984ERC20Wrapper, ZamaEthereumConfig, ERC7984Mock {
     constructor(
         IERC20 token,
         string memory name,
         string memory symbol,
         string memory uri
-    ) ERC7984ERC20Wrapper(token) ERC7984(name, symbol, uri) {}
+    ) ERC7984ERC20Wrapper(token) ERC7984Mock(name, symbol, uri) {}
+
+    function supportsInterface(bytes4 interfaceId) public view override(ERC7984ERC20Wrapper, ERC7984) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+
+    function decimals() public view override(ERC7984ERC20Wrapper, ERC7984) returns (uint8) {
+        return super.decimals();
+    }
+
+    function _update(
+        address from,
+        address to,
+        euint64 amount
+    ) internal virtual override(ERC7984ERC20Wrapper, ERC7984Mock) returns (euint64) {
+        return super._update(from, to, amount);
+    }
 }

contracts/mocks/token/ERC7984Mock.sol

@@ -73,6 +73,10 @@ contract ERC7984Mock is ERC7984, ZamaEthereumConfig {
         return _transferAndCall(from, to, FHE.fromExternal(encryptedAmount, inputProof), data);
     }
 
+    function $_burn(address from, uint64 amount) public returns (euint64 transferred) {
+        return _burn(from, FHE.asEuint64(amount));
+    }
+
     function $_burn(
         address from,
         externalEuint64 encryptedAmount,