merge queue: embarking main (e3c8453) and [#1808 + #1840] together

.github/workflows/test-suite-e2e-tests.yml

@@ -190,6 +190,11 @@ jobs:
         run: |
           ./fhevm-cli test user-decryption
 
+      - name: Delegated User Decryption test
+        working-directory: test-suite/fhevm
+        run: |
+          ./fhevm-cli test delegated-user-decryption
+
       - name: ERC20 test
         working-directory: test-suite/fhevm
         run: |
@@ -205,11 +210,6 @@ jobs:
         run: |
           ./fhevm-cli test public-decrypt-http-mixed
 
-      - name: Delegate User Decryption (partial test)
-        working-directory: test-suite/fhevm
-        run: |
-          ./fhevm-cli test delegate-user-decryption
-
       - name: Random operators test (subset)
         working-directory: test-suite/fhevm
         run: |

.gitignore

@@ -32,6 +32,8 @@ logs/
 .env.*
 !.env.example
 !.env.sample
+# Allow shared env templates in subprojects
+!test-suite/e2e/.env.devnet
 # If you have .env files specific to subprojects, e.g. subproject/.env,
 # the .env rule above will catch them.
 

test-suite/e2e/.env.devnet

@@ -0,0 +1,31 @@
+#
+# CONTRACT ADDRESS OVERRIDE CONFIGURATION
+#
+# If the runtime Hardhat network selected via the --network flag (e.g., 'devnet')
+# matches the value defined here, all contract addresses and URLs below
+# will OVERRIDE any default or previously loaded configuration.
+FHEVM_HARDHAT_NETWORK="devnet"
+
+# Gateway
+INPUT_VERIFICATION_ADDRESS="0xf091D9B4C2da7ecd11858cDD1F4515a8a767D755"
+DECRYPTION_ADDRESS="0xA4dc265D54D25D41565c60d36097E8955B03decD"
+# Host
+ACL_CONTRACT_ADDRESS="0xBCA6F8De823a399Dc431930FD5EE550Bf1C0013e"
+KMS_VERIFIER_CONTRACT_ADDRESS="0x3F3819BeBE4bD0EFEf8078Df6f9B574ADa80CCA4"
+INPUT_VERIFIER_CONTRACT_ADDRESS="0x6B32f47E39B0F8bE8bEAD5B8990F62E3e28ac08d"
+FHEVM_EXECUTOR_CONTRACT_ADDRESS="0x5cc8c5A366E733d4f1e677B2A9C08Bc2ea49b302"
+HCU_LIMIT_CONTRACT_ADDRESS="0xb8E70273De41498aAF047fd73ae1F3025D8709f8"
+RELAYER_URL="https://relayer.dev.zama.cloud"
+
+# Hardhat account seed (used for hardhat/anvil/sepolia)
+MNEMONIC="test test test test test test test test test test test junk"
+
+# Provider keys
+INFURA_API_KEY=""
+ETHERSCAN_API_KEY=""
+
+# Required: authorized caller addresses for Numeric deploy (comma-separated list)
+AUTHORIZED_CALLER_ADDRESSES=""
+
+# Optional: set a specific payment token for SimplifiedAuction deploys
+SIMPLIFIED_AUCTION_PAYMENT_TOKEN=""

test-suite/e2e/.env.example

@@ -1,4 +1,9 @@
 MNEMONIC="adapt mosquito move limb mobile illegal tree voyage juice mosquito burger raise father hope layer"
+RPC_URL=""
+SEPOLIA_ETH_RPC_URL=""
+MAINNET_ETH_RPC_URL=""
+RELAYER_URL=""
+ZAMA_FHEVM_API_KEY=""
 # Gateway
 CHAIN_ID_GATEWAY="54321"
 CHAIN_ID_HOST="12345"
@@ -9,5 +14,13 @@ ACL_CONTRACT_ADDRESS="0x05fD9B5EFE0a996095f42Ed7e77c390810CF660c"
 KMS_VERIFIER_CONTRACT_ADDRESS="0xcCAe95fF1d11656358E782570dF0418F59fA40e1"
 INPUT_VERIFIER_CONTRACT_ADDRESS="0xa1880e99d86F081E8D3868A8C4732C8f65dfdB11"
 FHEVM_EXECUTOR_CONTRACT_ADDRESS="0x12B064FB845C1cc05e9493856a1D637a73e944bE"
+TEST_INPUT_CONTRACT_ADDRESS=""
 
 HARDHAT_NETWORK="staging"
+
+# Smoke runner (optional)
+BETTERSTACK_HEARTBEAT_URL=""
+# SMOKE_DEPLOY_CONTRACT=1
+# SMOKE_RUN_TESTS=1
+# SMOKE_TX_TIMEOUT_SECS=48
+# SMOKE_DECRYPT_TIMEOUT_SECS=120

test-suite/e2e/README.md

@@ -11,3 +11,77 @@ REPORT_GAS=true npx hardhat test
 npx hardhat node
 npx hardhat ignition deploy ./ignition/modules/Lock.ts
 ```
+
+## Smoke runner (inputFlow)
+
+Runs a single on-chain smoke flow (input + add42 + decrypt) using Hardhat as a runtime
+and hardened transaction handling.
+
+### Prereqs
+
+**For sepolia/mainnet**, most config is auto-populated from the SDK (`SepoliaConfig`/`MainnetConfig`).
+You only need:
+
+- `RPC_URL` (or `SEPOLIA_ETH_RPC_URL` / `MAINNET_ETH_RPC_URL`)
+- `MNEMONIC`
+- `ZAMA_FHEVM_API_KEY` (mainnet only)
+
+**For devnet**, use the pre-configured `.env.devnet` (all addresses included):
+
+```shell
+DOTENV_CONFIG_PATH=./.env.devnet npx hardhat run --network devnet scripts/smoke-inputflow.ts
+```
+
+**For other networks** (staging, custom), set all variables manually - see `.env.example`.
+
+Network-specific RPC URLs:
+
+- staging/zwsDev: `RPC_URL` (defaults to localhost:8545)
+- sepolia: `SEPOLIA_ETH_RPC_URL` (falls back to `RPC_URL`)
+- mainnet: `MAINNET_ETH_RPC_URL` (falls back to `RPC_URL`)
+
+For pod deployments, just set `RPC_URL` - it works for all networks.
+
+Set `TEST_INPUT_CONTRACT_ADDRESS` to reuse an existing contract (requires `SMOKE_DEPLOY_CONTRACT=0`).
+
+Hardhat loads env from `test-suite/e2e/.env` by default; override with `DOTENV_CONFIG_PATH`.
+You can also store secrets with Hardhat vars, e.g. `npx hardhat vars set SEPOLIA_ETH_RPC_URL` (it will prompt for the value).
+For devnet, `test-suite/e2e/.env.devnet` provides a ready baseline (use `DOTENV_CONFIG_PATH=./.env.devnet`).
+
+### Signer configuration
+
+The smoke runner uses HD wallet signers derived from `MNEMONIC`. By default, it uses indices `0,1,2`
+for automatic failover - if one signer has a stuck transaction, it falls back to another.
+
+**Important:** All configured signers should be funded for maximum resilience. The script logs all
+available signers at startup with their balances and warns if any have low balance (< 0.1 ETH).
+
+To derive signer addresses from a mnemonic (for funding):
+```shell
+# Using Foundry's cast
+cast wallet address --mnemonic "your mnemonic here" --mnemonic-index 0
+cast wallet address --mnemonic "your mnemonic here" --mnemonic-index 1
+cast wallet address --mnemonic "your mnemonic here" --mnemonic-index 2
+```
+
+### Smoke-specific knobs (defaults in parentheses)
+
+- `SMOKE_SIGNER_INDICES` (`0,1,2`) - comma-separated list of signer indices to use for failover
+- `SMOKE_TX_TIMEOUT_SECS` (`48`)
+- `SMOKE_TX_MAX_RETRIES` (`2`)
+- `SMOKE_FEE_BUMP` (`1.125^4`)
+- `SMOKE_MAX_BACKLOG` (`3`)
+- `SMOKE_CANCEL_BACKLOG` (`1`) - set to `0` to disable auto-cancel of pending transactions
+- `SMOKE_DEPLOY_CONTRACT` (`1`) - set to `0` to attach to existing contract via `TEST_INPUT_CONTRACT_ADDRESS`
+- `SMOKE_RUN_TESTS` (`1`) - set to `0` to deploy contract only without running tests
+- `SMOKE_DECRYPT_TIMEOUT_SECS` (`120`) - timeout for decryption operations
+- `BETTERSTACK_HEARTBEAT_URL` (optional) - if set, pings BetterStack on success; reports error with exit code on failure
+
+### Run
+
+```shell
+cd test-suite/e2e
+npx hardhat run --network zwsDev scripts/smoke-inputflow.ts
+npx hardhat run --network sepolia scripts/smoke-inputflow.ts
+npx hardhat run --network mainnet scripts/smoke-inputflow.ts
+```

test-suite/e2e/contracts/E2ECoprocessorConfigLocal.sol

@@ -4,6 +4,8 @@ pragma solidity ^0.8.24;
 import {CoprocessorConfig, FHE} from "@fhevm/solidity/lib/FHE.sol";
 
 library DefaultCoprocessorConfig {
+    /// @dev These addresses are placeholders. They are patched at runtime via sed
+    /// in the E2E test runner script with the actual deployment addresses.
     function getConfig() internal pure returns (CoprocessorConfig memory) {
         return
             CoprocessorConfig({

test-suite/e2e/contracts/SmartWalletWithDelegation.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.24;
+
+import "@fhevm/solidity/lib/FHE.sol";
+import {E2ECoprocessorConfig} from "./E2ECoprocessorConfigLocal.sol";
+
+/// @notice SmartWallet contract that supports delegated user decryption.
+contract SmartWalletWithDelegation is E2ECoprocessorConfig {
+    struct Transaction {
+        address target;
+        bytes data;
+    }
+
+    event ProposedTx(uint256 indexed txId, address target, bytes data);
+
+    uint256 public txCounter;
+    address public owner;
+    mapping(uint256 => Transaction) public transactions;
+    mapping(uint256 => bool) public executed;
+
+    constructor(address _owner) {
+        require(_owner != address(0), "Owner cannot be zero address");
+        owner = _owner;
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Sender is not the owner");
+        _;
+    }
+
+    /// @notice Propose a transaction and assume as approved (since there's only one owner).
+    /// @param target The target contract address
+    /// @param data The calldata to execute
+    function proposeTx(address target, bytes calldata data) external onlyOwner returns (uint256) {
+        txCounter++;
+        uint256 txId = txCounter;
+        transactions[txCounter] = Transaction({target: target, data: data});
+        emit ProposedTx(txId, target, data);
+        return txId;
+    }
+
+    /// @notice Execute a previously proposed transaction.
+    /// @param txId The transaction ID to execute.
+    function executeTx(uint256 txId) external onlyOwner {
+        require(txId != 0 && txId <= txCounter, "Invalid txId");
+        require(!executed[txId], "tx has already been executed");
+        Transaction memory transaction = transactions[txId];
+
+        (bool success, ) = (transaction.target).call(transaction.data);
+        require(success, "tx reverted");
+        executed[txId] = true;
+    }
+
+    /// @notice Delegate user decryption for a specific contract.
+    /// @dev This allows an EOA to decrypt confidential data owned by this smart wallet.
+    /// @param delegate The address that will be able to user decrypt.
+    /// @param delegateContractAddress The contract address for which delegation applies.
+    /// @param expirationTimestamp When the delegation expires.
+    function delegateUserDecryption(
+        address delegate,
+        address delegateContractAddress,
+        uint64 expirationTimestamp
+    ) external onlyOwner {
+        FHE.delegateUserDecryption(delegate, delegateContractAddress, expirationTimestamp);
+    }
+
+    /// @notice Revoke a previously granted delegation.
+    /// @param delegate The address to revoke delegation from.
+    /// @param delegateContractAddress The contract address for which to revoke delegation.
+    function revokeUserDecryptionDelegation(address delegate, address delegateContractAddress) external onlyOwner {
+        FHE.revokeUserDecryptionDelegation(delegate, delegateContractAddress);
+    }
+}

test-suite/e2e/contracts/smoke/SmokeTestInput.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+
+pragma solidity ^0.8.24;
+
+import "@fhevm/solidity/lib/FHE.sol";
+import {CoprocessorConfig} from "@fhevm/solidity/lib/Impl.sol";
+
+/// @notice Smoke test contract with constructor-based coprocessor config injection.
+/// @dev Unlike TestInput.sol which uses E2ECoprocessorConfig (sed-patched at runtime),
+/// this contract receives addresses at deploy time, enabling smoke tests to run on
+/// devnet, sepolia, and mainnet without sed patching.
+contract SmokeTestInput {
+    euint64 public resUint64;
+
+    constructor(address aclAddress, address coprocessorAddress, address kmsVerifierAddress) {
+        FHE.setCoprocessor(
+            CoprocessorConfig({
+                ACLAddress: aclAddress,
+                CoprocessorAddress: coprocessorAddress,
+                KMSVerifierAddress: kmsVerifierAddress
+            })
+        );
+    }
+
+    function requestUint64NonTrivial(externalEuint64 inputHandle, bytes calldata inputProof) public {
+        resUint64 = FHE.fromExternal(inputHandle, inputProof);
+        FHE.allowThis(resUint64);
+    }
+
+    // Adds a trivially-encrypted 42 to the user-provided encrypted uint64 input.
+    function add42ToInput64(externalEuint64 inputHandle, bytes calldata inputProof) public {
+        euint64 input = FHE.fromExternal(inputHandle, inputProof);
+        euint64 trivial42 = FHE.asEuint64(42);
+        resUint64 = FHE.add(input, trivial42);
+        FHE.allowThis(resUint64);
+        FHE.allow(resUint64, msg.sender);
+        FHE.makePubliclyDecryptable(resUint64);
+    }
+}

test-suite/e2e/contracts/TestInput.sol → test-suite/e2e/contracts/smoke/TestInput.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.8.24;
 
 import "@fhevm/solidity/lib/FHE.sol";
-import {E2ECoprocessorConfig} from "./E2ECoprocessorConfigLocal.sol";
+import {E2ECoprocessorConfig} from "../E2ECoprocessorConfigLocal.sol";
 
 contract TestInput is E2ECoprocessorConfig {
     euint64 public resUint64;