Create test evm contract

[freesig]

Write / generate a solidity contract with a single function that:

• takes action sets at calldata
• inserts the message sender as the first input for each action in the set
• hashes the action set with the previous input hash and updates the latest input hash
• has a function to read the current input hash
• emits the input hash as a log

input hash lives in the contracts state

• deploy on base testnet

[freesig]

A super basic generated contract:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title ActionProcessor
 * @dev A contract that processes action sets, inserts the message sender as the first input for each action,
 * hashes the modified set with the previous input hash, and updates the state.
 */
contract ActionProcessor {
    // Storage for the latest input hash
    bytes32 public latestInputHash;
    
    // Event to emit when input hash is updated
    event InputHashUpdated(bytes32 inputHash, address sender);
    
    // Struct to represent a predicate address as two addresses (40 bytes total)
    struct PredicateAddress {
        address contract;
        address predicate;
    }
    
    /**
     * @dev Constructor that initializes the latest input hash to bytes32(0).
     */
    constructor() {
        latestInputHash = bytes32(0);
    }
    
    /**
     * @dev Processes an action set, inserts the message sender as the first input for each action,
     * hashes the action set with the previous input hash, and updates the latest input hash.
     * @param predicatesToSolve An array of predicate addresses, each consisting of two parts.
     * @param inputsPerAction A 2D array of inputs, where inputsPerAction[i] contains the inputs for the ith action.
     */
    function processActionSet(
        PredicateAddress[] calldata predicatesToSolve,
        bytes[][] calldata inputsPerAction
    ) external {
        require(predicatesToSolve.length == inputsPerAction.length, "Mismatched arrays");
        
        // Start with the previous input hash
        bytes32 newInputHash = latestInputHash;
        
        // Process each action in the set
        for (uint i = 0; i < predicatesToSolve.length; i++) {
            // Create a modified action by inserting msg.sender as the first input
            bytes[] memory modifiedInputs = new bytes[](inputsPerAction[i].length + 1);
            modifiedInputs[0] = abi.encodePacked(msg.sender);
            
            for (uint j = 0; j < inputsPerAction[i].length; j++) {
                modifiedInputs[j + 1] = inputsPerAction[i][j];
            }
            
            // Hash the modified action and combine it with the new input hash
            newInputHash = keccak256(abi.encodePacked(
                newInputHash,
                predicatesToSolve[i].contract,
                predicatesToSolve[i].predicate
                abi.encode(modifiedInputs)
            ));
        }
        
        // Update the latest input hash
        latestInputHash = newInputHash;
        
        // Emit the input hash and sender as a log
        emit InputHashUpdated(newInputHash, msg.sender);
    }
    
    /**
     * @dev Returns the current input hash.
     * @return The current input hash.
     */
    function getCurrentInputHash() external view returns (bytes32) {
        return latestInputHash;
    }
}