ReactorHelper

{{
  "language": "Solidity",
  "sources": {
    "contracts/interfaces/IReactorHelper.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;

struct ReactorParameter {
    string name;
    string value;
}

struct ReactorWebRequest {
    string method;
    string url;
    string body;
    ReactorParameter[] headers;
}

interface IReactorHelper {
    function decodeGenerateRandomNumbersRequestData(bytes memory _payload) external returns (uint256);
    function decodeGenerateRandomNumbersResponseData(bytes memory _payload) external returns (uint256[] memory);
    function decodePayloadAndReactorParameters(bytes memory _payload) external pure returns (bytes memory, ReactorParameter[] memory);
    function decodePayloadAndStringParameters(bytes memory _payload) external pure returns (bytes memory, string[] memory, string[] memory);
    function decodeWebRequestAndReactorParameters(bytes memory _payload) external pure returns (string memory, string memory, string memory, ReactorParameter[] memory);
    function decodeWebRequestAndStringParameters(bytes memory _payload) external pure returns (string memory, string memory, string memory, string[] memory, string[] memory);
    function decodeWebRequestData(bytes memory _payload) external pure returns (string memory,string memory, string memory);
    function decodeWebResponseData(bytes memory _payload) external pure returns (uint256, string memory, string[] memory, string[] memory);
    function encodeGenerateRandomNumbersRequestAndStringParameters(uint256 _number_of_randoms_to_create, string[] memory _parameterNames, string[] memory _parameterValues) external returns(bytes memory);
    function encodeGenerateRandomNumbersRequestData(uint256 _number_of_randoms_to_create) external returns(bytes memory);
    function encodePayloadAndReactorParameters(bytes memory _payload, ReactorParameter[] memory _parameters) external pure returns(bytes memory);
    function encodePayloadAndStringParameters(bytes memory _payload, string[] memory _parameterNames, string[] memory _parameterValues) external pure returns(bytes memory);
    function encodeWebRequestAndReactorParameters(string calldata _method, string calldata _url, string calldata _body, ReactorParameter[] memory _headers, ReactorParameter[] memory _parameters) external pure returns(bytes memory);
    function encodeWebRequestAndStringParameters(string calldata _method, string calldata _url, string calldata _body, string[] memory _headerNames, string[] memory _headerValues, string[] memory _parameterNames, string[] memory _parameterValues) external pure returns(bytes memory);
    function encodeWebRequestData(string calldata _method, string calldata _url, string calldata _body) external pure returns(bytes memory);
    function encodeWebRequestFromReactorWebRequest(ReactorWebRequest calldata _request, ReactorParameter[] calldata _parameters) external pure returns(bytes memory);
}"
    },
    "contracts/ReactorHelper.sol": {
      "content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;

import {IReactorHelper, ReactorWebRequest, ReactorParameter} from "./interfaces/IReactorHelper.sol";

contract ReactorHelper is IReactorHelper
{
    function decodePayloadAndStringParameters(bytes memory _payload) public pure returns (bytes memory, string[] memory, string[] memory)
    {
        return abi.decode(_payload, (bytes, string[], string[]));
    }
    
    function decodePayloadAndReactorParameters(bytes memory _payload) public pure returns (bytes memory, ReactorParameter[] memory)
    {
        (bytes memory payload, string[] memory parameterNames, string[] memory parameterValues) = decodePayloadAndStringParameters(_payload);
        require(parameterNames.length == parameterValues.length, "Parameter name and value lengths must match");
        
        ReactorParameter[] memory parameters = new ReactorParameter[](parameterNames.length);
        for (uint256 i = 0; i < parameterNames.length; i++ ) {
            require(bytes(parameterNames[i]).length > 0, "Empty parameter name");
            require(bytes(parameterValues[i]).length > 0, "Empty parameter value");
            
            parameters[i] = ReactorParameter({name: parameterNames[i], value: parameterValues[i]});
        }
        
        return (payload, parameters);
    }
    
    function decodeWebRequestAndStringParameters(bytes memory _payload) public pure returns (string memory, string memory, string memory, string[] memory, string[] memory)
    {
        (bytes memory payload, string[] memory parameterNames, string[] memory parameterValues) = decodePayloadAndStringParameters(_payload);
        (string memory method, string memory url, string memory body) = abi.decode(payload, (string, string, string));
        return (method, url, body, parameterNames, parameterValues);
    }
    
    function decodeWebRequestAndReactorParameters(bytes memory _payload) public pure returns (string memory, string memory, string memory, ReactorParameter[] memory)
    {
        (bytes memory payload, ReactorParameter[] memory parameters) = decodePayloadAndReactorParameters(_payload);
        (string memory method, string memory url, string memory body) = abi.decode(payload, (string, string, string));
        return (method, url, body, parameters);
    }
    
    function decodeWebRequestData(bytes memory _payload) public pure returns (string memory,string memory, string memory)
    {
        return abi.decode(_payload, (string, string, string));
    }
    
    function decodeGenerateRandomNumbersResponseData(bytes memory _payload) public pure returns (uint256[] memory)
    {
        return abi.decode(_payload, (uint256[]));
    }
    
    function decodeGenerateRandomNumbersRequestData(bytes memory _payload) public pure returns (uint256)
    {
        return abi.decode(_payload, (uint256));
    }
    
    function decodeWebResponseData(bytes memory _payload) public pure returns (uint256, string memory, string[] memory, string[] memory)
    {
        return abi.decode(_payload, (uint256, string, string[], string[]));
    }
    
    function encodePayloadAndStringParameters(bytes memory _payload, string[] memory _parameterNames, string[] memory _parameterValues) public pure returns(bytes memory)
    {
        require(_parameterNames.length == _parameterValues.length, "Parameter name and value lengths must match");

        for (uint256 i = 0; i < _parameterNames.length; i++ ) {
            require(bytes(_parameterNames[i]).length > 0, "Empty parameter name");
            require(bytes(_parameterValues[i]).length > 0, "Empty parameter value");
        }

        return abi.encode(_payload, _parameterNames, _parameterValues);
    }
    
    function encodePayloadAndReactorParameters(bytes memory _payload, ReactorParameter[] memory _parameters) public pure returns(bytes memory)
    {
        string[] memory parameterNames = new string[](_parameters.length);
        string[] memory parameterValues = new string[](_parameters.length);
        for (uint256 i = 0; i < parameterNames.length; i++ ) {
            parameterNames[i] = _parameters[i].name;
            parameterValues[i] = _parameters[i].value;
        }

        return encodePayloadAndStringParameters(_payload, parameterNames, parameterValues);
    }
    
    function encodeWebRequestAndStringParameters(string calldata _method, string calldata _url, string calldata _body, string[] memory _headerNames, string[] memory _headerValues, string[] memory _parameterNames, string[] memory _parameterValues) public pure returns(bytes memory)
    {
        require(_headerNames.length == _headerValues.length, "Header name and value lengths must match");
        require(_parameterNames.length == _parameterValues.length, "Parameter name and value lengths must match");
        
        uint256 parameterListLength = _headerNames.length + _parameterNames.length;
        string[] memory parameterNames = new string[](parameterListLength);
        string[] memory parameterValues = new string[](parameterListLength);
        
        for (uint256 i = 0; i < _headerNames.length; i++ ) {
            parameterNames[i] = string.concat("header.", _headerNames[i]);
            parameterValues[i] = _headerValues[i];
        }
        
        for (uint256 j = 0; j < _parameterNames.length; j++ ) {
            parameterNames[j + _headerNames.length] = _parameterNames[j];
            parameterValues[j + _headerNames.length] = _parameterValues[j];
        }
        
        return encodePayloadAndStringParameters(encodeWebRequestData(_method, _url, _body), parameterNames, parameterValues);
    }
    
    function encodeWebRequestAndReactorParameters(string calldata _method, string calldata _url, string calldata _body, ReactorParameter[] memory _headers, ReactorParameter[] memory _parameters) public pure returns(bytes memory)
    {
        string[] memory headerNames = new string[](_headers.length);
        string[] memory headerValues = new string[](_headers.length);
        for (uint256 i = 0; i < _headers.length; i++ ) {
            headerNames[i] = _headers[i].name;
            headerValues[i] = _headers[i].value;
        }
        
        string[] memory parameterNames = new string[](_parameters.length);
        string[] memory parameterValues = new string[](_parameters.length);
        for (uint256 j = 0; j < parameterNames.length; j++ ) {
            parameterNames[j] = _parameters[j].name;
            parameterValues[j] = _parameters[j].value;
        }
        
        return encodeWebRequestAndStringParameters(_method, _url, _body, headerNames, headerValues, parameterNames, parameterValues);
    }
    
    function encodeWebRequestFromReactorWebRequest(ReactorWebRequest calldata _request, ReactorParameter[] calldata _parameters) public pure returns(bytes memory)
    {
        return encodeWebRequestAndReactorParameters(_request.method, _request.url, _request.body, _request.headers, _parameters);
    }
    
    function encodeWebRequestData(string calldata _method, string calldata _url, string calldata _body) public pure returns(bytes memory)
    {
        require(bytes(_method).length > 0, "Empty method");
        require(bytes(_url).length > 0, "Empty url");
        
        return abi.encode(_method, _url, _body);
    }
    
    function encodeGenerateRandomNumbersRequestAndStringParameters(uint256 _number_of_randoms_to_create, string[] memory _parameterNames, string[] memory _parameterValues) public pure returns(bytes memory)
    {
        require(_parameterNames.length == _parameterValues.length, "Parameter name and value lengths must match");
        
        return encodePayloadAndStringParameters(encodeGenerateRandomNumbersRequestData(_number_of_randoms_to_create), _parameterNames, _parameterValues);
    }
    
    function encodeGenerateRandomNumbersRequestAndReactorParameters(uint256 _number_of_randoms_to_create, ReactorParameter[] memory _parameters) public pure returns(bytes memory)
    {
        string[] memory parameterNames = new string[](_parameters.length);
        string[] memory parameterValues = new string[](_parameters.length);
        for (uint256 i = 0; i < parameterNames.length; i++ ) {
            parameterNames[i] = _parameters[i].name;
            parameterValues[i] = _parameters[i].value;
        }
        
        return encodeGenerateRandomNumbersRequestAndStringParameters(_number_of_randoms_to_create, parameterNames, parameterValues);
    }
    
    function encodeGenerateRandomNumbersRequestData(uint256 _number_of_randoms_to_create) public pure returns(bytes memory)
    {
        require(_number_of_randoms_to_create > 0, "Number of randoms to create must be greater than zero");
        
        return abi.encode(_number_of_randoms_to_create);
    }
    
    receive() external payable {}
    fallback() external payable {}
}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 10000
    },
    "viaIR": true,
    "evmVersion": "paris",
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}}