diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000..a81f31474 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +bindings/src/codegen/** linguist-generated=true diff --git a/.gitignore b/.gitignore index d0f849d53..85c6c605d 100644 --- a/.gitignore +++ b/.gitignore @@ -49,6 +49,7 @@ configs/ # Contract Bindings **/codegen +!bindings/src/codegen/ # Grafana alloy config config.alloy diff --git a/Cargo.lock b/Cargo.lock index 7e840763e..47ea5a446 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7411,6 +7411,7 @@ dependencies = [ "num-format", "op-alloy-consensus", "op-alloy-network", + "op-succinct-bindings", "op-succinct-client-utils", "op-succinct-elfs", "opentelemetry 0.23.0", diff --git a/bindings/build.rs b/bindings/build.rs index 51782fb62..e1cfabf3d 100644 --- a/bindings/build.rs +++ b/bindings/build.rs @@ -21,13 +21,22 @@ fn main() -> anyhow::Result<()> { println!("cargo:rerun-if-changed={}", contracts_package_path.join("remappings.txt")); println!("cargo:rerun-if-changed={}", contracts_package_path.join("foundry.toml")); - // Check if forge is available - if Command::new("forge").arg("--version").output().is_err() { - println!("cargo:warning=Forge not found in PATH. Skipping bindings generation."); - return Ok(()); + // Check if forge is available; skip regeneration if not (e.g. Docker builds). + // CI jobs with forge (cargo-tests, lint) will catch ABI drift. + let forge_check = Command::new("forge").arg("--version").output(); + match forge_check { + Err(_) => { + println!("cargo:warning=Forge not found in PATH. Skipping bindings generation."); + return Ok(()); + } + Ok(output) if !output.status.success() => { + anyhow::bail!( + "Forge is installed but returned an error. Check your Foundry installation." + ); + } + Ok(_) => {} // forge available, continue } - // Use 'forge bind' to generate bindings for only the contracts we need for E2E tests let mut forge_command = Command::new("forge"); forge_command.args([ "bind", @@ -38,8 +47,8 @@ fn main() -> anyhow::Result<()> { "--skip-extra-derives", ]); - // Only generate bindings for the contracts we actually need for E2E testing let required_contracts = [ + // E2E test contracts "DisputeGameFactory", "SuperchainConfig", "MockOptimismPortal2", @@ -49,10 +58,14 @@ fn main() -> anyhow::Result<()> { "OPSuccinctFaultDisputeGame", "ERC1967Proxy", "MockPermissionedDisputeGame", - // Also include interfaces that we need + // Interfaces "IDisputeGameFactory", "IDisputeGame", "IFaultDisputeGame", + "IAnchorStateRegistry", + // Production contracts (host utils) + "OPSuccinctL2OutputOracle", + "OPSuccinctDisputeGame", ]; // Create a regex pattern that matches any of our required contracts diff --git a/bindings/src/codegen/access_manager.rs b/bindings/src/codegen/access_manager.rs new file mode 100644 index 000000000..1358582ed --- /dev/null +++ b/bindings/src/codegen/access_manager.rs @@ -0,0 +1,3987 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface AccessManager { + event ChallengerPermissionUpdated(address indexed challenger, bool allowed); + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + event ProposerPermissionUpdated(address indexed proposer, bool allowed); + + constructor(uint256 _fallbackTimeout, address _disputeGameFactory); + + function DEPLOYMENT_TIMESTAMP() external view returns (uint256); + function DISPUTE_GAME_FACTORY() external view returns (address); + function FALLBACK_TIMEOUT() external view returns (uint256); + function challengers(address) external view returns (bool); + function getLastProposalTimestamp() external view returns (uint256); + function isAllowedChallenger(address _challenger) external view returns (bool allowed_); + function isAllowedProposer(address _proposer) external view returns (bool allowed_); + function isProposalPermissionlessMode() external view returns (bool); + function owner() external view returns (address); + function proposers(address) external view returns (bool); + function renounceOwnership() external; + function setChallenger(address _challenger, bool _allowed) external; + function setProposer(address _proposer, bool _allowed) external; + function transferOwnership(address newOwner) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_fallbackTimeout", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_disputeGameFactory", + "type": "address", + "internalType": "contract IDisputeGameFactory" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "DEPLOYMENT_TIMESTAMP", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "DISPUTE_GAME_FACTORY", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IDisputeGameFactory" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "FALLBACK_TIMEOUT", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "challengers", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getLastProposalTimestamp", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isAllowedChallenger", + "inputs": [ + { + "name": "_challenger", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "allowed_", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isAllowedProposer", + "inputs": [ + { + "name": "_proposer", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "allowed_", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isProposalPermissionlessMode", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proposers", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setChallenger", + "inputs": [ + { + "name": "_challenger", + "type": "address", + "internalType": "address" + }, + { + "name": "_allowed", + "type": "bool", + "internalType": "bool" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setProposer", + "inputs": [ + { + "name": "_proposer", + "type": "address", + "internalType": "address" + }, + { + "name": "_allowed", + "type": "bool", + "internalType": "bool" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "ChallengerPermissionUpdated", + "inputs": [ + { + "name": "challenger", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "allowed", + "type": "bool", + "indexed": false, + "internalType": "bool" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ProposerPermissionUpdated", + "inputs": [ + { + "name": "proposer", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "allowed", + "type": "bool", + "indexed": false, + "internalType": "bool" + } + ], + "anonymous": false + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod AccessManager { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60e06040523480156200001157600080fd5b506040516200130638038062001306833981810160405281019062000037919062000228565b620000576200004b620000a360201b60201c565b620000ab60201b60201c565b81608081815250508073ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff16815250504260c0818152505050506200026f565b600033905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b600080fd5b6000819050919050565b620001898162000174565b81146200019557600080fd5b50565b600081519050620001a9816200017e565b92915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000620001dc82620001af565b9050919050565b6000620001f082620001cf565b9050919050565b6200020281620001e3565b81146200020e57600080fd5b50565b6000815190506200022281620001f7565b92915050565b600080604083850312156200024257620002416200016f565b5b6000620002528582860162000198565b9250506020620002658582860162000211565b9150509250929050565b60805160a05160c051611036620002d0600039600081816104c0015281816105c6015281816105ee0152818161067801526108f40152600081816103fa01528181610427015261050601526000818161032c015261079c01526110366000f3fe608060405234801561001057600080fd5b50600436106100ea5760003560e01c806392b5d1901161008c578063e9ed9b6411610066578063e9ed9b641461023b578063f2fde38b14610257578063fbc6def714610273578063ff59ae7d14610291576100ea565b806392b5d190146101d1578063cfea71c0146101ed578063d33b35051461021d576100ea565b8063715018a6116100c8578063715018a61461016d57806382ff53a1146101775780638620689d146101955780638da5cb5b146101b3576100ea565b80630c8b0fdf146100ef578063181774971461010d5780631d3225e31461013d575b600080fd5b6100f76102c1565b6040516101049190610b39565b60405180910390f35b61012760048036038101906101229190610bb7565b61035f565b6040516101349190610b39565b60405180910390f35b61015760048036038101906101529190610bb7565b61037f565b6040516101649190610b39565b60405180910390f35b6101756103e4565b005b61017f6103f8565b60405161018c9190610c43565b60405180910390f35b61019d61041c565b6040516101aa9190610c77565b60405180910390f35b6101bb6106a0565b6040516101c89190610ca1565b60405180910390f35b6101eb60048036038101906101e69190610ce8565b6106c9565b005b61020760048036038101906102029190610bb7565b61077a565b6040516102149190610b39565b60405180910390f35b61022561079a565b6040516102329190610c77565b60405180910390f35b61025560048036038101906102509190610ce8565b6107be565b005b610271600480360381019061026c9190610bb7565b61086f565b005b61027b6108f2565b6040516102889190610c77565b60405180910390f35b6102ab60048036038101906102a69190610bb7565b610916565b6040516102b89190610b39565b60405180910390f35b6000600160008073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff161561031e576001905061035c565b600061032861041c565b90507f000000000000000000000000000000000000000000000000000000000000000081426103579190610d57565b119150505b90565b60016020528060005260406000206000915054906101000a900460ff1681565b6000600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16806103dd57506103dc6102c1565b5b9050919050565b6103ec6109c0565b6103f66000610a3e565b565b7f000000000000000000000000000000000000000000000000000000000000000081565b600080602a905060007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16634d1975b46040518163ffffffff1660e01b8152600401602060405180830381865afa158015610490573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104b49190610db7565b9050600081036104e8577f00000000000000000000000000000000000000000000000000000000000000009250505061069d565b60006001826104f79190610d57565b90505b600115610676576000807f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663bb8aa1fc846040518263ffffffff1660e01b815260040161055d9190610c77565b606060405180830381865afa15801561057a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061059e9190610e9e565b509150915060006105b88267ffffffffffffffff16610b02565b67ffffffffffffffff1690507f000000000000000000000000000000000000000000000000000000000000000081101561061a577f0000000000000000000000000000000000000000000000000000000000000000965050505050505061069d565b6106298663ffffffff16610b0c565b63ffffffff1661063e8463ffffffff16610b0c565b63ffffffff16036106575780965050505050505061069d565b6000840361066757505050610676565b836001900393505050506104fa565b7f000000000000000000000000000000000000000000000000000000000000000093505050505b90565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6106d16109c0565b80600260008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508173ffffffffffffffffffffffffffffffffffffffff167f761bede702fa6507fd979a5c4213a8d5d38b47ae9f7736506eafe9149c6c6b778260405161076e9190610b39565b60405180910390a25050565b60026020528060005260406000206000915054906101000a900460ff1681565b7f000000000000000000000000000000000000000000000000000000000000000081565b6107c66109c0565b80600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508173ffffffffffffffffffffffffffffffffffffffff167f205b4586f0aad63e3849b0c69893bd6139aca673e7f16088c504691c6502cee4826040516108639190610b39565b60405180910390a25050565b6108776109c0565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16036108e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108dd90610f74565b60405180910390fd5b6108ef81610a3e565b50565b7f000000000000000000000000000000000000000000000000000000000000000081565b6000600260008073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16806109b95750600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff165b9050919050565b6109c8610b16565b73ffffffffffffffffffffffffffffffffffffffff166109e66106a0565b73ffffffffffffffffffffffffffffffffffffffff1614610a3c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a3390610fe0565b60405180910390fd5b565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000819050919050565b6000819050919050565b600033905090565b60008115159050919050565b610b3381610b1e565b82525050565b6000602082019050610b4e6000830184610b2a565b92915050565b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000610b8482610b59565b9050919050565b610b9481610b79565b8114610b9f57600080fd5b50565b600081359050610bb181610b8b565b92915050565b600060208284031215610bcd57610bcc610b54565b5b6000610bdb84828501610ba2565b91505092915050565b6000819050919050565b6000610c09610c04610bff84610b59565b610be4565b610b59565b9050919050565b6000610c1b82610bee565b9050919050565b6000610c2d82610c10565b9050919050565b610c3d81610c22565b82525050565b6000602082019050610c586000830184610c34565b92915050565b6000819050919050565b610c7181610c5e565b82525050565b6000602082019050610c8c6000830184610c68565b92915050565b610c9b81610b79565b82525050565b6000602082019050610cb66000830184610c92565b92915050565b610cc581610b1e565b8114610cd057600080fd5b50565b600081359050610ce281610cbc565b92915050565b60008060408385031215610cff57610cfe610b54565b5b6000610d0d85828601610ba2565b9250506020610d1e85828601610cd3565b9150509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000610d6282610c5e565b9150610d6d83610c5e565b925082821015610d8057610d7f610d28565b5b828203905092915050565b610d9481610c5e565b8114610d9f57600080fd5b50565b600081519050610db181610d8b565b92915050565b600060208284031215610dcd57610dcc610b54565b5b6000610ddb84828501610da2565b91505092915050565b600063ffffffff82169050919050565b610dfd81610de4565b8114610e0857600080fd5b50565b600081519050610e1a81610df4565b92915050565b600067ffffffffffffffff82169050919050565b610e3d81610e20565b8114610e4857600080fd5b50565b600081519050610e5a81610e34565b92915050565b6000610e6b82610b79565b9050919050565b610e7b81610e60565b8114610e8657600080fd5b50565b600081519050610e9881610e72565b92915050565b600080600060608486031215610eb757610eb6610b54565b5b6000610ec586828701610e0b565b9350506020610ed686828701610e4b565b9250506040610ee786828701610e89565b9150509250925092565b600082825260208201905092915050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b6000610f5e602683610ef1565b9150610f6982610f02565b604082019050919050565b60006020820190508181036000830152610f8d81610f51565b9050919050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b6000610fca602083610ef1565b9150610fd582610f94565b602082019050919050565b60006020820190508181036000830152610ff981610fbd565b905091905056fea2646970667358221220fdeec4a6c3e4ff2c581b2544217a113008375feeb4f22ab7d1f06056bf172c1e64736f6c634300080f0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\xE0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0\x13\x068\x03\x80b\0\x13\x06\x839\x81\x81\x01`@R\x81\x01\x90b\0\x007\x91\x90b\0\x02(V[b\0\0Wb\0\0Kb\0\0\xA3` \x1B` \x1CV[b\0\0\xAB` \x1B` \x1CV[\x81`\x80\x81\x81RPP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\xA0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPPB`\xC0\x81\x81RPPPPb\0\x02oV[`\x003\x90P\x90V[`\0\x80`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81`\0\x80a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0`@Q`@Q\x80\x91\x03\x90\xA3PPV[`\0\x80\xFD[`\0\x81\x90P\x91\x90PV[b\0\x01\x89\x81b\0\x01tV[\x81\x14b\0\x01\x95W`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x01\xA9\x81b\0\x01~V[\x92\x91PPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0b\0\x01\xDC\x82b\0\x01\xAFV[\x90P\x91\x90PV[`\0b\0\x01\xF0\x82b\0\x01\xCFV[\x90P\x91\x90PV[b\0\x02\x02\x81b\0\x01\xE3V[\x81\x14b\0\x02\x0EW`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x02\"\x81b\0\x01\xF7V[\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15b\0\x02BWb\0\x02Ab\0\x01oV[[`\0b\0\x02R\x85\x82\x86\x01b\0\x01\x98V[\x92PP` b\0\x02e\x85\x82\x86\x01b\0\x02\x11V[\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Q`\xC0Qa\x106b\0\x02\xD0`\09`\0\x81\x81a\x04\xC0\x01R\x81\x81a\x05\xC6\x01R\x81\x81a\x05\xEE\x01R\x81\x81a\x06x\x01Ra\x08\xF4\x01R`\0\x81\x81a\x03\xFA\x01R\x81\x81a\x04'\x01Ra\x05\x06\x01R`\0\x81\x81a\x03,\x01Ra\x07\x9C\x01Ra\x106`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xEAW`\x005`\xE0\x1C\x80c\x92\xB5\xD1\x90\x11a\0\x8CW\x80c\xE9\xED\x9Bd\x11a\0fW\x80c\xE9\xED\x9Bd\x14a\x02;W\x80c\xF2\xFD\xE3\x8B\x14a\x02WW\x80c\xFB\xC6\xDE\xF7\x14a\x02sW\x80c\xFFY\xAE}\x14a\x02\x91Wa\0\xEAV[\x80c\x92\xB5\xD1\x90\x14a\x01\xD1W\x80c\xCF\xEAq\xC0\x14a\x01\xEDW\x80c\xD3;5\x05\x14a\x02\x1DWa\0\xEAV[\x80cqP\x18\xA6\x11a\0\xC8W\x80cqP\x18\xA6\x14a\x01mW\x80c\x82\xFFS\xA1\x14a\x01wW\x80c\x86 h\x9D\x14a\x01\x95W\x80c\x8D\xA5\xCB[\x14a\x01\xB3Wa\0\xEAV[\x80c\x0C\x8B\x0F\xDF\x14a\0\xEFW\x80c\x18\x17t\x97\x14a\x01\rW\x80c\x1D2%\xE3\x14a\x01=W[`\0\x80\xFD[a\0\xF7a\x02\xC1V[`@Qa\x01\x04\x91\x90a\x0B9V[`@Q\x80\x91\x03\x90\xF3[a\x01'`\x04\x806\x03\x81\x01\x90a\x01\"\x91\x90a\x0B\xB7V[a\x03_V[`@Qa\x014\x91\x90a\x0B9V[`@Q\x80\x91\x03\x90\xF3[a\x01W`\x04\x806\x03\x81\x01\x90a\x01R\x91\x90a\x0B\xB7V[a\x03\x7FV[`@Qa\x01d\x91\x90a\x0B9V[`@Q\x80\x91\x03\x90\xF3[a\x01ua\x03\xE4V[\0[a\x01\x7Fa\x03\xF8V[`@Qa\x01\x8C\x91\x90a\x0CCV[`@Q\x80\x91\x03\x90\xF3[a\x01\x9Da\x04\x1CV[`@Qa\x01\xAA\x91\x90a\x0CwV[`@Q\x80\x91\x03\x90\xF3[a\x01\xBBa\x06\xA0V[`@Qa\x01\xC8\x91\x90a\x0C\xA1V[`@Q\x80\x91\x03\x90\xF3[a\x01\xEB`\x04\x806\x03\x81\x01\x90a\x01\xE6\x91\x90a\x0C\xE8V[a\x06\xC9V[\0[a\x02\x07`\x04\x806\x03\x81\x01\x90a\x02\x02\x91\x90a\x0B\xB7V[a\x07zV[`@Qa\x02\x14\x91\x90a\x0B9V[`@Q\x80\x91\x03\x90\xF3[a\x02%a\x07\x9AV[`@Qa\x022\x91\x90a\x0CwV[`@Q\x80\x91\x03\x90\xF3[a\x02U`\x04\x806\x03\x81\x01\x90a\x02P\x91\x90a\x0C\xE8V[a\x07\xBEV[\0[a\x02q`\x04\x806\x03\x81\x01\x90a\x02l\x91\x90a\x0B\xB7V[a\x08oV[\0[a\x02{a\x08\xF2V[`@Qa\x02\x88\x91\x90a\x0CwV[`@Q\x80\x91\x03\x90\xF3[a\x02\xAB`\x04\x806\x03\x81\x01\x90a\x02\xA6\x91\x90a\x0B\xB7V[a\t\x16V[`@Qa\x02\xB8\x91\x90a\x0B9V[`@Q\x80\x91\x03\x90\xF3[`\0`\x01`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a\x03\x1EW`\x01\x90Pa\x03\\V[`\0a\x03(a\x04\x1CV[\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ba\x03W\x91\x90a\rWV[\x11\x91PP[\x90V[`\x01` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x80a\x03\xDDWPa\x03\xDCa\x02\xC1V[[\x90P\x91\x90PV[a\x03\xECa\t\xC0V[a\x03\xF6`\0a\n>V[V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0\x80`*\x90P`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cM\x19u\xB4`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\x90W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\xB4\x91\x90a\r\xB7V[\x90P`\0\x81\x03a\x04\xE8W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPPa\x06\x9DV[`\0`\x01\x82a\x04\xF7\x91\x90a\rWV[\x90P[`\x01\x15a\x06vW`\0\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBB\x8A\xA1\xFC\x84`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x05]\x91\x90a\x0CwV[```@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05zW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x9E\x91\x90a\x0E\x9EV[P\x91P\x91P`\0a\x05\xB8\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0B\x02V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x10\x15a\x06\x1AW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96PPPPPPPa\x06\x9DV[a\x06)\x86c\xFF\xFF\xFF\xFF\x16a\x0B\x0CV[c\xFF\xFF\xFF\xFF\x16a\x06>\x84c\xFF\xFF\xFF\xFF\x16a\x0B\x0CV[c\xFF\xFF\xFF\xFF\x16\x03a\x06WW\x80\x96PPPPPPPa\x06\x9DV[`\0\x84\x03a\x06gWPPPa\x06vV[\x83`\x01\x90\x03\x93PPPPa\x04\xFAV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93PPPP[\x90V[`\0\x80`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x90V[a\x06\xD1a\t\xC0V[\x80`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7Fv\x1B\xED\xE7\x02\xFAe\x07\xFD\x97\x9A\\B\x13\xA8\xD5\xD3\x8BG\xAE\x9Fw6Pn\xAF\xE9\x14\x9Clkw\x82`@Qa\x07n\x91\x90a\x0B9V[`@Q\x80\x91\x03\x90\xA2PPV[`\x02` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x07\xC6a\t\xC0V[\x80`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F [E\x86\xF0\xAA\xD6>8I\xB0\xC6\x98\x93\xBDa9\xAC\xA6s\xE7\xF1`\x88\xC5\x04i\x1Ce\x02\xCE\xE4\x82`@Qa\x08c\x91\x90a\x0B9V[`@Q\x80\x91\x03\x90\xA2PPV[a\x08wa\t\xC0V[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x08\xE6W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x08\xDD\x90a\x0FtV[`@Q\x80\x91\x03\x90\xFD[a\x08\xEF\x81a\n>V[PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0`\x02`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x80a\t\xB9WP`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16[\x90P\x91\x90PV[a\t\xC8a\x0B\x16V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\t\xE6a\x06\xA0V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\nV[V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0\x80`*\x90P`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cM\x19u\xB4`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\x90W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\xB4\x91\x90a\r\xB7V[\x90P`\0\x81\x03a\x04\xE8W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x92PPPa\x06\x9DV[`\0`\x01\x82a\x04\xF7\x91\x90a\rWV[\x90P[`\x01\x15a\x06vW`\0\x80\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBB\x8A\xA1\xFC\x84`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x05]\x91\x90a\x0CwV[```@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05zW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x9E\x91\x90a\x0E\x9EV[P\x91P\x91P`\0a\x05\xB8\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0B\x02V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81\x10\x15a\x06\x1AW\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x96PPPPPPPa\x06\x9DV[a\x06)\x86c\xFF\xFF\xFF\xFF\x16a\x0B\x0CV[c\xFF\xFF\xFF\xFF\x16a\x06>\x84c\xFF\xFF\xFF\xFF\x16a\x0B\x0CV[c\xFF\xFF\xFF\xFF\x16\x03a\x06WW\x80\x96PPPPPPPa\x06\x9DV[`\0\x84\x03a\x06gWPPPa\x06vV[\x83`\x01\x90\x03\x93PPPPa\x04\xFAV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93PPPP[\x90V[`\0\x80`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x90V[a\x06\xD1a\t\xC0V[\x80`\x02`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7Fv\x1B\xED\xE7\x02\xFAe\x07\xFD\x97\x9A\\B\x13\xA8\xD5\xD3\x8BG\xAE\x9Fw6Pn\xAF\xE9\x14\x9Clkw\x82`@Qa\x07n\x91\x90a\x0B9V[`@Q\x80\x91\x03\x90\xA2PPV[`\x02` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x07\xC6a\t\xC0V[\x80`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F [E\x86\xF0\xAA\xD6>8I\xB0\xC6\x98\x93\xBDa9\xAC\xA6s\xE7\xF1`\x88\xC5\x04i\x1Ce\x02\xCE\xE4\x82`@Qa\x08c\x91\x90a\x0B9V[`@Q\x80\x91\x03\x90\xA2PPV[a\x08wa\t\xC0V[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x08\xE6W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x08\xDD\x90a\x0FtV[`@Q\x80\x91\x03\x90\xFD[a\x08\xEF\x81a\n>V[PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`\0`\x02`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x80a\t\xB9WP`\x02`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16[\x90P\x91\x90PV[a\t\xC8a\x0B\x16V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\t\xE6a\x06\xA0V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\n = (alloy::sol_types::sol_data::Bool,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "ChallengerPermissionUpdated(address,bool)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 118u8, 27u8, 237u8, 231u8, 2u8, 250u8, 101u8, 7u8, 253u8, 151u8, 154u8, + 92u8, 66u8, 19u8, 168u8, 213u8, 211u8, 139u8, 71u8, 174u8, 159u8, 119u8, + 54u8, 80u8, 110u8, 175u8, 233u8, 20u8, 156u8, 108u8, 107u8, 119u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + challenger: topics.1, + allowed: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.allowed, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.challenger.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.challenger, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for ChallengerPermissionUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ChallengerPermissionUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &ChallengerPermissionUpdated, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`. +```solidity +event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct OwnershipTransferred { + #[allow(missing_docs)] + pub previousOwner: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub newOwner: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "OwnershipTransferred(address,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, + 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, + 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.previousOwner.clone(), + self.newOwner.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::encode_topic( + &self.newOwner, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OwnershipTransferred { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `ProposerPermissionUpdated(address,bool)` and selector `0x205b4586f0aad63e3849b0c69893bd6139aca673e7f16088c504691c6502cee4`. +```solidity +event ProposerPermissionUpdated(address indexed proposer, bool allowed); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct ProposerPermissionUpdated { + #[allow(missing_docs)] + pub proposer: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub allowed: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for ProposerPermissionUpdated { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "ProposerPermissionUpdated(address,bool)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 32u8, 91u8, 69u8, 134u8, 240u8, 170u8, 214u8, 62u8, 56u8, 73u8, 176u8, + 198u8, 152u8, 147u8, 189u8, 97u8, 57u8, 172u8, 166u8, 115u8, 231u8, + 241u8, 96u8, 136u8, 197u8, 4u8, 105u8, 28u8, 101u8, 2u8, 206u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + proposer: topics.1, + allowed: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.allowed, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.proposer.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.proposer, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for ProposerPermissionUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ProposerPermissionUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &ProposerPermissionUpdated, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(uint256 _fallbackTimeout, address _disputeGameFactory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _fallbackTimeout: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _disputeGameFactory: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._fallbackTimeout, value._disputeGameFactory) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _fallbackTimeout: tuple.0, + _disputeGameFactory: tuple.1, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._fallbackTimeout), + ::tokenize( + &self._disputeGameFactory, + ), + ) + } + } + }; + /**Function with signature `DEPLOYMENT_TIMESTAMP()` and selector `0xfbc6def7`. +```solidity +function DEPLOYMENT_TIMESTAMP() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct DEPLOYMENT_TIMESTAMPCall; + ///Container type for the return parameters of the [`DEPLOYMENT_TIMESTAMP()`](DEPLOYMENT_TIMESTAMPCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct DEPLOYMENT_TIMESTAMPReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: DEPLOYMENT_TIMESTAMPCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for DEPLOYMENT_TIMESTAMPCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: DEPLOYMENT_TIMESTAMPReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for DEPLOYMENT_TIMESTAMPReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for DEPLOYMENT_TIMESTAMPCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "DEPLOYMENT_TIMESTAMP()"; + const SELECTOR: [u8; 4] = [251u8, 198u8, 222u8, 247u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: DEPLOYMENT_TIMESTAMPReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: DEPLOYMENT_TIMESTAMPReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `DISPUTE_GAME_FACTORY()` and selector `0x82ff53a1`. +```solidity +function DISPUTE_GAME_FACTORY() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct DISPUTE_GAME_FACTORYCall; + ///Container type for the return parameters of the [`DISPUTE_GAME_FACTORY()`](DISPUTE_GAME_FACTORYCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct DISPUTE_GAME_FACTORYReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: DISPUTE_GAME_FACTORYCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for DISPUTE_GAME_FACTORYCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: DISPUTE_GAME_FACTORYReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for DISPUTE_GAME_FACTORYReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for DISPUTE_GAME_FACTORYCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "DISPUTE_GAME_FACTORY()"; + const SELECTOR: [u8; 4] = [130u8, 255u8, 83u8, 161u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: DISPUTE_GAME_FACTORYReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: DISPUTE_GAME_FACTORYReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `FALLBACK_TIMEOUT()` and selector `0xd33b3505`. +```solidity +function FALLBACK_TIMEOUT() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FALLBACK_TIMEOUTCall; + ///Container type for the return parameters of the [`FALLBACK_TIMEOUT()`](FALLBACK_TIMEOUTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FALLBACK_TIMEOUTReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: FALLBACK_TIMEOUTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for FALLBACK_TIMEOUTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: FALLBACK_TIMEOUTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for FALLBACK_TIMEOUTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for FALLBACK_TIMEOUTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "FALLBACK_TIMEOUT()"; + const SELECTOR: [u8; 4] = [211u8, 59u8, 53u8, 5u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: FALLBACK_TIMEOUTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: FALLBACK_TIMEOUTReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `challengers(address)` and selector `0xcfea71c0`. +```solidity +function challengers(address) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengersCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`challengers(address)`](challengersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengersReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: challengersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for challengersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: challengersReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for challengersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for challengersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "challengers(address)"; + const SELECTOR: [u8; 4] = [207u8, 234u8, 113u8, 192u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: challengersReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: challengersReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `getLastProposalTimestamp()` and selector `0x8620689d`. +```solidity +function getLastProposalTimestamp() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getLastProposalTimestampCall; + ///Container type for the return parameters of the [`getLastProposalTimestamp()`](getLastProposalTimestampCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getLastProposalTimestampReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getLastProposalTimestampCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getLastProposalTimestampCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getLastProposalTimestampReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getLastProposalTimestampReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getLastProposalTimestampCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getLastProposalTimestamp()"; + const SELECTOR: [u8; 4] = [134u8, 32u8, 104u8, 157u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getLastProposalTimestampReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getLastProposalTimestampReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isAllowedChallenger(address)` and selector `0xff59ae7d`. +```solidity +function isAllowedChallenger(address _challenger) external view returns (bool allowed_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isAllowedChallengerCall { + #[allow(missing_docs)] + pub _challenger: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isAllowedChallenger(address)`](isAllowedChallengerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isAllowedChallengerReturn { + #[allow(missing_docs)] + pub allowed_: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isAllowedChallengerCall) -> Self { + (value._challenger,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isAllowedChallengerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _challenger: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isAllowedChallengerReturn) -> Self { + (value.allowed_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isAllowedChallengerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { allowed_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isAllowedChallengerCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isAllowedChallenger(address)"; + const SELECTOR: [u8; 4] = [255u8, 89u8, 174u8, 125u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._challenger, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isAllowedChallengerReturn = r.into(); + r.allowed_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isAllowedChallengerReturn = r.into(); + r.allowed_ + }) + } + } + }; + /**Function with signature `isAllowedProposer(address)` and selector `0x1d3225e3`. +```solidity +function isAllowedProposer(address _proposer) external view returns (bool allowed_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isAllowedProposerCall { + #[allow(missing_docs)] + pub _proposer: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isAllowedProposer(address)`](isAllowedProposerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isAllowedProposerReturn { + #[allow(missing_docs)] + pub allowed_: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isAllowedProposerCall) -> Self { + (value._proposer,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isAllowedProposerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _proposer: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isAllowedProposerReturn) -> Self { + (value.allowed_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isAllowedProposerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { allowed_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isAllowedProposerCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isAllowedProposer(address)"; + const SELECTOR: [u8; 4] = [29u8, 50u8, 37u8, 227u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._proposer, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isAllowedProposerReturn = r.into(); + r.allowed_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isAllowedProposerReturn = r.into(); + r.allowed_ + }) + } + } + }; + /**Function with signature `isProposalPermissionlessMode()` and selector `0x0c8b0fdf`. +```solidity +function isProposalPermissionlessMode() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isProposalPermissionlessModeCall; + ///Container type for the return parameters of the [`isProposalPermissionlessMode()`](isProposalPermissionlessModeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isProposalPermissionlessModeReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isProposalPermissionlessModeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isProposalPermissionlessModeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isProposalPermissionlessModeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isProposalPermissionlessModeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isProposalPermissionlessModeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isProposalPermissionlessMode()"; + const SELECTOR: [u8; 4] = [12u8, 139u8, 15u8, 223u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isProposalPermissionlessModeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isProposalPermissionlessModeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `owner()` and selector `0x8da5cb5b`. +```solidity +function owner() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ownerCall; + ///Container type for the return parameters of the [`owner()`](ownerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ownerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proposers(address)` and selector `0x18177497`. +```solidity +function proposers(address) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proposersCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`proposers(address)`](proposersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proposersReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proposersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proposersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proposersReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proposersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proposersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proposers(address)"; + const SELECTOR: [u8; 4] = [24u8, 23u8, 116u8, 151u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proposersReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proposersReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `renounceOwnership()` and selector `0x715018a6`. +```solidity +function renounceOwnership() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct renounceOwnershipCall; + ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct renounceOwnershipReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl renounceOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for renounceOwnershipCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = renounceOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "renounceOwnership()"; + const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + renounceOwnershipReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setChallenger(address,bool)` and selector `0x92b5d190`. +```solidity +function setChallenger(address _challenger, bool _allowed) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setChallengerCall { + #[allow(missing_docs)] + pub _challenger: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _allowed: bool, + } + ///Container type for the return parameters of the [`setChallenger(address,bool)`](setChallengerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setChallengerReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bool, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, bool); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setChallengerCall) -> Self { + (value._challenger, value._allowed) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setChallengerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _challenger: tuple.0, + _allowed: tuple.1, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setChallengerReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setChallengerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setChallengerReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setChallengerCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bool, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setChallengerReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setChallenger(address,bool)"; + const SELECTOR: [u8; 4] = [146u8, 181u8, 209u8, 144u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._challenger, + ), + ::tokenize( + &self._allowed, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setChallengerReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setProposer(address,bool)` and selector `0xe9ed9b64`. +```solidity +function setProposer(address _proposer, bool _allowed) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setProposerCall { + #[allow(missing_docs)] + pub _proposer: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _allowed: bool, + } + ///Container type for the return parameters of the [`setProposer(address,bool)`](setProposerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setProposerReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bool, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, bool); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setProposerCall) -> Self { + (value._proposer, value._allowed) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setProposerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _proposer: tuple.0, + _allowed: tuple.1, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setProposerReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setProposerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setProposerReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setProposerCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bool, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setProposerReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setProposer(address,bool)"; + const SELECTOR: [u8; 4] = [233u8, 237u8, 155u8, 100u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._proposer, + ), + ::tokenize( + &self._allowed, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setProposerReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`. +```solidity +function transferOwnership(address newOwner) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct transferOwnershipCall { + #[allow(missing_docs)] + pub newOwner: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct transferOwnershipReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value.newOwner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newOwner: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.newOwner, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + transferOwnershipReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`AccessManager`](self) function calls. + #[derive(Clone)] + pub enum AccessManagerCalls { + #[allow(missing_docs)] + DEPLOYMENT_TIMESTAMP(DEPLOYMENT_TIMESTAMPCall), + #[allow(missing_docs)] + DISPUTE_GAME_FACTORY(DISPUTE_GAME_FACTORYCall), + #[allow(missing_docs)] + FALLBACK_TIMEOUT(FALLBACK_TIMEOUTCall), + #[allow(missing_docs)] + challengers(challengersCall), + #[allow(missing_docs)] + getLastProposalTimestamp(getLastProposalTimestampCall), + #[allow(missing_docs)] + isAllowedChallenger(isAllowedChallengerCall), + #[allow(missing_docs)] + isAllowedProposer(isAllowedProposerCall), + #[allow(missing_docs)] + isProposalPermissionlessMode(isProposalPermissionlessModeCall), + #[allow(missing_docs)] + owner(ownerCall), + #[allow(missing_docs)] + proposers(proposersCall), + #[allow(missing_docs)] + renounceOwnership(renounceOwnershipCall), + #[allow(missing_docs)] + setChallenger(setChallengerCall), + #[allow(missing_docs)] + setProposer(setProposerCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + } + impl AccessManagerCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [12u8, 139u8, 15u8, 223u8], + [24u8, 23u8, 116u8, 151u8], + [29u8, 50u8, 37u8, 227u8], + [113u8, 80u8, 24u8, 166u8], + [130u8, 255u8, 83u8, 161u8], + [134u8, 32u8, 104u8, 157u8], + [141u8, 165u8, 203u8, 91u8], + [146u8, 181u8, 209u8, 144u8], + [207u8, 234u8, 113u8, 192u8], + [211u8, 59u8, 53u8, 5u8], + [233u8, 237u8, 155u8, 100u8], + [242u8, 253u8, 227u8, 139u8], + [251u8, 198u8, 222u8, 247u8], + [255u8, 89u8, 174u8, 125u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(isProposalPermissionlessMode), + ::core::stringify!(proposers), + ::core::stringify!(isAllowedProposer), + ::core::stringify!(renounceOwnership), + ::core::stringify!(DISPUTE_GAME_FACTORY), + ::core::stringify!(getLastProposalTimestamp), + ::core::stringify!(owner), + ::core::stringify!(setChallenger), + ::core::stringify!(challengers), + ::core::stringify!(FALLBACK_TIMEOUT), + ::core::stringify!(setProposer), + ::core::stringify!(transferOwnership), + ::core::stringify!(DEPLOYMENT_TIMESTAMP), + ::core::stringify!(isAllowedChallenger), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for AccessManagerCalls { + const NAME: &'static str = "AccessManagerCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 14usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::DEPLOYMENT_TIMESTAMP(_) => { + ::SELECTOR + } + Self::DISPUTE_GAME_FACTORY(_) => { + ::SELECTOR + } + Self::FALLBACK_TIMEOUT(_) => { + ::SELECTOR + } + Self::challengers(_) => { + ::SELECTOR + } + Self::getLastProposalTimestamp(_) => { + ::SELECTOR + } + Self::isAllowedChallenger(_) => { + ::SELECTOR + } + Self::isAllowedProposer(_) => { + ::SELECTOR + } + Self::isProposalPermissionlessMode(_) => { + ::SELECTOR + } + Self::owner(_) => ::SELECTOR, + Self::proposers(_) => { + ::SELECTOR + } + Self::renounceOwnership(_) => { + ::SELECTOR + } + Self::setChallenger(_) => { + ::SELECTOR + } + Self::setProposer(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isProposalPermissionlessMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::isProposalPermissionlessMode) + } + isProposalPermissionlessMode + }, + { + fn proposers( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AccessManagerCalls::proposers) + } + proposers + }, + { + fn isAllowedProposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::isAllowedProposer) + } + isAllowedProposer + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn DISPUTE_GAME_FACTORY( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::DISPUTE_GAME_FACTORY) + } + DISPUTE_GAME_FACTORY + }, + { + fn getLastProposalTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::getLastProposalTimestamp) + } + getLastProposalTimestamp + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AccessManagerCalls::owner) + } + owner + }, + { + fn setChallenger( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::setChallenger) + } + setChallenger + }, + { + fn challengers( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::challengers) + } + challengers + }, + { + fn FALLBACK_TIMEOUT( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::FALLBACK_TIMEOUT) + } + FALLBACK_TIMEOUT + }, + { + fn setProposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::setProposer) + } + setProposer + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::transferOwnership) + } + transferOwnership + }, + { + fn DEPLOYMENT_TIMESTAMP( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::DEPLOYMENT_TIMESTAMP) + } + DEPLOYMENT_TIMESTAMP + }, + { + fn isAllowedChallenger( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AccessManagerCalls::isAllowedChallenger) + } + isAllowedChallenger + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isProposalPermissionlessMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::isProposalPermissionlessMode) + } + isProposalPermissionlessMode + }, + { + fn proposers( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::proposers) + } + proposers + }, + { + fn isAllowedProposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::isAllowedProposer) + } + isAllowedProposer + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn DISPUTE_GAME_FACTORY( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::DISPUTE_GAME_FACTORY) + } + DISPUTE_GAME_FACTORY + }, + { + fn getLastProposalTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::getLastProposalTimestamp) + } + getLastProposalTimestamp + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::owner) + } + owner + }, + { + fn setChallenger( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::setChallenger) + } + setChallenger + }, + { + fn challengers( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::challengers) + } + challengers + }, + { + fn FALLBACK_TIMEOUT( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::FALLBACK_TIMEOUT) + } + FALLBACK_TIMEOUT + }, + { + fn setProposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::setProposer) + } + setProposer + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::transferOwnership) + } + transferOwnership + }, + { + fn DEPLOYMENT_TIMESTAMP( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::DEPLOYMENT_TIMESTAMP) + } + DEPLOYMENT_TIMESTAMP + }, + { + fn isAllowedChallenger( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AccessManagerCalls::isAllowedChallenger) + } + isAllowedChallenger + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::DEPLOYMENT_TIMESTAMP(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::DISPUTE_GAME_FACTORY(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::FALLBACK_TIMEOUT(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::challengers(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getLastProposalTimestamp(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isAllowedChallenger(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isAllowedProposer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isProposalPermissionlessMode(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::proposers(inner) => { + ::abi_encoded_size(inner) + } + Self::renounceOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setChallenger(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setProposer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::DEPLOYMENT_TIMESTAMP(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::DISPUTE_GAME_FACTORY(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::FALLBACK_TIMEOUT(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::challengers(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getLastProposalTimestamp(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isAllowedChallenger(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isAllowedProposer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isProposalPermissionlessMode(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::proposers(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::renounceOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setChallenger(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setProposer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`AccessManager`](self) events. + #[derive(Clone)] + pub enum AccessManagerEvents { + #[allow(missing_docs)] + ChallengerPermissionUpdated(ChallengerPermissionUpdated), + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + #[allow(missing_docs)] + ProposerPermissionUpdated(ProposerPermissionUpdated), + } + impl AccessManagerEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 32u8, 91u8, 69u8, 134u8, 240u8, 170u8, 214u8, 62u8, 56u8, 73u8, 176u8, + 198u8, 152u8, 147u8, 189u8, 97u8, 57u8, 172u8, 166u8, 115u8, 231u8, + 241u8, 96u8, 136u8, 197u8, 4u8, 105u8, 28u8, 101u8, 2u8, 206u8, 228u8, + ], + [ + 118u8, 27u8, 237u8, 231u8, 2u8, 250u8, 101u8, 7u8, 253u8, 151u8, 154u8, + 92u8, 66u8, 19u8, 168u8, 213u8, 211u8, 139u8, 71u8, 174u8, 159u8, 119u8, + 54u8, 80u8, 110u8, 175u8, 233u8, 20u8, 156u8, 108u8, 107u8, 119u8, + ], + [ + 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, + 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, + 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(ProposerPermissionUpdated), + ::core::stringify!(ChallengerPermissionUpdated), + ::core::stringify!(OwnershipTransferred), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for AccessManagerEvents { + const NAME: &'static str = "AccessManagerEvents"; + const COUNT: usize = 3usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ChallengerPermissionUpdated) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ProposerPermissionUpdated) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for AccessManagerEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::ChallengerPermissionUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::ProposerPermissionUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::ChallengerPermissionUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::ProposerPermissionUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`AccessManager`](self) contract instance. + +See the [wrapper's documentation](`AccessManagerInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> AccessManagerInstance { + AccessManagerInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _fallbackTimeout: alloy::sol_types::private::primitives::aliases::U256, + _disputeGameFactory: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + AccessManagerInstance::< + P, + N, + >::deploy(__provider, _fallbackTimeout, _disputeGameFactory) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _fallbackTimeout: alloy::sol_types::private::primitives::aliases::U256, + _disputeGameFactory: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + AccessManagerInstance::< + P, + N, + >::deploy_builder(__provider, _fallbackTimeout, _disputeGameFactory) + } + /**A [`AccessManager`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`AccessManager`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct AccessManagerInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for AccessManagerInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("AccessManagerInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AccessManagerInstance { + /**Creates a new wrapper around an on-chain [`AccessManager`](self) contract instance. + +See the [wrapper's documentation](`AccessManagerInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + _fallbackTimeout: alloy::sol_types::private::primitives::aliases::U256, + _disputeGameFactory: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + __provider, + _fallbackTimeout, + _disputeGameFactory, + ); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder( + __provider: P, + _fallbackTimeout: alloy::sol_types::private::primitives::aliases::U256, + _disputeGameFactory: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _fallbackTimeout, + _disputeGameFactory, + }, + )[..], + ] + .concat() + .into(), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl AccessManagerInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> AccessManagerInstance { + AccessManagerInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AccessManagerInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`DEPLOYMENT_TIMESTAMP`] function. + pub fn DEPLOYMENT_TIMESTAMP( + &self, + ) -> alloy_contract::SolCallBuilder<&P, DEPLOYMENT_TIMESTAMPCall, N> { + self.call_builder(&DEPLOYMENT_TIMESTAMPCall) + } + ///Creates a new call builder for the [`DISPUTE_GAME_FACTORY`] function. + pub fn DISPUTE_GAME_FACTORY( + &self, + ) -> alloy_contract::SolCallBuilder<&P, DISPUTE_GAME_FACTORYCall, N> { + self.call_builder(&DISPUTE_GAME_FACTORYCall) + } + ///Creates a new call builder for the [`FALLBACK_TIMEOUT`] function. + pub fn FALLBACK_TIMEOUT( + &self, + ) -> alloy_contract::SolCallBuilder<&P, FALLBACK_TIMEOUTCall, N> { + self.call_builder(&FALLBACK_TIMEOUTCall) + } + ///Creates a new call builder for the [`challengers`] function. + pub fn challengers( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, challengersCall, N> { + self.call_builder(&challengersCall(_0)) + } + ///Creates a new call builder for the [`getLastProposalTimestamp`] function. + pub fn getLastProposalTimestamp( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getLastProposalTimestampCall, N> { + self.call_builder(&getLastProposalTimestampCall) + } + ///Creates a new call builder for the [`isAllowedChallenger`] function. + pub fn isAllowedChallenger( + &self, + _challenger: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isAllowedChallengerCall, N> { + self.call_builder( + &isAllowedChallengerCall { + _challenger, + }, + ) + } + ///Creates a new call builder for the [`isAllowedProposer`] function. + pub fn isAllowedProposer( + &self, + _proposer: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isAllowedProposerCall, N> { + self.call_builder(&isAllowedProposerCall { _proposer }) + } + ///Creates a new call builder for the [`isProposalPermissionlessMode`] function. + pub fn isProposalPermissionlessMode( + &self, + ) -> alloy_contract::SolCallBuilder<&P, isProposalPermissionlessModeCall, N> { + self.call_builder(&isProposalPermissionlessModeCall) + } + ///Creates a new call builder for the [`owner`] function. + pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> { + self.call_builder(&ownerCall) + } + ///Creates a new call builder for the [`proposers`] function. + pub fn proposers( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, proposersCall, N> { + self.call_builder(&proposersCall(_0)) + } + ///Creates a new call builder for the [`renounceOwnership`] function. + pub fn renounceOwnership( + &self, + ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> { + self.call_builder(&renounceOwnershipCall) + } + ///Creates a new call builder for the [`setChallenger`] function. + pub fn setChallenger( + &self, + _challenger: alloy::sol_types::private::Address, + _allowed: bool, + ) -> alloy_contract::SolCallBuilder<&P, setChallengerCall, N> { + self.call_builder( + &setChallengerCall { + _challenger, + _allowed, + }, + ) + } + ///Creates a new call builder for the [`setProposer`] function. + pub fn setProposer( + &self, + _proposer: alloy::sol_types::private::Address, + _allowed: bool, + ) -> alloy_contract::SolCallBuilder<&P, setProposerCall, N> { + self.call_builder( + &setProposerCall { + _proposer, + _allowed, + }, + ) + } + ///Creates a new call builder for the [`transferOwnership`] function. + pub fn transferOwnership( + &self, + newOwner: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> { + self.call_builder(&transferOwnershipCall { newOwner }) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AccessManagerInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`ChallengerPermissionUpdated`] event. + pub fn ChallengerPermissionUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, ChallengerPermissionUpdated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`ProposerPermissionUpdated`] event. + pub fn ProposerPermissionUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, ProposerPermissionUpdated, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/anchor_state_registry.rs b/bindings/src/codegen/anchor_state_registry.rs new file mode 100644 index 000000000..398b1c162 --- /dev/null +++ b/bindings/src/codegen/anchor_state_registry.rs @@ -0,0 +1,8904 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface AnchorStateRegistry { + type GameType is uint32; + type Hash is bytes32; + struct Proposal { + Hash root; + uint256 l2SequenceNumber; + } + + error AnchorStateRegistry_InvalidAnchorGame(); + error AnchorStateRegistry_Unauthorized(); + error ProxyAdminOwnedBase_NotProxyAdmin(); + error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); + error ProxyAdminOwnedBase_NotProxyAdminOwner(); + error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); + error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); + error ProxyAdminOwnedBase_ProxyAdminNotFound(); + error ReinitializableBase_ZeroInitVersion(); + + event AnchorUpdated(address indexed game); + event DisputeGameBlacklisted(address indexed disputeGame); + event Initialized(uint8 version); + event RespectedGameTypeSet(GameType gameType); + event RetirementTimestampSet(uint256 timestamp); + + constructor(uint256 _disputeGameFinalityDelaySeconds); + + function anchorGame() external view returns (address); + function anchors(GameType) external view returns (Hash, uint256); + function blacklistDisputeGame(address _disputeGame) external; + function disputeGameBlacklist(address) external view returns (bool); + function disputeGameFactory() external view returns (address); + function disputeGameFinalityDelaySeconds() external view returns (uint256); + function getAnchorRoot() external view returns (Hash, uint256); + function initVersion() external view returns (uint8); + function initialize(address _systemConfig, address _disputeGameFactory, Proposal memory _startingAnchorRoot, GameType _startingRespectedGameType) external; + function isGameBlacklisted(address _game) external view returns (bool); + function isGameClaimValid(address _game) external view returns (bool); + function isGameFinalized(address _game) external view returns (bool); + function isGameProper(address _game) external view returns (bool); + function isGameRegistered(address _game) external view returns (bool); + function isGameResolved(address _game) external view returns (bool); + function isGameRespected(address _game) external view returns (bool); + function isGameRetired(address _game) external view returns (bool); + function paused() external view returns (bool); + function proxyAdmin() external view returns (address); + function proxyAdminOwner() external view returns (address); + function respectedGameType() external view returns (GameType); + function retirementTimestamp() external view returns (uint64); + function setAnchorState(address _game) external; + function setRespectedGameType(GameType _gameType) external; + function superchainConfig() external view returns (address); + function systemConfig() external view returns (address); + function updateRetirementTimestamp() external; + function version() external view returns (string memory); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_disputeGameFinalityDelaySeconds", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "anchorGame", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IFaultDisputeGame" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "anchors", + "inputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "Hash" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "blacklistDisputeGame", + "inputs": [ + { + "name": "_disputeGame", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "disputeGameBlacklist", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "disputeGameFactory", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IDisputeGameFactory" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "disputeGameFinalityDelaySeconds", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getAnchorRoot", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "Hash" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initVersion", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [ + { + "name": "_systemConfig", + "type": "address", + "internalType": "contract ISystemConfig" + }, + { + "name": "_disputeGameFactory", + "type": "address", + "internalType": "contract IDisputeGameFactory" + }, + { + "name": "_startingAnchorRoot", + "type": "tuple", + "internalType": "struct Proposal", + "components": [ + { + "name": "root", + "type": "bytes32", + "internalType": "Hash" + }, + { + "name": "l2SequenceNumber", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_startingRespectedGameType", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "isGameBlacklisted", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameClaimValid", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameFinalized", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameProper", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameRegistered", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameResolved", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameRespected", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameRetired", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "paused", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdmin", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IProxyAdmin" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdminOwner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "respectedGameType", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "retirementTimestamp", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "uint64" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setAnchorState", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setRespectedGameType", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "superchainConfig", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISuperchainConfig" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "systemConfig", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISystemConfig" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "updateRetirementTimestamp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "AnchorUpdated", + "inputs": [ + { + "name": "game", + "type": "address", + "indexed": true, + "internalType": "contract IFaultDisputeGame" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "DisputeGameBlacklisted", + "inputs": [ + { + "name": "disputeGame", + "type": "address", + "indexed": true, + "internalType": "contract IDisputeGame" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Initialized", + "inputs": [ + { + "name": "version", + "type": "uint8", + "indexed": false, + "internalType": "uint8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "RespectedGameTypeSet", + "inputs": [ + { + "name": "gameType", + "type": "uint32", + "indexed": false, + "internalType": "GameType" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "RetirementTimestampSet", + "inputs": [ + { + "name": "timestamp", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "AnchorStateRegistry_InvalidAnchorGame", + "inputs": [] + }, + { + "type": "error", + "name": "AnchorStateRegistry_Unauthorized", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdmin", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotResolvedDelegateProxy", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotSharedProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_ProxyAdminNotFound", + "inputs": [] + }, + { + "type": "error", + "name": "ReinitializableBase_ZeroInitVersion", + "inputs": [] + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod AnchorStateRegistry { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60c06040523480156200001157600080fd5b5060405162002bb338038062002bb38339818101604052810190620000379190620001ac565b600160008160ff160362000077576040517f9b01afed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060ff1660808160ff1681525050508060a081815250506200009e620000a560201b60201c565b50620002c2565b600060019054906101000a900460ff1615620000f8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000ef9062000265565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1610156200016a5760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff604051620001619190620002a5565b60405180910390a15b565b600080fd5b6000819050919050565b620001868162000171565b81146200019257600080fd5b50565b600081519050620001a6816200017b565b92915050565b600060208284031215620001c557620001c46200016c565b5b6000620001d58482850162000195565b91505092915050565b600082825260208201905092915050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60006200024d602783620001de565b91506200025a82620001ef565b604082019050919050565b6000602082019050818103600083015262000280816200023e565b9050919050565b600060ff82169050919050565b6200029f8162000287565b82525050565b6000602082019050620002bc600083018462000294565b92915050565b60805160a0516128c4620002ef600039600081816105c5015261125e015260006109a201526128c46000f3fe608060405234801561001057600080fd5b50600436106101c45760003560e01c80635958a193116100f9578063d5a3e12e11610097578063e0a840eb11610071578063e0a840eb1461050f578063ee658e451461052d578063f2b4e6171461055d578063fdbb3dcf1461057b576101c4565b8063d5a3e12e146104c8578063d83ef267146104d2578063dad544e0146104f1576101c4565b80637258a807116100d35780637258a807146104415780637d6be8dc146104725780637fc485041461048e578063952b2797146104aa576101c4565b80635958a193146103c35780635c975abb146103f35780636c4f446714610411576101c4565b80633c9f397c1161016657806345884d321161014057806345884d321461032957806347a222c514610359578063496b9c161461037557806354fd4d50146103a5576101c4565b80633c9f397c146102cf5780633e47158c146102ed5780634086d1831461030b576101c4565b806333d7e2bd116101a257806333d7e2bd1461024557806334a346ea1461026357806335e80ab31461029357806338d38c97146102b1576101c4565b80630314d2b3146101c957806304e50fed146101f957806317cf21a914610229575b600080fd5b6101e360048036038101906101de9190611b84565b6105ab565b6040516101f09190611bcc565b60405180910390f35b610213600480360381019061020e9190611b84565b610692565b6040516102209190611bcc565b60405180910390f35b610243600480360381019061023e9190611b84565b61070a565b005b61024d61088b565b60405161025a9190611c46565b60405180910390f35b61027d60048036038101906102789190611b84565b6108b1565b60405161028a9190611bcc565b60405180910390f35b61029b610907565b6040516102a89190611c82565b60405180910390f35b6102b961099e565b6040516102c69190611cb9565b60405180910390f35b6102d76109c6565b6040516102e49190611d15565b60405180910390f35b6102f56109dc565b6040516103029190611d51565b60405180910390f35b610313610c35565b6040516103209190611d8f565b60405180910390f35b610343600480360381019061033e9190611b84565b610c4f565b6040516103509190611bcc565b60405180910390f35b610373600480360381019061036e9190611f9f565b610c6f565b005b61038f600480360381019061038a9190611b84565b610e60565b60405161039c9190611bcc565b60405180910390f35b6103ad610ec6565b6040516103ba919061208e565b60405180910390f35b6103dd60048036038101906103d89190611b84565b610eff565b6040516103ea9190611bcc565b60405180910390f35b6103fb610fb6565b6040516104089190611bcc565b60405180910390f35b61042b60048036038101906104269190611b84565b61104d565b6040516104389190611bcc565b60405180910390f35b61045b600480360381019061045691906120b0565b61113d565b60405161046992919061210d565b60405180910390f35b61048c60048036038101906104879190611b84565b611151565b005b6104a860048036038101906104a391906120b0565b6111f7565b005b6104b261125a565b6040516104bf9190612136565b60405180910390f35b6104d0611282565b005b6104da6112ec565b6040516104e892919061210d565b60405180910390f35b6104f961148d565b6040516105069190612160565b60405180910390f35b61051761150a565b604051610524919061219c565b60405180910390f35b61054760048036038101906105429190611b84565b611530565b6040516105549190611bcc565b60405180910390f35b610565611739565b60405161057291906121d8565b60405180910390f35b61059560048036038101906105909190611b84565b61175f565b6040516105a29190611bcc565b60405180910390f35b60006105b68261175f565b6105c3576000905061068d565b7f00000000000000000000000000000000000000000000000000000000000000006106658373ffffffffffffffffffffffffffffffffffffffff166319effeb46040518163ffffffff1660e01b8152600401602060405180830381865afa158015610632573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610656919061221f565b67ffffffffffffffff16611930565b67ffffffffffffffff164261067a919061227b565b11610688576000905061068d565b600190505b919050565b60008173ffffffffffffffffffffffffffffffffffffffff1663250e69bd6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156106df573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061070391906122db565b9050919050565b60008190506107188161104d565b61074e576040517f47ad367a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006107586112ec565b915050808273ffffffffffffffffffffffffffffffffffffffff166399735e326040518163ffffffff1660e01b8152600401602060405180830381865afa1580156107a7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107cb919061231d565b11610802576040517f47ad367a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff167f474f180d74ea8751955ee261c93ff8270411b180408d1014c49f552c92a4d11e60405160405180910390a2505050565b600060029054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000600560008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff169050919050565b60008060029054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166335e80ab36040518163ffffffff1660e01b8152600401602060405180830381865afa158015610975573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109999190612388565b905090565b60007f0000000000000000000000000000000000000000000000000000000000000000905090565b600660009054906101000a900463ffffffff1681565b600080610a0b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d610360001b61193a565b9050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614610a4a5780915050610c32565b60026040518060400160405280601a81526020017f4f564d5f4c3143726f7373446f6d61696e4d657373656e67657200000000000081525051610a8d91906123b5565b7f4f564d5f4c3143726f7373446f6d61696e4d657373656e67657200000000000060001c1760001b610ae7306000604051602001610acc92919061240f565b60405160208183030381529060405280519060200120611945565b14610b1e576040517f54e433cd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610b52306001604051602001610b3792919061240f565b6040516020818303038152906040528051906020012061193a565b9050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614610c00578073ffffffffffffffffffffffffffffffffffffffff16638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610bd3573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bf79190612464565b92505050610c32565b6040517f332144db00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b90565b600660049054906101000a900467ffffffffffffffff1681565b60056020528060005260406000206000915054906101000a900460ff1681565b610c7761099e565b600060019054906101000a900460ff16158015610ca657508060ff1660008054906101000a900460ff1660ff16105b610ce5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610cdc90612503565b60405180910390fd5b806000806101000a81548160ff021916908360ff1602179055506001600060016101000a81548160ff021916908315150217905550610d22611950565b84600060026101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555083600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550826003600082015181600001556020820151816001015590505081600660006101000a81548163ffffffff021916908363ffffffff16021790555042600660046101000a81548167ffffffffffffffff021916908367ffffffffffffffff16021790555060008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249881604051610e519190611cb9565b60405180910390a15050505050565b6000610e6b82611530565b610e785760009050610ec1565b610e81826108b1565b15610e8f5760009050610ec1565b610e9882610eff565b15610ea65760009050610ec1565b610eae610fb6565b15610ebc5760009050610ec1565b600190505b919050565b6040518060400160405280600581526020017f332e352e3000000000000000000000000000000000000000000000000000000081525081565b6000600660049054906101000a900467ffffffffffffffff1667ffffffffffffffff16610fa38373ffffffffffffffffffffffffffffffffffffffff1663cf09e0d06040518163ffffffff1660e01b8152600401602060405180830381865afa158015610f70573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f94919061221f565b67ffffffffffffffff16611930565b67ffffffffffffffff1611159050919050565b60008060029054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635c975abb6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611024573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061104891906122db565b905090565b600061105882610e60565b6110655760009050611138565b61106e82610692565b61107b5760009050611138565b611084826105ab565b6110915760009050611138565b6002808111156110a4576110a3612523565b5b8273ffffffffffffffffffffffffffffffffffffffff1663200d2ed26040518163ffffffff1660e01b8152600401602060405180830381865afa1580156110ef573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111139190612577565b600281111561112557611124612523565b5b146111335760009050611138565b600190505b919050565b6000806111486112ec565b91509150915091565b6111596119ff565b6001600560008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508073ffffffffffffffffffffffffffffffffffffffff167f192c289026d59a41a27f5aea08f3969b57931b0589202d14f4368cded95d3cda60405160405180910390a250565b6111ff6119ff565b80600660006101000a81548163ffffffff021916908363ffffffff1602179055507fcee0703b5e4bad4efededab85c9fd1aec17dee7c5f6c584330e0509b677745a28160405161124f9190611d15565b60405180910390a150565b60007f0000000000000000000000000000000000000000000000000000000000000000905090565b61128a6119ff565b42600660046101000a81548167ffffffffffffffff021916908367ffffffffffffffff1602179055507f6e5b1ba771e8e484f741ed085f039ff4e5c6e882eaf68f550fb390922d0ae4a7426040516112e29190612136565b60405180910390a1565b600080600073ffffffffffffffffffffffffffffffffffffffff16600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff160361135a5760036000015460036001015491509150611489565b6113f3600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663bcef3b556040518163ffffffff1660e01b8152600401602060405180830381865afa1580156113ca573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113ee91906125d0565b611af6565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166399735e326040518163ffffffff1660e01b8152600401602060405180830381865afa158015611460573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611484919061231d565b915091505b9091565b60006114976109dc565b73ffffffffffffffffffffffffffffffffffffffff16638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156114e1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906115059190612464565b905090565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000806000808473ffffffffffffffffffffffffffffffffffffffff1663fa24f7436040518163ffffffff1660e01b8152600401600060405180830381865afa158015611581573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052508101906115aa91906126bd565b9250925092506000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635f0150cb8585856040518463ffffffff1660e01b815260040161161193929190612790565b6040805180830381865afa15801561162d573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061165191906127e3565b50905060008673ffffffffffffffffffffffffffffffffffffffff16635c0cba336040518163ffffffff1660e01b8152600401602060405180830381865afa1580156116a1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116c59190612861565b90508673ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614801561172d57503073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b95505050505050919050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000806117e38373ffffffffffffffffffffffffffffffffffffffff166319effeb46040518163ffffffff1660e01b8152600401602060405180830381865afa1580156117b0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117d4919061221f565b67ffffffffffffffff16611930565b67ffffffffffffffff1614158015611929575060028081111561180957611808612523565b5b8273ffffffffffffffffffffffffffffffffffffffff1663200d2ed26040518163ffffffff1660e01b8152600401602060405180830381865afa158015611854573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118789190612577565b600281111561188a57611889612523565b5b14806119285750600160028111156118a5576118a4612523565b5b8273ffffffffffffffffffffffffffffffffffffffff1663200d2ed26040518163ffffffff1660e01b8152600401602060405180830381865afa1580156118f0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906119149190612577565b600281111561192657611925612523565b5b145b5b9050919050565b6000819050919050565b600081549050919050565b600081549050919050565b3373ffffffffffffffffffffffffffffffffffffffff1661196f6109dc565b73ffffffffffffffffffffffffffffffffffffffff16141580156119c657503373ffffffffffffffffffffffffffffffffffffffff166119ad61148d565b73ffffffffffffffffffffffffffffffffffffffff1614155b156119fd576040517fc4050a2600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b565b600060029054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663452a93206040518163ffffffff1660e01b8152600401602060405180830381865afa158015611a6c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611a909190612464565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611af4576040517f2e5321ac00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b565b6000819050919050565b6000604051905090565b600080fd5b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000611b3f82611b14565b9050919050565b6000611b5182611b34565b9050919050565b611b6181611b46565b8114611b6c57600080fd5b50565b600081359050611b7e81611b58565b92915050565b600060208284031215611b9a57611b99611b0a565b5b6000611ba884828501611b6f565b91505092915050565b60008115159050919050565b611bc681611bb1565b82525050565b6000602082019050611be16000830184611bbd565b92915050565b6000819050919050565b6000611c0c611c07611c0284611b14565b611be7565b611b14565b9050919050565b6000611c1e82611bf1565b9050919050565b6000611c3082611c13565b9050919050565b611c4081611c25565b82525050565b6000602082019050611c5b6000830184611c37565b92915050565b6000611c6c82611c13565b9050919050565b611c7c81611c61565b82525050565b6000602082019050611c976000830184611c73565b92915050565b600060ff82169050919050565b611cb381611c9d565b82525050565b6000602082019050611cce6000830184611caa565b92915050565b600063ffffffff82169050919050565b6000611cff611cfa611cf584611cd4565b611be7565b611cd4565b9050919050565b611d0f81611ce4565b82525050565b6000602082019050611d2a6000830184611d06565b92915050565b6000611d3b82611c13565b9050919050565b611d4b81611d30565b82525050565b6000602082019050611d666000830184611d42565b92915050565b600067ffffffffffffffff82169050919050565b611d8981611d6c565b82525050565b6000602082019050611da46000830184611d80565b92915050565b6000611db582611b34565b9050919050565b611dc581611daa565b8114611dd057600080fd5b50565b600081359050611de281611dbc565b92915050565b6000611df382611b34565b9050919050565b611e0381611de8565b8114611e0e57600080fd5b50565b600081359050611e2081611dfa565b92915050565b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b611e7482611e2b565b810181811067ffffffffffffffff82111715611e9357611e92611e3c565b5b80604052505050565b6000611ea6611b00565b9050611eb28282611e6b565b919050565b6000819050919050565b611eca81611eb7565b8114611ed557600080fd5b50565b600081359050611ee781611ec1565b92915050565b6000819050919050565b611f0081611eed565b8114611f0b57600080fd5b50565b600081359050611f1d81611ef7565b92915050565b600060408284031215611f3957611f38611e26565b5b611f436040611e9c565b90506000611f5384828501611ed8565b6000830152506020611f6784828501611f0e565b60208301525092915050565b611f7c81611cd4565b8114611f8757600080fd5b50565b600081359050611f9981611f73565b92915050565b60008060008060a08587031215611fb957611fb8611b0a565b5b6000611fc787828801611dd3565b9450506020611fd887828801611e11565b9350506040611fe987828801611f23565b9250506080611ffa87828801611f8a565b91505092959194509250565b600081519050919050565b600082825260208201905092915050565b60005b83811015612040578082015181840152602081019050612025565b8381111561204f576000848401525b50505050565b600061206082612006565b61206a8185612011565b935061207a818560208601612022565b61208381611e2b565b840191505092915050565b600060208201905081810360008301526120a88184612055565b905092915050565b6000602082840312156120c6576120c5611b0a565b5b60006120d484828501611f8a565b91505092915050565b60006120e882611eb7565b9050919050565b6120f8816120dd565b82525050565b61210781611eed565b82525050565b600060408201905061212260008301856120ef565b61212f60208301846120fe565b9392505050565b600060208201905061214b60008301846120fe565b92915050565b61215a81611b34565b82525050565b60006020820190506121756000830184612151565b92915050565b600061218682611c13565b9050919050565b6121968161217b565b82525050565b60006020820190506121b1600083018461218d565b92915050565b60006121c282611c13565b9050919050565b6121d2816121b7565b82525050565b60006020820190506121ed60008301846121c9565b92915050565b6121fc81611d6c565b811461220757600080fd5b50565b600081519050612219816121f3565b92915050565b60006020828403121561223557612234611b0a565b5b60006122438482850161220a565b91505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600061228682611eed565b915061229183611eed565b9250828210156122a4576122a361224c565b5b828203905092915050565b6122b881611bb1565b81146122c357600080fd5b50565b6000815190506122d5816122af565b92915050565b6000602082840312156122f1576122f0611b0a565b5b60006122ff848285016122c6565b91505092915050565b60008151905061231781611ef7565b92915050565b60006020828403121561233357612332611b0a565b5b600061234184828501612308565b91505092915050565b600061235582611b34565b9050919050565b6123658161234a565b811461237057600080fd5b50565b6000815190506123828161235c565b92915050565b60006020828403121561239e5761239d611b0a565b5b60006123ac84828501612373565b91505092915050565b60006123c082611eed565b91506123cb83611eed565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff04831182151516156124045761240361224c565b5b828202905092915050565b60006040820190506124246000830185612151565b61243160208301846120fe565b9392505050565b61244181611b34565b811461244c57600080fd5b50565b60008151905061245e81612438565b92915050565b60006020828403121561247a57612479611b0a565b5b60006124888482850161244f565b91505092915050565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b60006124ed602e83612011565b91506124f882612491565b604082019050919050565b6000602082019050818103600083015261251c816124e0565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b6003811061255f57600080fd5b50565b60008151905061257181612552565b92915050565b60006020828403121561258d5761258c611b0a565b5b600061259b84828501612562565b91505092915050565b6125ad81611eb7565b81146125b857600080fd5b50565b6000815190506125ca816125a4565b92915050565b6000602082840312156125e6576125e5611b0a565b5b60006125f4848285016125bb565b91505092915050565b60008151905061260c81611f73565b92915050565b600080fd5b600080fd5b600067ffffffffffffffff82111561263757612636611e3c565b5b61264082611e2b565b9050602081019050919050565b600061266061265b8461261c565b611e9c565b90508281526020810184848401111561267c5761267b612617565b5b612687848285612022565b509392505050565b600082601f8301126126a4576126a3612612565b5b81516126b484826020860161264d565b91505092915050565b6000806000606084860312156126d6576126d5611b0a565b5b60006126e4868287016125fd565b93505060206126f5868287016125bb565b925050604084015167ffffffffffffffff81111561271657612715611b0f565b5b6127228682870161268f565b9150509250925092565b612735816120dd565b82525050565b600081519050919050565b600082825260208201905092915050565b60006127628261273b565b61276c8185612746565b935061277c818560208601612022565b61278581611e2b565b840191505092915050565b60006060820190506127a56000830186611d06565b6127b2602083018561272c565b81810360408301526127c48184612757565b9050949350505050565b6000815190506127dd81611b58565b92915050565b600080604083850312156127fa576127f9611b0a565b5b6000612808858286016127ce565b92505060206128198582860161220a565b9150509250929050565b600061282e82611b34565b9050919050565b61283e81612823565b811461284957600080fd5b50565b60008151905061285b81612835565b92915050565b60006020828403121561287757612876611b0a565b5b60006128858482850161284c565b9150509291505056fea264697066735822122033f9b9308e6c3f0ba0c065af0109df5f00e46acdea9f7b6a6f66096fdab8545d64736f6c634300080f0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\xC0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0+\xB38\x03\x80b\0+\xB3\x839\x81\x81\x01`@R\x81\x01\x90b\0\x007\x91\x90b\0\x01\xACV[`\x01`\0\x81`\xFF\x16\x03b\0\0wW`@Q\x7F\x9B\x01\xAF\xED\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80`\xFF\x16`\x80\x81`\xFF\x16\x81RPPP\x80`\xA0\x81\x81RPPb\0\0\x9Eb\0\0\xA5` \x1B` \x1CV[Pb\0\x02\xC2V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15b\0\0\xF8W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01b\0\0\xEF\x90b\0\x02eV[`@Q\x80\x91\x03\x90\xFD[`\xFF\x80\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10\x15b\0\x01jW`\xFF`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98`\xFF`@Qb\0\x01a\x91\x90b\0\x02\xA5V[`@Q\x80\x91\x03\x90\xA1[V[`\0\x80\xFD[`\0\x81\x90P\x91\x90PV[b\0\x01\x86\x81b\0\x01qV[\x81\x14b\0\x01\x92W`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x01\xA6\x81b\0\x01{V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15b\0\x01\xC5Wb\0\x01\xC4b\0\x01lV[[`\0b\0\x01\xD5\x84\x82\x85\x01b\0\x01\x95V[\x91PP\x92\x91PPV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[\x7FInitializable: contract is initi`\0\x82\x01R\x7Falizing\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0b\0\x02M`'\x83b\0\x01\xDEV[\x91Pb\0\x02Z\x82b\0\x01\xEFV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Rb\0\x02\x80\x81b\0\x02>V[\x90P\x91\x90PV[`\0`\xFF\x82\x16\x90P\x91\x90PV[b\0\x02\x9F\x81b\0\x02\x87V[\x82RPPV[`\0` \x82\x01\x90Pb\0\x02\xBC`\0\x83\x01\x84b\0\x02\x94V[\x92\x91PPV[`\x80Q`\xA0Qa(\xC4b\0\x02\xEF`\09`\0\x81\x81a\x05\xC5\x01Ra\x12^\x01R`\0a\t\xA2\x01Ra(\xC4`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x01\xC4W`\x005`\xE0\x1C\x80cYX\xA1\x93\x11a\0\xF9W\x80c\xD5\xA3\xE1.\x11a\0\x97W\x80c\xE0\xA8@\xEB\x11a\0qW\x80c\xE0\xA8@\xEB\x14a\x05\x0FW\x80c\xEEe\x8EE\x14a\x05-W\x80c\xF2\xB4\xE6\x17\x14a\x05]W\x80c\xFD\xBB=\xCF\x14a\x05{Wa\x01\xC4V[\x80c\xD5\xA3\xE1.\x14a\x04\xC8W\x80c\xD8>\xF2g\x14a\x04\xD2W\x80c\xDA\xD5D\xE0\x14a\x04\xF1Wa\x01\xC4V[\x80crX\xA8\x07\x11a\0\xD3W\x80crX\xA8\x07\x14a\x04AW\x80c}k\xE8\xDC\x14a\x04rW\x80c\x7F\xC4\x85\x04\x14a\x04\x8EW\x80c\x95+'\x97\x14a\x04\xAAWa\x01\xC4V[\x80cYX\xA1\x93\x14a\x03\xC3W\x80c\\\x97Z\xBB\x14a\x03\xF3W\x80clODg\x14a\x04\x11Wa\x01\xC4V[\x80c<\x9F9|\x11a\x01fW\x80cE\x88M2\x11a\x01@W\x80cE\x88M2\x14a\x03)W\x80cG\xA2\"\xC5\x14a\x03YW\x80cIk\x9C\x16\x14a\x03uW\x80cT\xFDMP\x14a\x03\xA5Wa\x01\xC4V[\x80c<\x9F9|\x14a\x02\xCFW\x80c>G\x15\x8C\x14a\x02\xEDW\x80c@\x86\xD1\x83\x14a\x03\x0BWa\x01\xC4V[\x80c3\xD7\xE2\xBD\x11a\x01\xA2W\x80c3\xD7\xE2\xBD\x14a\x02EW\x80c4\xA3F\xEA\x14a\x02cW\x80c5\xE8\n\xB3\x14a\x02\x93W\x80c8\xD3\x8C\x97\x14a\x02\xB1Wa\x01\xC4V[\x80c\x03\x14\xD2\xB3\x14a\x01\xC9W\x80c\x04\xE5\x0F\xED\x14a\x01\xF9W\x80c\x17\xCF!\xA9\x14a\x02)W[`\0\x80\xFD[a\x01\xE3`\x04\x806\x03\x81\x01\x90a\x01\xDE\x91\x90a\x1B\x84V[a\x05\xABV[`@Qa\x01\xF0\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x02\x13`\x04\x806\x03\x81\x01\x90a\x02\x0E\x91\x90a\x1B\x84V[a\x06\x92V[`@Qa\x02 \x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x02C`\x04\x806\x03\x81\x01\x90a\x02>\x91\x90a\x1B\x84V[a\x07\nV[\0[a\x02Ma\x08\x8BV[`@Qa\x02Z\x91\x90a\x1CFV[`@Q\x80\x91\x03\x90\xF3[a\x02}`\x04\x806\x03\x81\x01\x90a\x02x\x91\x90a\x1B\x84V[a\x08\xB1V[`@Qa\x02\x8A\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x02\x9Ba\t\x07V[`@Qa\x02\xA8\x91\x90a\x1C\x82V[`@Q\x80\x91\x03\x90\xF3[a\x02\xB9a\t\x9EV[`@Qa\x02\xC6\x91\x90a\x1C\xB9V[`@Q\x80\x91\x03\x90\xF3[a\x02\xD7a\t\xC6V[`@Qa\x02\xE4\x91\x90a\x1D\x15V[`@Q\x80\x91\x03\x90\xF3[a\x02\xF5a\t\xDCV[`@Qa\x03\x02\x91\x90a\x1DQV[`@Q\x80\x91\x03\x90\xF3[a\x03\x13a\x0C5V[`@Qa\x03 \x91\x90a\x1D\x8FV[`@Q\x80\x91\x03\x90\xF3[a\x03C`\x04\x806\x03\x81\x01\x90a\x03>\x91\x90a\x1B\x84V[a\x0COV[`@Qa\x03P\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x03s`\x04\x806\x03\x81\x01\x90a\x03n\x91\x90a\x1F\x9FV[a\x0CoV[\0[a\x03\x8F`\x04\x806\x03\x81\x01\x90a\x03\x8A\x91\x90a\x1B\x84V[a\x0E`V[`@Qa\x03\x9C\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x03\xADa\x0E\xC6V[`@Qa\x03\xBA\x91\x90a \x8EV[`@Q\x80\x91\x03\x90\xF3[a\x03\xDD`\x04\x806\x03\x81\x01\x90a\x03\xD8\x91\x90a\x1B\x84V[a\x0E\xFFV[`@Qa\x03\xEA\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x03\xFBa\x0F\xB6V[`@Qa\x04\x08\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x04+`\x04\x806\x03\x81\x01\x90a\x04&\x91\x90a\x1B\x84V[a\x10MV[`@Qa\x048\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x04[`\x04\x806\x03\x81\x01\x90a\x04V\x91\x90a \xB0V[a\x11=V[`@Qa\x04i\x92\x91\x90a!\rV[`@Q\x80\x91\x03\x90\xF3[a\x04\x8C`\x04\x806\x03\x81\x01\x90a\x04\x87\x91\x90a\x1B\x84V[a\x11QV[\0[a\x04\xA8`\x04\x806\x03\x81\x01\x90a\x04\xA3\x91\x90a \xB0V[a\x11\xF7V[\0[a\x04\xB2a\x12ZV[`@Qa\x04\xBF\x91\x90a!6V[`@Q\x80\x91\x03\x90\xF3[a\x04\xD0a\x12\x82V[\0[a\x04\xDAa\x12\xECV[`@Qa\x04\xE8\x92\x91\x90a!\rV[`@Q\x80\x91\x03\x90\xF3[a\x04\xF9a\x14\x8DV[`@Qa\x05\x06\x91\x90a!`V[`@Q\x80\x91\x03\x90\xF3[a\x05\x17a\x15\nV[`@Qa\x05$\x91\x90a!\x9CV[`@Q\x80\x91\x03\x90\xF3[a\x05G`\x04\x806\x03\x81\x01\x90a\x05B\x91\x90a\x1B\x84V[a\x150V[`@Qa\x05T\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x05ea\x179V[`@Qa\x05r\x91\x90a!\xD8V[`@Q\x80\x91\x03\x90\xF3[a\x05\x95`\x04\x806\x03\x81\x01\x90a\x05\x90\x91\x90a\x1B\x84V[a\x17_V[`@Qa\x05\xA2\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[`\0a\x05\xB6\x82a\x17_V[a\x05\xC3W`\0\x90Pa\x06\x8DV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06e\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x19\xEF\xFE\xB4`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x062W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06V\x91\x90a\"\x1FV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x190V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16Ba\x06z\x91\x90a\"{V[\x11a\x06\x88W`\0\x90Pa\x06\x8DV[`\x01\x90P[\x91\x90PV[`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c%\x0Ei\xBD`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xDFW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x03\x91\x90a\"\xDBV[\x90P\x91\x90PV[`\0\x81\x90Pa\x07\x18\x81a\x10MV[a\x07NW`@Q\x7FG\xAD6z\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\x07Xa\x12\xECV[\x91PP\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x99s^2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xA7W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xCB\x91\x90a#\x1DV[\x11a\x08\x02W`@Q\x7FG\xAD6z\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x02`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7FGO\x18\rt\xEA\x87Q\x95^\xE2a\xC9?\xF8'\x04\x11\xB1\x80@\x8D\x10\x14\xC4\x9FU,\x92\xA4\xD1\x1E`@Q`@Q\x80\x91\x03\x90\xA2PPPV[`\0`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0`\x05`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x90P\x91\x90PV[`\0\x80`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5\xE8\n\xB3`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\tuW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x99\x91\x90a#\x88V[\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\x06`\0\x90T\x90a\x01\0\n\x90\x04c\xFF\xFF\xFF\xFF\x16\x81V[`\0\x80a\n\x0B\x7F\xB51'hJV\x8B1s\xAE\x13\xB9\xF8\xA6\x01n$>c\xB6\xE8\xEE\x11x\xD6\xA7\x17\x85\x0B]a\x03`\0\x1Ba\x19:V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\nJW\x80\x91PPa\x0C2V[`\x02`@Q\x80`@\x01`@R\x80`\x1A\x81R` \x01\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0\x81RPQa\n\x8D\x91\x90a#\xB5V[\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0`\0\x1C\x17`\0\x1Ba\n\xE70`\0`@Q` \x01a\n\xCC\x92\x91\x90a$\x0FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x19EV[\x14a\x0B\x1EW`@Q\x7FT\xE43\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\x0BR0`\x01`@Q` \x01a\x0B7\x92\x91\x90a$\x0FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x19:V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x0C\0W\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xD3W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xF7\x91\x90a$dV[\x92PPPa\x0C2V[`@Q\x7F3!D\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x90V[`\x06`\x04\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x05` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[a\x0Cwa\t\x9EV[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15\x80\x15a\x0C\xA6WP\x80`\xFF\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10[a\x0C\xE5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x0C\xDC\x90a%\x03V[`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP`\x01`\0`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPa\r\"a\x19PV[\x84`\0`\x02a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x83`\x01`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x82`\x03`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U\x90PP\x81`\x06`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPB`\x06`\x04a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0\x80`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x81`@Qa\x0EQ\x91\x90a\x1C\xB9V[`@Q\x80\x91\x03\x90\xA1PPPPPV[`\0a\x0Ek\x82a\x150V[a\x0ExW`\0\x90Pa\x0E\xC1V[a\x0E\x81\x82a\x08\xB1V[\x15a\x0E\x8FW`\0\x90Pa\x0E\xC1V[a\x0E\x98\x82a\x0E\xFFV[\x15a\x0E\xA6W`\0\x90Pa\x0E\xC1V[a\x0E\xAEa\x0F\xB6V[\x15a\x0E\xBCW`\0\x90Pa\x0E\xC1V[`\x01\x90P[\x91\x90PV[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F3.5.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\0`\x06`\x04\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0F\xA3\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xCF\t\xE0\xD0`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FpW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\x94\x91\x90a\"\x1FV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x190V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x11\x15\x90P\x91\x90PV[`\0\x80`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\\\x97Z\xBB`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10$W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10H\x91\x90a\"\xDBV[\x90P\x90V[`\0a\x10X\x82a\x0E`V[a\x10eW`\0\x90Pa\x118V[a\x10n\x82a\x06\x92V[a\x10{W`\0\x90Pa\x118V[a\x10\x84\x82a\x05\xABV[a\x10\x91W`\0\x90Pa\x118V[`\x02\x80\x81\x11\x15a\x10\xA4Wa\x10\xA3a%#V[[\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xEFW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x13\x91\x90a%wV[`\x02\x81\x11\x15a\x11%Wa\x11$a%#V[[\x14a\x113W`\0\x90Pa\x118V[`\x01\x90P[\x91\x90PV[`\0\x80a\x11Ha\x12\xECV[\x91P\x91P\x91P\x91V[a\x11Ya\x19\xFFV[`\x01`\x05`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x19,(\x90&\xD5\x9AA\xA2\x7FZ\xEA\x08\xF3\x96\x9BW\x93\x1B\x05\x89 -\x14\xF46\x8C\xDE\xD9]<\xDA`@Q`@Q\x80\x91\x03\x90\xA2PV[a\x11\xFFa\x19\xFFV[\x80`\x06`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xCE\xE0p;^K\xADN\xFE\xDE\xDA\xB8\\\x9F\xD1\xAE\xC1}\xEE|_lXC0\xE0P\x9BgwE\xA2\x81`@Qa\x12O\x91\x90a\x1D\x15V[`@Q\x80\x91\x03\x90\xA1PV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[a\x12\x8Aa\x19\xFFV[B`\x06`\x04a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7Fn[\x1B\xA7q\xE8\xE4\x84\xF7A\xED\x08_\x03\x9F\xF4\xE5\xC6\xE8\x82\xEA\xF6\x8FU\x0F\xB3\x90\x92-\n\xE4\xA7B`@Qa\x12\xE2\x91\x90a!6V[`@Q\x80\x91\x03\x90\xA1V[`\0\x80`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x13ZW`\x03`\0\x01T`\x03`\x01\x01T\x91P\x91Pa\x14\x89V[a\x13\xF3`\x02`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBC\xEF;U`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x13\xCAW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xEE\x91\x90a%\xD0V[a\x1A\xF6V[`\x02`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x99s^2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14`W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\x84\x91\x90a#\x1DV[\x91P\x91P[\x90\x91V[`\0a\x14\x97a\t\xDCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xE1W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x05\x91\x90a$dV[\x90P\x90V[`\x02`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0\x80`\0\x80\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFA$\xF7C`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15\x81W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\xAA\x91\x90a&\xBDV[\x92P\x92P\x92P`\0`\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c_\x01P\xCB\x85\x85\x85`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x16\x11\x93\x92\x91\x90a'\x90V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16-W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16Q\x91\x90a'\xE3V[P\x90P`\0\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\\\x0C\xBA3`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16\xA1W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16\xC5\x91\x90a(aV[\x90P\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x80\x15a\x17-WP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14[\x95PPPPPP\x91\x90PV[`\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0\x80a\x17\xE3\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x19\xEF\xFE\xB4`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x17\xB0W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x17\xD4\x91\x90a\"\x1FV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x190V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x19)WP`\x02\x80\x81\x11\x15a\x18\tWa\x18\x08a%#V[[\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18TW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x18x\x91\x90a%wV[`\x02\x81\x11\x15a\x18\x8AWa\x18\x89a%#V[[\x14\x80a\x19(WP`\x01`\x02\x81\x11\x15a\x18\xA5Wa\x18\xA4a%#V[[\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\xF0W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19\x14\x91\x90a%wV[`\x02\x81\x11\x15a\x19&Wa\x19%a%#V[[\x14[[\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x19oa\t\xDCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x19\xC6WP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x19\xADa\x14\x8DV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x15a\x19\xFDW`@Q\x7F\xC4\x05\n&\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[`\0`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cE*\x93 `@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1AlW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\x90\x91\x90a$dV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x1A\xF4W`@Q\x7F.S!\xAC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[`\0\x81\x90P\x91\x90PV[`\0`@Q\x90P\x90V[`\0\x80\xFD[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x1B?\x82a\x1B\x14V[\x90P\x91\x90PV[`\0a\x1BQ\x82a\x1B4V[\x90P\x91\x90PV[a\x1Ba\x81a\x1BFV[\x81\x14a\x1BlW`\0\x80\xFD[PV[`\0\x815\x90Pa\x1B~\x81a\x1BXV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x1B\x9AWa\x1B\x99a\x1B\nV[[`\0a\x1B\xA8\x84\x82\x85\x01a\x1BoV[\x91PP\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\x1B\xC6\x81a\x1B\xB1V[\x82RPPV[`\0` \x82\x01\x90Pa\x1B\xE1`\0\x83\x01\x84a\x1B\xBDV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[`\0a\x1C\x0Ca\x1C\x07a\x1C\x02\x84a\x1B\x14V[a\x1B\xE7V[a\x1B\x14V[\x90P\x91\x90PV[`\0a\x1C\x1E\x82a\x1B\xF1V[\x90P\x91\x90PV[`\0a\x1C0\x82a\x1C\x13V[\x90P\x91\x90PV[a\x1C@\x81a\x1C%V[\x82RPPV[`\0` \x82\x01\x90Pa\x1C[`\0\x83\x01\x84a\x1C7V[\x92\x91PPV[`\0a\x1Cl\x82a\x1C\x13V[\x90P\x91\x90PV[a\x1C|\x81a\x1CaV[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\x97`\0\x83\x01\x84a\x1CsV[\x92\x91PPV[`\0`\xFF\x82\x16\x90P\x91\x90PV[a\x1C\xB3\x81a\x1C\x9DV[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\xCE`\0\x83\x01\x84a\x1C\xAAV[\x92\x91PPV[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x1C\xFFa\x1C\xFAa\x1C\xF5\x84a\x1C\xD4V[a\x1B\xE7V[a\x1C\xD4V[\x90P\x91\x90PV[a\x1D\x0F\x81a\x1C\xE4V[\x82RPPV[`\0` \x82\x01\x90Pa\x1D*`\0\x83\x01\x84a\x1D\x06V[\x92\x91PPV[`\0a\x1D;\x82a\x1C\x13V[\x90P\x91\x90PV[a\x1DK\x81a\x1D0V[\x82RPPV[`\0` \x82\x01\x90Pa\x1Df`\0\x83\x01\x84a\x1DBV[\x92\x91PPV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a\x1D\x89\x81a\x1DlV[\x82RPPV[`\0` \x82\x01\x90Pa\x1D\xA4`\0\x83\x01\x84a\x1D\x80V[\x92\x91PPV[`\0a\x1D\xB5\x82a\x1B4V[\x90P\x91\x90PV[a\x1D\xC5\x81a\x1D\xAAV[\x81\x14a\x1D\xD0W`\0\x80\xFD[PV[`\0\x815\x90Pa\x1D\xE2\x81a\x1D\xBCV[\x92\x91PPV[`\0a\x1D\xF3\x82a\x1B4V[\x90P\x91\x90PV[a\x1E\x03\x81a\x1D\xE8V[\x81\x14a\x1E\x0EW`\0\x80\xFD[PV[`\0\x815\x90Pa\x1E \x81a\x1D\xFAV[\x92\x91PPV[`\0\x80\xFD[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`A`\x04R`$`\0\xFD[a\x1Et\x82a\x1E+V[\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x1E\x93Wa\x1E\x92a\x1E\x81a(#V[\x81\x14a(IW`\0\x80\xFD[PV[`\0\x81Q\x90Pa([\x81a(5V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a(wWa(va\x1B\nV[[`\0a(\x85\x84\x82\x85\x01a(LV[\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 3\xF9\xB90\x8El?\x0B\xA0\xC0e\xAF\x01\t\xDF_\0\xE4j\xCD\xEA\x9F{jof\to\xDA\xB8T]dsolcC\0\x08\x0F\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\x01\xC4W`\x005`\xE0\x1C\x80cYX\xA1\x93\x11a\0\xF9W\x80c\xD5\xA3\xE1.\x11a\0\x97W\x80c\xE0\xA8@\xEB\x11a\0qW\x80c\xE0\xA8@\xEB\x14a\x05\x0FW\x80c\xEEe\x8EE\x14a\x05-W\x80c\xF2\xB4\xE6\x17\x14a\x05]W\x80c\xFD\xBB=\xCF\x14a\x05{Wa\x01\xC4V[\x80c\xD5\xA3\xE1.\x14a\x04\xC8W\x80c\xD8>\xF2g\x14a\x04\xD2W\x80c\xDA\xD5D\xE0\x14a\x04\xF1Wa\x01\xC4V[\x80crX\xA8\x07\x11a\0\xD3W\x80crX\xA8\x07\x14a\x04AW\x80c}k\xE8\xDC\x14a\x04rW\x80c\x7F\xC4\x85\x04\x14a\x04\x8EW\x80c\x95+'\x97\x14a\x04\xAAWa\x01\xC4V[\x80cYX\xA1\x93\x14a\x03\xC3W\x80c\\\x97Z\xBB\x14a\x03\xF3W\x80clODg\x14a\x04\x11Wa\x01\xC4V[\x80c<\x9F9|\x11a\x01fW\x80cE\x88M2\x11a\x01@W\x80cE\x88M2\x14a\x03)W\x80cG\xA2\"\xC5\x14a\x03YW\x80cIk\x9C\x16\x14a\x03uW\x80cT\xFDMP\x14a\x03\xA5Wa\x01\xC4V[\x80c<\x9F9|\x14a\x02\xCFW\x80c>G\x15\x8C\x14a\x02\xEDW\x80c@\x86\xD1\x83\x14a\x03\x0BWa\x01\xC4V[\x80c3\xD7\xE2\xBD\x11a\x01\xA2W\x80c3\xD7\xE2\xBD\x14a\x02EW\x80c4\xA3F\xEA\x14a\x02cW\x80c5\xE8\n\xB3\x14a\x02\x93W\x80c8\xD3\x8C\x97\x14a\x02\xB1Wa\x01\xC4V[\x80c\x03\x14\xD2\xB3\x14a\x01\xC9W\x80c\x04\xE5\x0F\xED\x14a\x01\xF9W\x80c\x17\xCF!\xA9\x14a\x02)W[`\0\x80\xFD[a\x01\xE3`\x04\x806\x03\x81\x01\x90a\x01\xDE\x91\x90a\x1B\x84V[a\x05\xABV[`@Qa\x01\xF0\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x02\x13`\x04\x806\x03\x81\x01\x90a\x02\x0E\x91\x90a\x1B\x84V[a\x06\x92V[`@Qa\x02 \x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x02C`\x04\x806\x03\x81\x01\x90a\x02>\x91\x90a\x1B\x84V[a\x07\nV[\0[a\x02Ma\x08\x8BV[`@Qa\x02Z\x91\x90a\x1CFV[`@Q\x80\x91\x03\x90\xF3[a\x02}`\x04\x806\x03\x81\x01\x90a\x02x\x91\x90a\x1B\x84V[a\x08\xB1V[`@Qa\x02\x8A\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x02\x9Ba\t\x07V[`@Qa\x02\xA8\x91\x90a\x1C\x82V[`@Q\x80\x91\x03\x90\xF3[a\x02\xB9a\t\x9EV[`@Qa\x02\xC6\x91\x90a\x1C\xB9V[`@Q\x80\x91\x03\x90\xF3[a\x02\xD7a\t\xC6V[`@Qa\x02\xE4\x91\x90a\x1D\x15V[`@Q\x80\x91\x03\x90\xF3[a\x02\xF5a\t\xDCV[`@Qa\x03\x02\x91\x90a\x1DQV[`@Q\x80\x91\x03\x90\xF3[a\x03\x13a\x0C5V[`@Qa\x03 \x91\x90a\x1D\x8FV[`@Q\x80\x91\x03\x90\xF3[a\x03C`\x04\x806\x03\x81\x01\x90a\x03>\x91\x90a\x1B\x84V[a\x0COV[`@Qa\x03P\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x03s`\x04\x806\x03\x81\x01\x90a\x03n\x91\x90a\x1F\x9FV[a\x0CoV[\0[a\x03\x8F`\x04\x806\x03\x81\x01\x90a\x03\x8A\x91\x90a\x1B\x84V[a\x0E`V[`@Qa\x03\x9C\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x03\xADa\x0E\xC6V[`@Qa\x03\xBA\x91\x90a \x8EV[`@Q\x80\x91\x03\x90\xF3[a\x03\xDD`\x04\x806\x03\x81\x01\x90a\x03\xD8\x91\x90a\x1B\x84V[a\x0E\xFFV[`@Qa\x03\xEA\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x03\xFBa\x0F\xB6V[`@Qa\x04\x08\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x04+`\x04\x806\x03\x81\x01\x90a\x04&\x91\x90a\x1B\x84V[a\x10MV[`@Qa\x048\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x04[`\x04\x806\x03\x81\x01\x90a\x04V\x91\x90a \xB0V[a\x11=V[`@Qa\x04i\x92\x91\x90a!\rV[`@Q\x80\x91\x03\x90\xF3[a\x04\x8C`\x04\x806\x03\x81\x01\x90a\x04\x87\x91\x90a\x1B\x84V[a\x11QV[\0[a\x04\xA8`\x04\x806\x03\x81\x01\x90a\x04\xA3\x91\x90a \xB0V[a\x11\xF7V[\0[a\x04\xB2a\x12ZV[`@Qa\x04\xBF\x91\x90a!6V[`@Q\x80\x91\x03\x90\xF3[a\x04\xD0a\x12\x82V[\0[a\x04\xDAa\x12\xECV[`@Qa\x04\xE8\x92\x91\x90a!\rV[`@Q\x80\x91\x03\x90\xF3[a\x04\xF9a\x14\x8DV[`@Qa\x05\x06\x91\x90a!`V[`@Q\x80\x91\x03\x90\xF3[a\x05\x17a\x15\nV[`@Qa\x05$\x91\x90a!\x9CV[`@Q\x80\x91\x03\x90\xF3[a\x05G`\x04\x806\x03\x81\x01\x90a\x05B\x91\x90a\x1B\x84V[a\x150V[`@Qa\x05T\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[a\x05ea\x179V[`@Qa\x05r\x91\x90a!\xD8V[`@Q\x80\x91\x03\x90\xF3[a\x05\x95`\x04\x806\x03\x81\x01\x90a\x05\x90\x91\x90a\x1B\x84V[a\x17_V[`@Qa\x05\xA2\x91\x90a\x1B\xCCV[`@Q\x80\x91\x03\x90\xF3[`\0a\x05\xB6\x82a\x17_V[a\x05\xC3W`\0\x90Pa\x06\x8DV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x06e\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x19\xEF\xFE\xB4`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x062W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06V\x91\x90a\"\x1FV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x190V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16Ba\x06z\x91\x90a\"{V[\x11a\x06\x88W`\0\x90Pa\x06\x8DV[`\x01\x90P[\x91\x90PV[`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c%\x0Ei\xBD`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xDFW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x03\x91\x90a\"\xDBV[\x90P\x91\x90PV[`\0\x81\x90Pa\x07\x18\x81a\x10MV[a\x07NW`@Q\x7FG\xAD6z\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\x07Xa\x12\xECV[\x91PP\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x99s^2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xA7W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xCB\x91\x90a#\x1DV[\x11a\x08\x02W`@Q\x7FG\xAD6z\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x81`\x02`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7FGO\x18\rt\xEA\x87Q\x95^\xE2a\xC9?\xF8'\x04\x11\xB1\x80@\x8D\x10\x14\xC4\x9FU,\x92\xA4\xD1\x1E`@Q`@Q\x80\x91\x03\x90\xA2PPPV[`\0`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0`\x05`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x90P\x91\x90PV[`\0\x80`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c5\xE8\n\xB3`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\tuW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x99\x91\x90a#\x88V[\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\x06`\0\x90T\x90a\x01\0\n\x90\x04c\xFF\xFF\xFF\xFF\x16\x81V[`\0\x80a\n\x0B\x7F\xB51'hJV\x8B1s\xAE\x13\xB9\xF8\xA6\x01n$>c\xB6\xE8\xEE\x11x\xD6\xA7\x17\x85\x0B]a\x03`\0\x1Ba\x19:V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\nJW\x80\x91PPa\x0C2V[`\x02`@Q\x80`@\x01`@R\x80`\x1A\x81R` \x01\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0\x81RPQa\n\x8D\x91\x90a#\xB5V[\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0`\0\x1C\x17`\0\x1Ba\n\xE70`\0`@Q` \x01a\n\xCC\x92\x91\x90a$\x0FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x19EV[\x14a\x0B\x1EW`@Q\x7FT\xE43\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\x0BR0`\x01`@Q` \x01a\x0B7\x92\x91\x90a$\x0FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x19:V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x0C\0W\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xD3W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xF7\x91\x90a$dV[\x92PPPa\x0C2V[`@Q\x7F3!D\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x90V[`\x06`\x04\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x05` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[a\x0Cwa\t\x9EV[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15\x80\x15a\x0C\xA6WP\x80`\xFF\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10[a\x0C\xE5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x0C\xDC\x90a%\x03V[`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP`\x01`\0`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPa\r\"a\x19PV[\x84`\0`\x02a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x83`\x01`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x82`\x03`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U\x90PP\x81`\x06`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPB`\x06`\x04a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0\x80`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x81`@Qa\x0EQ\x91\x90a\x1C\xB9V[`@Q\x80\x91\x03\x90\xA1PPPPPV[`\0a\x0Ek\x82a\x150V[a\x0ExW`\0\x90Pa\x0E\xC1V[a\x0E\x81\x82a\x08\xB1V[\x15a\x0E\x8FW`\0\x90Pa\x0E\xC1V[a\x0E\x98\x82a\x0E\xFFV[\x15a\x0E\xA6W`\0\x90Pa\x0E\xC1V[a\x0E\xAEa\x0F\xB6V[\x15a\x0E\xBCW`\0\x90Pa\x0E\xC1V[`\x01\x90P[\x91\x90PV[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F3.5.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\0`\x06`\x04\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0F\xA3\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xCF\t\xE0\xD0`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FpW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\x94\x91\x90a\"\x1FV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x190V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x11\x15\x90P\x91\x90PV[`\0\x80`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\\\x97Z\xBB`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10$W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10H\x91\x90a\"\xDBV[\x90P\x90V[`\0a\x10X\x82a\x0E`V[a\x10eW`\0\x90Pa\x118V[a\x10n\x82a\x06\x92V[a\x10{W`\0\x90Pa\x118V[a\x10\x84\x82a\x05\xABV[a\x10\x91W`\0\x90Pa\x118V[`\x02\x80\x81\x11\x15a\x10\xA4Wa\x10\xA3a%#V[[\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xEFW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x13\x91\x90a%wV[`\x02\x81\x11\x15a\x11%Wa\x11$a%#V[[\x14a\x113W`\0\x90Pa\x118V[`\x01\x90P[\x91\x90PV[`\0\x80a\x11Ha\x12\xECV[\x91P\x91P\x91P\x91V[a\x11Ya\x19\xFFV[`\x01`\x05`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x19,(\x90&\xD5\x9AA\xA2\x7FZ\xEA\x08\xF3\x96\x9BW\x93\x1B\x05\x89 -\x14\xF46\x8C\xDE\xD9]<\xDA`@Q`@Q\x80\x91\x03\x90\xA2PV[a\x11\xFFa\x19\xFFV[\x80`\x06`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\xCE\xE0p;^K\xADN\xFE\xDE\xDA\xB8\\\x9F\xD1\xAE\xC1}\xEE|_lXC0\xE0P\x9BgwE\xA2\x81`@Qa\x12O\x91\x90a\x1D\x15V[`@Q\x80\x91\x03\x90\xA1PV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[a\x12\x8Aa\x19\xFFV[B`\x06`\x04a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7Fn[\x1B\xA7q\xE8\xE4\x84\xF7A\xED\x08_\x03\x9F\xF4\xE5\xC6\xE8\x82\xEA\xF6\x8FU\x0F\xB3\x90\x92-\n\xE4\xA7B`@Qa\x12\xE2\x91\x90a!6V[`@Q\x80\x91\x03\x90\xA1V[`\0\x80`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x13ZW`\x03`\0\x01T`\x03`\x01\x01T\x91P\x91Pa\x14\x89V[a\x13\xF3`\x02`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBC\xEF;U`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x13\xCAW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xEE\x91\x90a%\xD0V[a\x1A\xF6V[`\x02`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x99s^2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14`W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\x84\x91\x90a#\x1DV[\x91P\x91P[\x90\x91V[`\0a\x14\x97a\t\xDCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xE1W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x05\x91\x90a$dV[\x90P\x90V[`\x02`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0\x80`\0\x80\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFA$\xF7C`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15\x81W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\xAA\x91\x90a&\xBDV[\x92P\x92P\x92P`\0`\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c_\x01P\xCB\x85\x85\x85`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x16\x11\x93\x92\x91\x90a'\x90V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16-W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16Q\x91\x90a'\xE3V[P\x90P`\0\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\\\x0C\xBA3`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16\xA1W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16\xC5\x91\x90a(aV[\x90P\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x80\x15a\x17-WP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14[\x95PPPPPP\x91\x90PV[`\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0\x80a\x17\xE3\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x19\xEF\xFE\xB4`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x17\xB0W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x17\xD4\x91\x90a\"\x1FV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x190V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x19)WP`\x02\x80\x81\x11\x15a\x18\tWa\x18\x08a%#V[[\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18TW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x18x\x91\x90a%wV[`\x02\x81\x11\x15a\x18\x8AWa\x18\x89a%#V[[\x14\x80a\x19(WP`\x01`\x02\x81\x11\x15a\x18\xA5Wa\x18\xA4a%#V[[\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\xF0W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19\x14\x91\x90a%wV[`\x02\x81\x11\x15a\x19&Wa\x19%a%#V[[\x14[[\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x19oa\t\xDCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x19\xC6WP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x19\xADa\x14\x8DV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x15a\x19\xFDW`@Q\x7F\xC4\x05\n&\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[`\0`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cE*\x93 `@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1AlW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\x90\x91\x90a$dV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x1A\xF4W`@Q\x7F.S!\xAC\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[`\0\x81\x90P\x91\x90PV[`\0`@Q\x90P\x90V[`\0\x80\xFD[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x1B?\x82a\x1B\x14V[\x90P\x91\x90PV[`\0a\x1BQ\x82a\x1B4V[\x90P\x91\x90PV[a\x1Ba\x81a\x1BFV[\x81\x14a\x1BlW`\0\x80\xFD[PV[`\0\x815\x90Pa\x1B~\x81a\x1BXV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x1B\x9AWa\x1B\x99a\x1B\nV[[`\0a\x1B\xA8\x84\x82\x85\x01a\x1BoV[\x91PP\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\x1B\xC6\x81a\x1B\xB1V[\x82RPPV[`\0` \x82\x01\x90Pa\x1B\xE1`\0\x83\x01\x84a\x1B\xBDV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[`\0a\x1C\x0Ca\x1C\x07a\x1C\x02\x84a\x1B\x14V[a\x1B\xE7V[a\x1B\x14V[\x90P\x91\x90PV[`\0a\x1C\x1E\x82a\x1B\xF1V[\x90P\x91\x90PV[`\0a\x1C0\x82a\x1C\x13V[\x90P\x91\x90PV[a\x1C@\x81a\x1C%V[\x82RPPV[`\0` \x82\x01\x90Pa\x1C[`\0\x83\x01\x84a\x1C7V[\x92\x91PPV[`\0a\x1Cl\x82a\x1C\x13V[\x90P\x91\x90PV[a\x1C|\x81a\x1CaV[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\x97`\0\x83\x01\x84a\x1CsV[\x92\x91PPV[`\0`\xFF\x82\x16\x90P\x91\x90PV[a\x1C\xB3\x81a\x1C\x9DV[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\xCE`\0\x83\x01\x84a\x1C\xAAV[\x92\x91PPV[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x1C\xFFa\x1C\xFAa\x1C\xF5\x84a\x1C\xD4V[a\x1B\xE7V[a\x1C\xD4V[\x90P\x91\x90PV[a\x1D\x0F\x81a\x1C\xE4V[\x82RPPV[`\0` \x82\x01\x90Pa\x1D*`\0\x83\x01\x84a\x1D\x06V[\x92\x91PPV[`\0a\x1D;\x82a\x1C\x13V[\x90P\x91\x90PV[a\x1DK\x81a\x1D0V[\x82RPPV[`\0` \x82\x01\x90Pa\x1Df`\0\x83\x01\x84a\x1DBV[\x92\x91PPV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a\x1D\x89\x81a\x1DlV[\x82RPPV[`\0` \x82\x01\x90Pa\x1D\xA4`\0\x83\x01\x84a\x1D\x80V[\x92\x91PPV[`\0a\x1D\xB5\x82a\x1B4V[\x90P\x91\x90PV[a\x1D\xC5\x81a\x1D\xAAV[\x81\x14a\x1D\xD0W`\0\x80\xFD[PV[`\0\x815\x90Pa\x1D\xE2\x81a\x1D\xBCV[\x92\x91PPV[`\0a\x1D\xF3\x82a\x1B4V[\x90P\x91\x90PV[a\x1E\x03\x81a\x1D\xE8V[\x81\x14a\x1E\x0EW`\0\x80\xFD[PV[`\0\x815\x90Pa\x1E \x81a\x1D\xFAV[\x92\x91PPV[`\0\x80\xFD[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`A`\x04R`$`\0\xFD[a\x1Et\x82a\x1E+V[\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x1E\x93Wa\x1E\x92a\x1E\x81a(#V[\x81\x14a(IW`\0\x80\xFD[PV[`\0\x81Q\x90Pa([\x81a(5V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a(wWa(va\x1B\nV[[`\0a(\x85\x84\x82\x85\x01a(LV[\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 3\xF9\xB90\x8El?\x0B\xA0\xC0e\xAF\x01\t\xDF_\0\xE4j\xCD\xEA\x9F{jof\to\xDA\xB8T]dsolcC\0\x08\x0F\x003", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Hash(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Hash { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Hash { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Hash) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Hash { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Hash { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**```solidity +struct Proposal { Hash root; uint256 l2SequenceNumber; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Proposal { + #[allow(missing_docs)] + pub root: ::RustType, + #[allow(missing_docs)] + pub l2SequenceNumber: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: Proposal) -> Self { + (value.root, value.l2SequenceNumber) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for Proposal { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + root: tuple.0, + l2SequenceNumber: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for Proposal { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for Proposal { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize(&self.root), + as alloy_sol_types::SolType>::tokenize(&self.l2SequenceNumber), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Proposal { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for Proposal { + const NAME: &'static str = "Proposal"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "Proposal(bytes32 root,uint256 l2SequenceNumber)", + ) + } + #[inline] + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { + alloy_sol_types::private::Vec::new() + } + #[inline] + fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word(&self.root).0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.l2SequenceNumber, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Proposal { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.root, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.l2SequenceNumber, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.root, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.l2SequenceNumber, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + /**Custom error with signature `AnchorStateRegistry_InvalidAnchorGame()` and selector `0x47ad367a`. +```solidity +error AnchorStateRegistry_InvalidAnchorGame(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct AnchorStateRegistry_InvalidAnchorGame; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: AnchorStateRegistry_InvalidAnchorGame) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for AnchorStateRegistry_InvalidAnchorGame { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for AnchorStateRegistry_InvalidAnchorGame { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "AnchorStateRegistry_InvalidAnchorGame()"; + const SELECTOR: [u8; 4] = [71u8, 173u8, 54u8, 122u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `AnchorStateRegistry_Unauthorized()` and selector `0x2e5321ac`. +```solidity +error AnchorStateRegistry_Unauthorized(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct AnchorStateRegistry_Unauthorized; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: AnchorStateRegistry_Unauthorized) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for AnchorStateRegistry_Unauthorized { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for AnchorStateRegistry_Unauthorized { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "AnchorStateRegistry_Unauthorized()"; + const SELECTOR: [u8; 4] = [46u8, 83u8, 33u8, 172u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdmin()` and selector `0xe818dcc3`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdmin(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdmin; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdmin) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdmin { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdmin { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdmin()"; + const SELECTOR: [u8; 4] = [232u8, 24u8, 220u8, 195u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()` and selector `0xc4050a26`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [196u8, 5u8, 10u8, 38u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOwner()` and selector `0x7f12c64b`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [127u8, 18u8, 198u8, 75u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotResolvedDelegateProxy()` and selector `0x54e433cd`. +```solidity +error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotResolvedDelegateProxy; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotResolvedDelegateProxy) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotResolvedDelegateProxy()"; + const SELECTOR: [u8; 4] = [84u8, 228u8, 51u8, 205u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotSharedProxyAdminOwner()` and selector `0x075c4314`. +```solidity +error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotSharedProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotSharedProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotSharedProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [7u8, 92u8, 67u8, 20u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_ProxyAdminNotFound()` and selector `0x332144db`. +```solidity +error ProxyAdminOwnedBase_ProxyAdminNotFound(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_ProxyAdminNotFound; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_ProxyAdminNotFound) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_ProxyAdminNotFound { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_ProxyAdminNotFound { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_ProxyAdminNotFound()"; + const SELECTOR: [u8; 4] = [51u8, 33u8, 68u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ReinitializableBase_ZeroInitVersion()` and selector `0x9b01afed`. +```solidity +error ReinitializableBase_ZeroInitVersion(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ReinitializableBase_ZeroInitVersion; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ReinitializableBase_ZeroInitVersion) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ReinitializableBase_ZeroInitVersion { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ReinitializableBase_ZeroInitVersion { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ReinitializableBase_ZeroInitVersion()"; + const SELECTOR: [u8; 4] = [155u8, 1u8, 175u8, 237u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Event with signature `AnchorUpdated(address)` and selector `0x474f180d74ea8751955ee261c93ff8270411b180408d1014c49f552c92a4d11e`. +```solidity +event AnchorUpdated(address indexed game); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct AnchorUpdated { + #[allow(missing_docs)] + pub game: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for AnchorUpdated { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "AnchorUpdated(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 71u8, 79u8, 24u8, 13u8, 116u8, 234u8, 135u8, 81u8, 149u8, 94u8, 226u8, + 97u8, 201u8, 63u8, 248u8, 39u8, 4u8, 17u8, 177u8, 128u8, 64u8, 141u8, + 16u8, 20u8, 196u8, 159u8, 85u8, 44u8, 146u8, 164u8, 209u8, 30u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { game: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.game.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.game, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for AnchorUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&AnchorUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &AnchorUpdated) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `DisputeGameBlacklisted(address)` and selector `0x192c289026d59a41a27f5aea08f3969b57931b0589202d14f4368cded95d3cda`. +```solidity +event DisputeGameBlacklisted(address indexed disputeGame); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct DisputeGameBlacklisted { + #[allow(missing_docs)] + pub disputeGame: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for DisputeGameBlacklisted { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "DisputeGameBlacklisted(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 25u8, 44u8, 40u8, 144u8, 38u8, 213u8, 154u8, 65u8, 162u8, 127u8, 90u8, + 234u8, 8u8, 243u8, 150u8, 155u8, 87u8, 147u8, 27u8, 5u8, 137u8, 32u8, + 45u8, 20u8, 244u8, 54u8, 140u8, 222u8, 217u8, 93u8, 60u8, 218u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { disputeGame: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.disputeGame.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.disputeGame, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for DisputeGameBlacklisted { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&DisputeGameBlacklisted> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &DisputeGameBlacklisted) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`. +```solidity +event Initialized(uint8 version); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Initialized { + #[allow(missing_docs)] + pub version: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Initialized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Initialized(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { version: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Initialized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Initialized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Initialized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `RespectedGameTypeSet(uint32)` and selector `0xcee0703b5e4bad4efededab85c9fd1aec17dee7c5f6c584330e0509b677745a2`. +```solidity +event RespectedGameTypeSet(GameType gameType); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct RespectedGameTypeSet { + #[allow(missing_docs)] + pub gameType: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for RespectedGameTypeSet { + type DataTuple<'a> = (GameType,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "RespectedGameTypeSet(uint32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 206u8, 224u8, 112u8, 59u8, 94u8, 75u8, 173u8, 78u8, 254u8, 222u8, 218u8, + 184u8, 92u8, 159u8, 209u8, 174u8, 193u8, 125u8, 238u8, 124u8, 95u8, + 108u8, 88u8, 67u8, 48u8, 224u8, 80u8, 155u8, 103u8, 119u8, 69u8, 162u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { gameType: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + (::tokenize(&self.gameType),) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for RespectedGameTypeSet { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&RespectedGameTypeSet> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &RespectedGameTypeSet) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `RetirementTimestampSet(uint256)` and selector `0x6e5b1ba771e8e484f741ed085f039ff4e5c6e882eaf68f550fb390922d0ae4a7`. +```solidity +event RetirementTimestampSet(uint256 timestamp); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct RetirementTimestampSet { + #[allow(missing_docs)] + pub timestamp: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for RetirementTimestampSet { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "RetirementTimestampSet(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 110u8, 91u8, 27u8, 167u8, 113u8, 232u8, 228u8, 132u8, 247u8, 65u8, 237u8, + 8u8, 95u8, 3u8, 159u8, 244u8, 229u8, 198u8, 232u8, 130u8, 234u8, 246u8, + 143u8, 85u8, 15u8, 179u8, 144u8, 146u8, 45u8, 10u8, 228u8, 167u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { timestamp: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.timestamp), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for RetirementTimestampSet { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&RetirementTimestampSet> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &RetirementTimestampSet) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(uint256 _disputeGameFinalityDelaySeconds); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._disputeGameFinalityDelaySeconds,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _disputeGameFinalityDelaySeconds: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize( + &self._disputeGameFinalityDelaySeconds, + ), + ) + } + } + }; + /**Function with signature `anchorGame()` and selector `0xe0a840eb`. +```solidity +function anchorGame() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorGameCall; + ///Container type for the return parameters of the [`anchorGame()`](anchorGameCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorGameReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: anchorGameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for anchorGameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: anchorGameReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for anchorGameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for anchorGameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "anchorGame()"; + const SELECTOR: [u8; 4] = [224u8, 168u8, 64u8, 235u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: anchorGameReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: anchorGameReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `anchors(uint32)` and selector `0x7258a807`. +```solidity +function anchors(GameType) external view returns (Hash, uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorsCall(pub ::RustType); + ///Container type for the return parameters of the [`anchors(uint32)`](anchorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorsReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + #[allow(missing_docs)] + pub _1: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: anchorsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for anchorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: anchorsReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for anchorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl anchorsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self._0), + as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for anchorsCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = anchorsReturn; + type ReturnTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "anchors(uint32)"; + const SELECTOR: [u8; 4] = [114u8, 88u8, 168u8, 7u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.0),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + anchorsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `blacklistDisputeGame(address)` and selector `0x7d6be8dc`. +```solidity +function blacklistDisputeGame(address _disputeGame) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct blacklistDisputeGameCall { + #[allow(missing_docs)] + pub _disputeGame: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`blacklistDisputeGame(address)`](blacklistDisputeGameCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct blacklistDisputeGameReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: blacklistDisputeGameCall) -> Self { + (value._disputeGame,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for blacklistDisputeGameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _disputeGame: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: blacklistDisputeGameReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for blacklistDisputeGameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl blacklistDisputeGameReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for blacklistDisputeGameCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = blacklistDisputeGameReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "blacklistDisputeGame(address)"; + const SELECTOR: [u8; 4] = [125u8, 107u8, 232u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._disputeGame, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + blacklistDisputeGameReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `disputeGameBlacklist(address)` and selector `0x45884d32`. +```solidity +function disputeGameBlacklist(address) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameBlacklistCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`disputeGameBlacklist(address)`](disputeGameBlacklistCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameBlacklistReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameBlacklistCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameBlacklistCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameBlacklistReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameBlacklistReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameBlacklistCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameBlacklist(address)"; + const SELECTOR: [u8; 4] = [69u8, 136u8, 77u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameBlacklistReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameBlacklistReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `disputeGameFactory()` and selector `0xf2b4e617`. +```solidity +function disputeGameFactory() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFactoryCall; + ///Container type for the return parameters of the [`disputeGameFactory()`](disputeGameFactoryCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFactoryReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFactoryCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFactoryCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFactoryReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFactoryReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameFactoryCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameFactory()"; + const SELECTOR: [u8; 4] = [242u8, 180u8, 230u8, 23u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameFactoryReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameFactoryReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `disputeGameFinalityDelaySeconds()` and selector `0x952b2797`. +```solidity +function disputeGameFinalityDelaySeconds() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFinalityDelaySecondsCall; + ///Container type for the return parameters of the [`disputeGameFinalityDelaySeconds()`](disputeGameFinalityDelaySecondsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFinalityDelaySecondsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFinalityDelaySecondsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFinalityDelaySecondsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFinalityDelaySecondsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFinalityDelaySecondsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameFinalityDelaySecondsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameFinalityDelaySeconds()"; + const SELECTOR: [u8; 4] = [149u8, 43u8, 39u8, 151u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameFinalityDelaySecondsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameFinalityDelaySecondsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `getAnchorRoot()` and selector `0xd83ef267`. +```solidity +function getAnchorRoot() external view returns (Hash, uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getAnchorRootCall; + ///Container type for the return parameters of the [`getAnchorRoot()`](getAnchorRootCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getAnchorRootReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + #[allow(missing_docs)] + pub _1: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getAnchorRootCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getAnchorRootCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getAnchorRootReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getAnchorRootReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl getAnchorRootReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self._0), + as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getAnchorRootCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getAnchorRootReturn; + type ReturnTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getAnchorRoot()"; + const SELECTOR: [u8; 4] = [216u8, 62u8, 242u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getAnchorRootReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `initVersion()` and selector `0x38d38c97`. +```solidity +function initVersion() external view returns (uint8); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionCall; + ///Container type for the return parameters of the [`initVersion()`](initVersionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionReturn { + #[allow(missing_docs)] + pub _0: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u8,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initVersionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initVersion()"; + const SELECTOR: [u8; 4] = [56u8, 211u8, 140u8, 151u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initialize(address,address,(bytes32,uint256),uint32)` and selector `0x47a222c5`. +```solidity +function initialize(address _systemConfig, address _disputeGameFactory, Proposal memory _startingAnchorRoot, GameType _startingRespectedGameType) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall { + #[allow(missing_docs)] + pub _systemConfig: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _disputeGameFactory: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _startingAnchorRoot: ::RustType, + #[allow(missing_docs)] + pub _startingRespectedGameType: ::RustType, + } + ///Container type for the return parameters of the [`initialize(address,address,(bytes32,uint256),uint32)`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + Proposal, + GameType, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + ::RustType, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + ( + value._systemConfig, + value._disputeGameFactory, + value._startingAnchorRoot, + value._startingRespectedGameType, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _systemConfig: tuple.0, + _disputeGameFactory: tuple.1, + _startingAnchorRoot: tuple.2, + _startingRespectedGameType: tuple.3, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + Proposal, + GameType, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize(address,address,(bytes32,uint256),uint32)"; + const SELECTOR: [u8; 4] = [71u8, 162u8, 34u8, 197u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._systemConfig, + ), + ::tokenize( + &self._disputeGameFactory, + ), + ::tokenize( + &self._startingAnchorRoot, + ), + ::tokenize( + &self._startingRespectedGameType, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `isGameBlacklisted(address)` and selector `0x34a346ea`. +```solidity +function isGameBlacklisted(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameBlacklistedCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameBlacklisted(address)`](isGameBlacklistedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameBlacklistedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameBlacklistedCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameBlacklistedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameBlacklistedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameBlacklistedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameBlacklistedCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameBlacklisted(address)"; + const SELECTOR: [u8; 4] = [52u8, 163u8, 70u8, 234u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameBlacklistedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameBlacklistedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameClaimValid(address)` and selector `0x6c4f4467`. +```solidity +function isGameClaimValid(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameClaimValidCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameClaimValid(address)`](isGameClaimValidCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameClaimValidReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameClaimValidCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameClaimValidCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameClaimValidReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameClaimValidReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameClaimValidCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameClaimValid(address)"; + const SELECTOR: [u8; 4] = [108u8, 79u8, 68u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameClaimValidReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameClaimValidReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameFinalized(address)` and selector `0x0314d2b3`. +```solidity +function isGameFinalized(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameFinalizedCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameFinalized(address)`](isGameFinalizedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameFinalizedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameFinalizedCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameFinalizedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameFinalizedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameFinalizedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameFinalizedCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameFinalized(address)"; + const SELECTOR: [u8; 4] = [3u8, 20u8, 210u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameFinalizedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameFinalizedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameProper(address)` and selector `0x496b9c16`. +```solidity +function isGameProper(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameProperCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameProper(address)`](isGameProperCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameProperReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameProperCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameProperCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameProperReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameProperReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameProperCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameProper(address)"; + const SELECTOR: [u8; 4] = [73u8, 107u8, 156u8, 22u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameProperReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameProperReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameRegistered(address)` and selector `0xee658e45`. +```solidity +function isGameRegistered(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRegisteredCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameRegistered(address)`](isGameRegisteredCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRegisteredReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameRegisteredCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameRegisteredCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameRegisteredReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameRegisteredReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameRegisteredCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameRegistered(address)"; + const SELECTOR: [u8; 4] = [238u8, 101u8, 142u8, 69u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameRegisteredReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameRegisteredReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameResolved(address)` and selector `0xfdbb3dcf`. +```solidity +function isGameResolved(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameResolvedCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameResolved(address)`](isGameResolvedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameResolvedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameResolvedCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameResolvedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameResolvedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameResolvedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameResolvedCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameResolved(address)"; + const SELECTOR: [u8; 4] = [253u8, 187u8, 61u8, 207u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameResolvedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameResolvedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameRespected(address)` and selector `0x04e50fed`. +```solidity +function isGameRespected(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRespectedCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameRespected(address)`](isGameRespectedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRespectedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameRespectedCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameRespectedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameRespectedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameRespectedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameRespectedCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameRespected(address)"; + const SELECTOR: [u8; 4] = [4u8, 229u8, 15u8, 237u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameRespectedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameRespectedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameRetired(address)` and selector `0x5958a193`. +```solidity +function isGameRetired(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRetiredCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameRetired(address)`](isGameRetiredCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRetiredReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameRetiredCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameRetiredCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameRetiredReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameRetiredReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameRetiredCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameRetired(address)"; + const SELECTOR: [u8; 4] = [89u8, 88u8, 161u8, 147u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameRetiredReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameRetiredReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `paused()` and selector `0x5c975abb`. +```solidity +function paused() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pausedCall; + ///Container type for the return parameters of the [`paused()`](pausedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pausedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pausedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pausedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pausedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pausedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pausedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "paused()"; + const SELECTOR: [u8; 4] = [92u8, 151u8, 90u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: pausedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: pausedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdmin()` and selector `0x3e47158c`. +```solidity +function proxyAdmin() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminCall; + ///Container type for the return parameters of the [`proxyAdmin()`](proxyAdminCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdmin()"; + const SELECTOR: [u8; 4] = [62u8, 71u8, 21u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdminOwner()` and selector `0xdad544e0`. +```solidity +function proxyAdminOwner() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerCall; + ///Container type for the return parameters of the [`proxyAdminOwner()`](proxyAdminOwnerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminOwnerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proxyAdminOwnerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminOwnerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdminOwner()"; + const SELECTOR: [u8; 4] = [218u8, 213u8, 68u8, 224u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `respectedGameType()` and selector `0x3c9f397c`. +```solidity +function respectedGameType() external view returns (GameType); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct respectedGameTypeCall; + ///Container type for the return parameters of the [`respectedGameType()`](respectedGameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct respectedGameTypeReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: respectedGameTypeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for respectedGameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: respectedGameTypeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for respectedGameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for respectedGameTypeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameType,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "respectedGameType()"; + const SELECTOR: [u8; 4] = [60u8, 159u8, 57u8, 124u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: respectedGameTypeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: respectedGameTypeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `retirementTimestamp()` and selector `0x4086d183`. +```solidity +function retirementTimestamp() external view returns (uint64); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct retirementTimestampCall; + ///Container type for the return parameters of the [`retirementTimestamp()`](retirementTimestampCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct retirementTimestampReturn { + #[allow(missing_docs)] + pub _0: u64, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: retirementTimestampCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for retirementTimestampCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u64,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: retirementTimestampReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for retirementTimestampReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for retirementTimestampCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u64; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "retirementTimestamp()"; + const SELECTOR: [u8; 4] = [64u8, 134u8, 209u8, 131u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: retirementTimestampReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: retirementTimestampReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `setAnchorState(address)` and selector `0x17cf21a9`. +```solidity +function setAnchorState(address _game) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setAnchorStateCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`setAnchorState(address)`](setAnchorStateCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setAnchorStateReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setAnchorStateCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setAnchorStateCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setAnchorStateReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setAnchorStateReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setAnchorStateReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setAnchorStateCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setAnchorStateReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setAnchorState(address)"; + const SELECTOR: [u8; 4] = [23u8, 207u8, 33u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setAnchorStateReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setRespectedGameType(uint32)` and selector `0x7fc48504`. +```solidity +function setRespectedGameType(GameType _gameType) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setRespectedGameTypeCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + } + ///Container type for the return parameters of the [`setRespectedGameType(uint32)`](setRespectedGameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setRespectedGameTypeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setRespectedGameTypeCall) -> Self { + (value._gameType,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setRespectedGameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _gameType: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setRespectedGameTypeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setRespectedGameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setRespectedGameTypeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setRespectedGameTypeCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setRespectedGameTypeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setRespectedGameType(uint32)"; + const SELECTOR: [u8; 4] = [127u8, 196u8, 133u8, 4u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self._gameType),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setRespectedGameTypeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `superchainConfig()` and selector `0x35e80ab3`. +```solidity +function superchainConfig() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct superchainConfigCall; + ///Container type for the return parameters of the [`superchainConfig()`](superchainConfigCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct superchainConfigReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: superchainConfigCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for superchainConfigCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: superchainConfigReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for superchainConfigReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for superchainConfigCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "superchainConfig()"; + const SELECTOR: [u8; 4] = [53u8, 232u8, 10u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: superchainConfigReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: superchainConfigReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `systemConfig()` and selector `0x33d7e2bd`. +```solidity +function systemConfig() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct systemConfigCall; + ///Container type for the return parameters of the [`systemConfig()`](systemConfigCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct systemConfigReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: systemConfigCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for systemConfigCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: systemConfigReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for systemConfigReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for systemConfigCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "systemConfig()"; + const SELECTOR: [u8; 4] = [51u8, 215u8, 226u8, 189u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: systemConfigReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: systemConfigReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `updateRetirementTimestamp()` and selector `0xd5a3e12e`. +```solidity +function updateRetirementTimestamp() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct updateRetirementTimestampCall; + ///Container type for the return parameters of the [`updateRetirementTimestamp()`](updateRetirementTimestampCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct updateRetirementTimestampReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: updateRetirementTimestampCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for updateRetirementTimestampCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: updateRetirementTimestampReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for updateRetirementTimestampReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl updateRetirementTimestampReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for updateRetirementTimestampCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = updateRetirementTimestampReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "updateRetirementTimestamp()"; + const SELECTOR: [u8; 4] = [213u8, 163u8, 225u8, 46u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + updateRetirementTimestampReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `version()` and selector `0x54fd4d50`. +```solidity +function version() external view returns (string memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionCall; + ///Container type for the return parameters of the [`version()`](versionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for versionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "version()"; + const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`AnchorStateRegistry`](self) function calls. + #[derive(Clone)] + pub enum AnchorStateRegistryCalls { + #[allow(missing_docs)] + anchorGame(anchorGameCall), + #[allow(missing_docs)] + anchors(anchorsCall), + #[allow(missing_docs)] + blacklistDisputeGame(blacklistDisputeGameCall), + #[allow(missing_docs)] + disputeGameBlacklist(disputeGameBlacklistCall), + #[allow(missing_docs)] + disputeGameFactory(disputeGameFactoryCall), + #[allow(missing_docs)] + disputeGameFinalityDelaySeconds(disputeGameFinalityDelaySecondsCall), + #[allow(missing_docs)] + getAnchorRoot(getAnchorRootCall), + #[allow(missing_docs)] + initVersion(initVersionCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + isGameBlacklisted(isGameBlacklistedCall), + #[allow(missing_docs)] + isGameClaimValid(isGameClaimValidCall), + #[allow(missing_docs)] + isGameFinalized(isGameFinalizedCall), + #[allow(missing_docs)] + isGameProper(isGameProperCall), + #[allow(missing_docs)] + isGameRegistered(isGameRegisteredCall), + #[allow(missing_docs)] + isGameResolved(isGameResolvedCall), + #[allow(missing_docs)] + isGameRespected(isGameRespectedCall), + #[allow(missing_docs)] + isGameRetired(isGameRetiredCall), + #[allow(missing_docs)] + paused(pausedCall), + #[allow(missing_docs)] + proxyAdmin(proxyAdminCall), + #[allow(missing_docs)] + proxyAdminOwner(proxyAdminOwnerCall), + #[allow(missing_docs)] + respectedGameType(respectedGameTypeCall), + #[allow(missing_docs)] + retirementTimestamp(retirementTimestampCall), + #[allow(missing_docs)] + setAnchorState(setAnchorStateCall), + #[allow(missing_docs)] + setRespectedGameType(setRespectedGameTypeCall), + #[allow(missing_docs)] + superchainConfig(superchainConfigCall), + #[allow(missing_docs)] + systemConfig(systemConfigCall), + #[allow(missing_docs)] + updateRetirementTimestamp(updateRetirementTimestampCall), + #[allow(missing_docs)] + version(versionCall), + } + impl AnchorStateRegistryCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [3u8, 20u8, 210u8, 179u8], + [4u8, 229u8, 15u8, 237u8], + [23u8, 207u8, 33u8, 169u8], + [51u8, 215u8, 226u8, 189u8], + [52u8, 163u8, 70u8, 234u8], + [53u8, 232u8, 10u8, 179u8], + [56u8, 211u8, 140u8, 151u8], + [60u8, 159u8, 57u8, 124u8], + [62u8, 71u8, 21u8, 140u8], + [64u8, 134u8, 209u8, 131u8], + [69u8, 136u8, 77u8, 50u8], + [71u8, 162u8, 34u8, 197u8], + [73u8, 107u8, 156u8, 22u8], + [84u8, 253u8, 77u8, 80u8], + [89u8, 88u8, 161u8, 147u8], + [92u8, 151u8, 90u8, 187u8], + [108u8, 79u8, 68u8, 103u8], + [114u8, 88u8, 168u8, 7u8], + [125u8, 107u8, 232u8, 220u8], + [127u8, 196u8, 133u8, 4u8], + [149u8, 43u8, 39u8, 151u8], + [213u8, 163u8, 225u8, 46u8], + [216u8, 62u8, 242u8, 103u8], + [218u8, 213u8, 68u8, 224u8], + [224u8, 168u8, 64u8, 235u8], + [238u8, 101u8, 142u8, 69u8], + [242u8, 180u8, 230u8, 23u8], + [253u8, 187u8, 61u8, 207u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(isGameFinalized), + ::core::stringify!(isGameRespected), + ::core::stringify!(setAnchorState), + ::core::stringify!(systemConfig), + ::core::stringify!(isGameBlacklisted), + ::core::stringify!(superchainConfig), + ::core::stringify!(initVersion), + ::core::stringify!(respectedGameType), + ::core::stringify!(proxyAdmin), + ::core::stringify!(retirementTimestamp), + ::core::stringify!(disputeGameBlacklist), + ::core::stringify!(initialize), + ::core::stringify!(isGameProper), + ::core::stringify!(version), + ::core::stringify!(isGameRetired), + ::core::stringify!(paused), + ::core::stringify!(isGameClaimValid), + ::core::stringify!(anchors), + ::core::stringify!(blacklistDisputeGame), + ::core::stringify!(setRespectedGameType), + ::core::stringify!(disputeGameFinalityDelaySeconds), + ::core::stringify!(updateRetirementTimestamp), + ::core::stringify!(getAnchorRoot), + ::core::stringify!(proxyAdminOwner), + ::core::stringify!(anchorGame), + ::core::stringify!(isGameRegistered), + ::core::stringify!(disputeGameFactory), + ::core::stringify!(isGameResolved), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for AnchorStateRegistryCalls { + const NAME: &'static str = "AnchorStateRegistryCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 28usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::anchorGame(_) => { + ::SELECTOR + } + Self::anchors(_) => ::SELECTOR, + Self::blacklistDisputeGame(_) => { + ::SELECTOR + } + Self::disputeGameBlacklist(_) => { + ::SELECTOR + } + Self::disputeGameFactory(_) => { + ::SELECTOR + } + Self::disputeGameFinalityDelaySeconds(_) => { + ::SELECTOR + } + Self::getAnchorRoot(_) => { + ::SELECTOR + } + Self::initVersion(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } + Self::isGameBlacklisted(_) => { + ::SELECTOR + } + Self::isGameClaimValid(_) => { + ::SELECTOR + } + Self::isGameFinalized(_) => { + ::SELECTOR + } + Self::isGameProper(_) => { + ::SELECTOR + } + Self::isGameRegistered(_) => { + ::SELECTOR + } + Self::isGameResolved(_) => { + ::SELECTOR + } + Self::isGameRespected(_) => { + ::SELECTOR + } + Self::isGameRetired(_) => { + ::SELECTOR + } + Self::paused(_) => ::SELECTOR, + Self::proxyAdmin(_) => { + ::SELECTOR + } + Self::proxyAdminOwner(_) => { + ::SELECTOR + } + Self::respectedGameType(_) => { + ::SELECTOR + } + Self::retirementTimestamp(_) => { + ::SELECTOR + } + Self::setAnchorState(_) => { + ::SELECTOR + } + Self::setRespectedGameType(_) => { + ::SELECTOR + } + Self::superchainConfig(_) => { + ::SELECTOR + } + Self::systemConfig(_) => { + ::SELECTOR + } + Self::updateRetirementTimestamp(_) => { + ::SELECTOR + } + Self::version(_) => ::SELECTOR, + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isGameFinalized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::isGameFinalized) + } + isGameFinalized + }, + { + fn isGameRespected( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::isGameRespected) + } + isGameRespected + }, + { + fn setAnchorState( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::setAnchorState) + } + setAnchorState + }, + { + fn systemConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::systemConfig) + } + systemConfig + }, + { + fn isGameBlacklisted( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::isGameBlacklisted) + } + isGameBlacklisted + }, + { + fn superchainConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::superchainConfig) + } + superchainConfig + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::initVersion) + } + initVersion + }, + { + fn respectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::respectedGameType) + } + respectedGameType + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn retirementTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::retirementTimestamp) + } + retirementTimestamp + }, + { + fn disputeGameBlacklist( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::disputeGameBlacklist) + } + disputeGameBlacklist + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::initialize) + } + initialize + }, + { + fn isGameProper( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::isGameProper) + } + isGameProper + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AnchorStateRegistryCalls::version) + } + version + }, + { + fn isGameRetired( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::isGameRetired) + } + isGameRetired + }, + { + fn paused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AnchorStateRegistryCalls::paused) + } + paused + }, + { + fn isGameClaimValid( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::isGameClaimValid) + } + isGameClaimValid + }, + { + fn anchors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AnchorStateRegistryCalls::anchors) + } + anchors + }, + { + fn blacklistDisputeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::blacklistDisputeGame) + } + blacklistDisputeGame + }, + { + fn setRespectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::setRespectedGameType) + } + setRespectedGameType + }, + { + fn disputeGameFinalityDelaySeconds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryCalls::disputeGameFinalityDelaySeconds, + ) + } + disputeGameFinalityDelaySeconds + }, + { + fn updateRetirementTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::updateRetirementTimestamp) + } + updateRetirementTimestamp + }, + { + fn getAnchorRoot( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::getAnchorRoot) + } + getAnchorRoot + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn anchorGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::anchorGame) + } + anchorGame + }, + { + fn isGameRegistered( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::isGameRegistered) + } + isGameRegistered + }, + { + fn disputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::disputeGameFactory) + } + disputeGameFactory + }, + { + fn isGameResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AnchorStateRegistryCalls::isGameResolved) + } + isGameResolved + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isGameFinalized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::isGameFinalized) + } + isGameFinalized + }, + { + fn isGameRespected( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::isGameRespected) + } + isGameRespected + }, + { + fn setAnchorState( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::setAnchorState) + } + setAnchorState + }, + { + fn systemConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::systemConfig) + } + systemConfig + }, + { + fn isGameBlacklisted( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::isGameBlacklisted) + } + isGameBlacklisted + }, + { + fn superchainConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::superchainConfig) + } + superchainConfig + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::initVersion) + } + initVersion + }, + { + fn respectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::respectedGameType) + } + respectedGameType + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn retirementTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::retirementTimestamp) + } + retirementTimestamp + }, + { + fn disputeGameBlacklist( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::disputeGameBlacklist) + } + disputeGameBlacklist + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::initialize) + } + initialize + }, + { + fn isGameProper( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::isGameProper) + } + isGameProper + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::version) + } + version + }, + { + fn isGameRetired( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::isGameRetired) + } + isGameRetired + }, + { + fn paused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::paused) + } + paused + }, + { + fn isGameClaimValid( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::isGameClaimValid) + } + isGameClaimValid + }, + { + fn anchors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::anchors) + } + anchors + }, + { + fn blacklistDisputeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::blacklistDisputeGame) + } + blacklistDisputeGame + }, + { + fn setRespectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::setRespectedGameType) + } + setRespectedGameType + }, + { + fn disputeGameFinalityDelaySeconds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryCalls::disputeGameFinalityDelaySeconds, + ) + } + disputeGameFinalityDelaySeconds + }, + { + fn updateRetirementTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::updateRetirementTimestamp) + } + updateRetirementTimestamp + }, + { + fn getAnchorRoot( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::getAnchorRoot) + } + getAnchorRoot + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn anchorGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::anchorGame) + } + anchorGame + }, + { + fn isGameRegistered( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::isGameRegistered) + } + isGameRegistered + }, + { + fn disputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::disputeGameFactory) + } + disputeGameFactory + }, + { + fn isGameResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AnchorStateRegistryCalls::isGameResolved) + } + isGameResolved + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::anchorGame(inner) => { + ::abi_encoded_size(inner) + } + Self::anchors(inner) => { + ::abi_encoded_size(inner) + } + Self::blacklistDisputeGame(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disputeGameBlacklist(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disputeGameFactory(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disputeGameFinalityDelaySeconds(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getAnchorRoot(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::isGameBlacklisted(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameClaimValid(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameFinalized(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameProper(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameRegistered(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameResolved(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameRespected(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameRetired(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::paused(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdmin(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::respectedGameType(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::retirementTimestamp(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setAnchorState(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setRespectedGameType(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::superchainConfig(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::systemConfig(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::updateRetirementTimestamp(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::version(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::anchorGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::anchors(inner) => { + ::abi_encode_raw(inner, out) + } + Self::blacklistDisputeGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disputeGameBlacklist(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disputeGameFactory(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disputeGameFinalityDelaySeconds(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getAnchorRoot(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameBlacklisted(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameClaimValid(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameFinalized(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameProper(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameRegistered(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameResolved(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameRespected(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameRetired(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::paused(inner) => { + ::abi_encode_raw(inner, out) + } + Self::proxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::respectedGameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::retirementTimestamp(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setAnchorState(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setRespectedGameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::superchainConfig(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::systemConfig(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::updateRetirementTimestamp(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::version(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`AnchorStateRegistry`](self) custom errors. + #[derive(Clone)] + pub enum AnchorStateRegistryErrors { + #[allow(missing_docs)] + AnchorStateRegistry_InvalidAnchorGame(AnchorStateRegistry_InvalidAnchorGame), + #[allow(missing_docs)] + AnchorStateRegistry_Unauthorized(AnchorStateRegistry_Unauthorized), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdmin(ProxyAdminOwnedBase_NotProxyAdmin), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOwner(ProxyAdminOwnedBase_NotProxyAdminOwner), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotResolvedDelegateProxy( + ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_ProxyAdminNotFound(ProxyAdminOwnedBase_ProxyAdminNotFound), + #[allow(missing_docs)] + ReinitializableBase_ZeroInitVersion(ReinitializableBase_ZeroInitVersion), + } + impl AnchorStateRegistryErrors { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [7u8, 92u8, 67u8, 20u8], + [46u8, 83u8, 33u8, 172u8], + [51u8, 33u8, 68u8, 219u8], + [71u8, 173u8, 54u8, 122u8], + [84u8, 228u8, 51u8, 205u8], + [127u8, 18u8, 198u8, 75u8], + [155u8, 1u8, 175u8, 237u8], + [196u8, 5u8, 10u8, 38u8], + [232u8, 24u8, 220u8, 195u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(ProxyAdminOwnedBase_NotSharedProxyAdminOwner), + ::core::stringify!(AnchorStateRegistry_Unauthorized), + ::core::stringify!(ProxyAdminOwnedBase_ProxyAdminNotFound), + ::core::stringify!(AnchorStateRegistry_InvalidAnchorGame), + ::core::stringify!(ProxyAdminOwnedBase_NotResolvedDelegateProxy), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOwner), + ::core::stringify!(ReinitializableBase_ZeroInitVersion), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdmin), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for AnchorStateRegistryErrors { + const NAME: &'static str = "AnchorStateRegistryErrors"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 9usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::AnchorStateRegistry_InvalidAnchorGame(_) => { + ::SELECTOR + } + Self::AnchorStateRegistry_Unauthorized(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(_) => { + ::SELECTOR + } + Self::ReinitializableBase_ZeroInitVersion(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn AnchorStateRegistry_Unauthorized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryErrors::AnchorStateRegistry_Unauthorized, + ) + } + AnchorStateRegistry_Unauthorized + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn AnchorStateRegistry_InvalidAnchorGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryErrors::AnchorStateRegistry_InvalidAnchorGame, + ) + } + AnchorStateRegistry_InvalidAnchorGame + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn AnchorStateRegistry_Unauthorized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryErrors::AnchorStateRegistry_Unauthorized, + ) + } + AnchorStateRegistry_Unauthorized + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn AnchorStateRegistry_InvalidAnchorGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryErrors::AnchorStateRegistry_InvalidAnchorGame, + ) + } + AnchorStateRegistry_InvalidAnchorGame + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::AnchorStateRegistry_InvalidAnchorGame(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::AnchorStateRegistry_Unauthorized(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::AnchorStateRegistry_InvalidAnchorGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::AnchorStateRegistry_Unauthorized(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`AnchorStateRegistry`](self) events. + #[derive(Clone)] + pub enum AnchorStateRegistryEvents { + #[allow(missing_docs)] + AnchorUpdated(AnchorUpdated), + #[allow(missing_docs)] + DisputeGameBlacklisted(DisputeGameBlacklisted), + #[allow(missing_docs)] + Initialized(Initialized), + #[allow(missing_docs)] + RespectedGameTypeSet(RespectedGameTypeSet), + #[allow(missing_docs)] + RetirementTimestampSet(RetirementTimestampSet), + } + impl AnchorStateRegistryEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 25u8, 44u8, 40u8, 144u8, 38u8, 213u8, 154u8, 65u8, 162u8, 127u8, 90u8, + 234u8, 8u8, 243u8, 150u8, 155u8, 87u8, 147u8, 27u8, 5u8, 137u8, 32u8, + 45u8, 20u8, 244u8, 54u8, 140u8, 222u8, 217u8, 93u8, 60u8, 218u8, + ], + [ + 71u8, 79u8, 24u8, 13u8, 116u8, 234u8, 135u8, 81u8, 149u8, 94u8, 226u8, + 97u8, 201u8, 63u8, 248u8, 39u8, 4u8, 17u8, 177u8, 128u8, 64u8, 141u8, + 16u8, 20u8, 196u8, 159u8, 85u8, 44u8, 146u8, 164u8, 209u8, 30u8, + ], + [ + 110u8, 91u8, 27u8, 167u8, 113u8, 232u8, 228u8, 132u8, 247u8, 65u8, 237u8, + 8u8, 95u8, 3u8, 159u8, 244u8, 229u8, 198u8, 232u8, 130u8, 234u8, 246u8, + 143u8, 85u8, 15u8, 179u8, 144u8, 146u8, 45u8, 10u8, 228u8, 167u8, + ], + [ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ], + [ + 206u8, 224u8, 112u8, 59u8, 94u8, 75u8, 173u8, 78u8, 254u8, 222u8, 218u8, + 184u8, 92u8, 159u8, 209u8, 174u8, 193u8, 125u8, 238u8, 124u8, 95u8, + 108u8, 88u8, 67u8, 48u8, 224u8, 80u8, 155u8, 103u8, 119u8, 69u8, 162u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(DisputeGameBlacklisted), + ::core::stringify!(AnchorUpdated), + ::core::stringify!(RetirementTimestampSet), + ::core::stringify!(Initialized), + ::core::stringify!(RespectedGameTypeSet), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for AnchorStateRegistryEvents { + const NAME: &'static str = "AnchorStateRegistryEvents"; + const COUNT: usize = 5usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::AnchorUpdated) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::DisputeGameBlacklisted) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::Initialized) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::RespectedGameTypeSet) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::RetirementTimestampSet) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for AnchorStateRegistryEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::AnchorUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::DisputeGameBlacklisted(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::RespectedGameTypeSet(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::RetirementTimestampSet(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::AnchorUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::DisputeGameBlacklisted(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::RespectedGameTypeSet(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::RetirementTimestampSet(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`AnchorStateRegistry`](self) contract instance. + +See the [wrapper's documentation](`AnchorStateRegistryInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> AnchorStateRegistryInstance { + AnchorStateRegistryInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + AnchorStateRegistryInstance::< + P, + N, + >::deploy(__provider, _disputeGameFinalityDelaySeconds) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::RawCallBuilder { + AnchorStateRegistryInstance::< + P, + N, + >::deploy_builder(__provider, _disputeGameFinalityDelaySeconds) + } + /**A [`AnchorStateRegistry`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`AnchorStateRegistry`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct AnchorStateRegistryInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for AnchorStateRegistryInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("AnchorStateRegistryInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AnchorStateRegistryInstance { + /**Creates a new wrapper around an on-chain [`AnchorStateRegistry`](self) contract instance. + +See the [wrapper's documentation](`AnchorStateRegistryInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + __provider, + _disputeGameFinalityDelaySeconds, + ); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder( + __provider: P, + _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _disputeGameFinalityDelaySeconds, + }, + )[..], + ] + .concat() + .into(), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl AnchorStateRegistryInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> AnchorStateRegistryInstance { + AnchorStateRegistryInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AnchorStateRegistryInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`anchorGame`] function. + pub fn anchorGame( + &self, + ) -> alloy_contract::SolCallBuilder<&P, anchorGameCall, N> { + self.call_builder(&anchorGameCall) + } + ///Creates a new call builder for the [`anchors`] function. + pub fn anchors( + &self, + _0: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, anchorsCall, N> { + self.call_builder(&anchorsCall(_0)) + } + ///Creates a new call builder for the [`blacklistDisputeGame`] function. + pub fn blacklistDisputeGame( + &self, + _disputeGame: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, blacklistDisputeGameCall, N> { + self.call_builder( + &blacklistDisputeGameCall { + _disputeGame, + }, + ) + } + ///Creates a new call builder for the [`disputeGameBlacklist`] function. + pub fn disputeGameBlacklist( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameBlacklistCall, N> { + self.call_builder(&disputeGameBlacklistCall(_0)) + } + ///Creates a new call builder for the [`disputeGameFactory`] function. + pub fn disputeGameFactory( + &self, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameFactoryCall, N> { + self.call_builder(&disputeGameFactoryCall) + } + ///Creates a new call builder for the [`disputeGameFinalityDelaySeconds`] function. + pub fn disputeGameFinalityDelaySeconds( + &self, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameFinalityDelaySecondsCall, N> { + self.call_builder(&disputeGameFinalityDelaySecondsCall) + } + ///Creates a new call builder for the [`getAnchorRoot`] function. + pub fn getAnchorRoot( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getAnchorRootCall, N> { + self.call_builder(&getAnchorRootCall) + } + ///Creates a new call builder for the [`initVersion`] function. + pub fn initVersion( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initVersionCall, N> { + self.call_builder(&initVersionCall) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + _systemConfig: alloy::sol_types::private::Address, + _disputeGameFactory: alloy::sol_types::private::Address, + _startingAnchorRoot: ::RustType, + _startingRespectedGameType: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder( + &initializeCall { + _systemConfig, + _disputeGameFactory, + _startingAnchorRoot, + _startingRespectedGameType, + }, + ) + } + ///Creates a new call builder for the [`isGameBlacklisted`] function. + pub fn isGameBlacklisted( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameBlacklistedCall, N> { + self.call_builder(&isGameBlacklistedCall { _game }) + } + ///Creates a new call builder for the [`isGameClaimValid`] function. + pub fn isGameClaimValid( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameClaimValidCall, N> { + self.call_builder(&isGameClaimValidCall { _game }) + } + ///Creates a new call builder for the [`isGameFinalized`] function. + pub fn isGameFinalized( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameFinalizedCall, N> { + self.call_builder(&isGameFinalizedCall { _game }) + } + ///Creates a new call builder for the [`isGameProper`] function. + pub fn isGameProper( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameProperCall, N> { + self.call_builder(&isGameProperCall { _game }) + } + ///Creates a new call builder for the [`isGameRegistered`] function. + pub fn isGameRegistered( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameRegisteredCall, N> { + self.call_builder(&isGameRegisteredCall { _game }) + } + ///Creates a new call builder for the [`isGameResolved`] function. + pub fn isGameResolved( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameResolvedCall, N> { + self.call_builder(&isGameResolvedCall { _game }) + } + ///Creates a new call builder for the [`isGameRespected`] function. + pub fn isGameRespected( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameRespectedCall, N> { + self.call_builder(&isGameRespectedCall { _game }) + } + ///Creates a new call builder for the [`isGameRetired`] function. + pub fn isGameRetired( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameRetiredCall, N> { + self.call_builder(&isGameRetiredCall { _game }) + } + ///Creates a new call builder for the [`paused`] function. + pub fn paused(&self) -> alloy_contract::SolCallBuilder<&P, pausedCall, N> { + self.call_builder(&pausedCall) + } + ///Creates a new call builder for the [`proxyAdmin`] function. + pub fn proxyAdmin( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminCall, N> { + self.call_builder(&proxyAdminCall) + } + ///Creates a new call builder for the [`proxyAdminOwner`] function. + pub fn proxyAdminOwner( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminOwnerCall, N> { + self.call_builder(&proxyAdminOwnerCall) + } + ///Creates a new call builder for the [`respectedGameType`] function. + pub fn respectedGameType( + &self, + ) -> alloy_contract::SolCallBuilder<&P, respectedGameTypeCall, N> { + self.call_builder(&respectedGameTypeCall) + } + ///Creates a new call builder for the [`retirementTimestamp`] function. + pub fn retirementTimestamp( + &self, + ) -> alloy_contract::SolCallBuilder<&P, retirementTimestampCall, N> { + self.call_builder(&retirementTimestampCall) + } + ///Creates a new call builder for the [`setAnchorState`] function. + pub fn setAnchorState( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, setAnchorStateCall, N> { + self.call_builder(&setAnchorStateCall { _game }) + } + ///Creates a new call builder for the [`setRespectedGameType`] function. + pub fn setRespectedGameType( + &self, + _gameType: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, setRespectedGameTypeCall, N> { + self.call_builder( + &setRespectedGameTypeCall { + _gameType, + }, + ) + } + ///Creates a new call builder for the [`superchainConfig`] function. + pub fn superchainConfig( + &self, + ) -> alloy_contract::SolCallBuilder<&P, superchainConfigCall, N> { + self.call_builder(&superchainConfigCall) + } + ///Creates a new call builder for the [`systemConfig`] function. + pub fn systemConfig( + &self, + ) -> alloy_contract::SolCallBuilder<&P, systemConfigCall, N> { + self.call_builder(&systemConfigCall) + } + ///Creates a new call builder for the [`updateRetirementTimestamp`] function. + pub fn updateRetirementTimestamp( + &self, + ) -> alloy_contract::SolCallBuilder<&P, updateRetirementTimestampCall, N> { + self.call_builder(&updateRetirementTimestampCall) + } + ///Creates a new call builder for the [`version`] function. + pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> { + self.call_builder(&versionCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AnchorStateRegistryInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`AnchorUpdated`] event. + pub fn AnchorUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, AnchorUpdated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`DisputeGameBlacklisted`] event. + pub fn DisputeGameBlacklisted_filter( + &self, + ) -> alloy_contract::Event<&P, DisputeGameBlacklisted, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Initialized`] event. + pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`RespectedGameTypeSet`] event. + pub fn RespectedGameTypeSet_filter( + &self, + ) -> alloy_contract::Event<&P, RespectedGameTypeSet, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`RetirementTimestampSet`] event. + pub fn RetirementTimestampSet_filter( + &self, + ) -> alloy_contract::Event<&P, RetirementTimestampSet, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/dispute_game_factory.rs b/bindings/src/codegen/dispute_game_factory.rs new file mode 100644 index 000000000..b0334b03b --- /dev/null +++ b/bindings/src/codegen/dispute_game_factory.rs @@ -0,0 +1,8224 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DisputeGameFactory { + type Claim is bytes32; + type GameId is bytes32; + type GameType is uint32; + type Hash is bytes32; + type Timestamp is uint64; + struct GameSearchResult { + uint256 index; + GameId metadata; + Timestamp timestamp; + Claim rootClaim; + bytes extraData; + } + + error GameAlreadyExists(Hash uuid); + error IncorrectBondAmount(); + error NoImplementation(GameType gameType); + error ProxyAdminOwnedBase_NotProxyAdmin(); + error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); + error ProxyAdminOwnedBase_NotProxyAdminOwner(); + error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); + error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); + error ProxyAdminOwnedBase_ProxyAdminNotFound(); + error ReinitializableBase_ZeroInitVersion(); + + event DisputeGameCreated(address indexed disputeProxy, GameType indexed gameType, Claim indexed rootClaim); + event ImplementationArgsSet(GameType indexed gameType, bytes args); + event ImplementationSet(address indexed impl, GameType indexed gameType); + event InitBondUpdated(GameType indexed gameType, uint256 indexed newBond); + event Initialized(uint8 version); + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + constructor(); + + function create(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external payable returns (address proxy_); + function findLatestGames(GameType _gameType, uint256 _start, uint256 _n) external view returns (GameSearchResult[] memory games_); + function gameArgs(GameType) external view returns (bytes memory); + function gameAtIndex(uint256 _index) external view returns (GameType gameType_, Timestamp timestamp_, address proxy_); + function gameCount() external view returns (uint256 gameCount_); + function gameImpls(GameType) external view returns (address); + function games(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external view returns (address proxy_, Timestamp timestamp_); + function getGameUUID(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external pure returns (Hash uuid_); + function initBonds(GameType) external view returns (uint256); + function initVersion() external view returns (uint8); + function initialize(address _owner) external; + function owner() external view returns (address); + function proxyAdmin() external view returns (address); + function proxyAdminOwner() external view returns (address); + function renounceOwnership() external; + function setImplementation(GameType _gameType, address _impl) external; + function setImplementation(GameType _gameType, address _impl, bytes memory _args) external; + function setInitBond(GameType _gameType, uint256 _initBond) external; + function transferOwnership(address newOwner) external; + function version() external view returns (string memory); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "create", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_rootClaim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_extraData", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "proxy_", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "findLatestGames", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_start", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_n", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "games_", + "type": "tuple[]", + "internalType": "struct DisputeGameFactory.GameSearchResult[]", + "components": [ + { + "name": "index", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "metadata", + "type": "bytes32", + "internalType": "GameId" + }, + { + "name": "timestamp", + "type": "uint64", + "internalType": "Timestamp" + }, + { + "name": "rootClaim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "extraData", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameArgs", + "inputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [ + { + "name": "", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameAtIndex", + "inputs": [ + { + "name": "_index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "timestamp_", + "type": "uint64", + "internalType": "Timestamp" + }, + { + "name": "proxy_", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameCount", + "inputs": [], + "outputs": [ + { + "name": "gameCount_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameImpls", + "inputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "games", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_rootClaim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_extraData", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "proxy_", + "type": "address", + "internalType": "contract IDisputeGame" + }, + { + "name": "timestamp_", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getGameUUID", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_rootClaim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_extraData", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "uuid_", + "type": "bytes32", + "internalType": "Hash" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "initBonds", + "inputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initVersion", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [ + { + "name": "_owner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdmin", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IProxyAdmin" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdminOwner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setImplementation", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_impl", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setImplementation", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_impl", + "type": "address", + "internalType": "contract IDisputeGame" + }, + { + "name": "_args", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setInitBond", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_initBond", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "DisputeGameCreated", + "inputs": [ + { + "name": "disputeProxy", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "gameType", + "type": "uint32", + "indexed": true, + "internalType": "GameType" + }, + { + "name": "rootClaim", + "type": "bytes32", + "indexed": true, + "internalType": "Claim" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ImplementationArgsSet", + "inputs": [ + { + "name": "gameType", + "type": "uint32", + "indexed": true, + "internalType": "GameType" + }, + { + "name": "args", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ImplementationSet", + "inputs": [ + { + "name": "impl", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "gameType", + "type": "uint32", + "indexed": true, + "internalType": "GameType" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "InitBondUpdated", + "inputs": [ + { + "name": "gameType", + "type": "uint32", + "indexed": true, + "internalType": "GameType" + }, + { + "name": "newBond", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Initialized", + "inputs": [ + { + "name": "version", + "type": "uint8", + "indexed": false, + "internalType": "uint8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "GameAlreadyExists", + "inputs": [ + { + "name": "uuid", + "type": "bytes32", + "internalType": "Hash" + } + ] + }, + { + "type": "error", + "name": "IncorrectBondAmount", + "inputs": [] + }, + { + "type": "error", + "name": "NoImplementation", + "inputs": [ + { + "name": "gameType", + "type": "uint32", + "internalType": "GameType" + } + ] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdmin", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotResolvedDelegateProxy", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotSharedProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_ProxyAdminNotFound", + "inputs": [] + }, + { + "type": "error", + "name": "ReinitializableBase_ZeroInitVersion", + "inputs": [] + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod DisputeGameFactory { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\xA0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`\x01`\0\x81`\xFF\x16\x03b\0\0RW`@Q\x7F\x9B\x01\xAF\xED\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80`\xFF\x16`\x80\x81`\xFF\x16\x81RPPPb\0\0qb\0\0w` \x1B` \x1CV[b\0\x02\"V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15b\0\0\xCAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01b\0\0\xC1\x90b\0\x01\xC5V[`@Q\x80\x91\x03\x90\xFD[`\xFF\x80\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10\x15b\0\x01V[\x91Pb\0\x01\xBA\x82b\0\x01OV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Rb\0\x01\xE0\x81b\0\x01\x9EV[\x90P\x91\x90PV[`\0`\xFF\x82\x16\x90P\x91\x90PV[b\0\x01\xFF\x81b\0\x01\xE7V[\x82RPPV[`\0` \x82\x01\x90Pb\0\x02\x1C`\0\x83\x01\x84b\0\x01\xF4V[\x92\x91PPV[`\x80Qa+Rb\0\x02>`\09`\0a\x08c\x01Ra+R`\0\xF3\xFE`\x80`@R`\x046\x10a\x01\x1FW`\x005`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xA0W\x80c\xB1\x07\tW\x11a\0dW\x80c\xB1\x07\tW\x14a\x04\x03W\x80c\xBB\x8A\xA1\xFC\x14a\x04,W\x80c\xC4\xD6m\xE8\x14a\x04kW\x80c\xDA\xD5D\xE0\x14a\x04\x94W\x80c\xF2\xFD\xE3\x8B\x14a\x04\xBFWa\x01\x1FV[\x80cqP\x18\xA6\x14a\x03\x17W\x80ct\xCC\x86\xAC\x14a\x03.W\x80c\x82\xEC\xF2\xF6\x14a\x03kW\x80c\x8D\xA5\xCB[\x14a\x03\x9BW\x80c\x96\xCD\x97 \x14a\x03\xC6Wa\x01\x1FV[\x80c>G\x15\x8C\x11a\0\xE7W\x80c>G\x15\x8C\x14a\x02\x1BW\x80cM\x19u\xB4\x14a\x02FW\x80cT\xFDMP\x14a\x02qW\x80c_\x01P\xCB\x14a\x02\x9CW\x80ce\x93\xDCn\x14a\x02\xDAWa\x01\x1FV[\x80c\x14\xF6\xB1\xA3\x14a\x01$W\x80c\x1Bh[\x9E\x14a\x01MW\x80c\x1E3B@\x14a\x01\x8AW\x80c%K\xD6\x83\x14a\x01\xB3W\x80c8\xD3\x8C\x97\x14a\x01\xF0W[`\0\x80\xFD[4\x80\x15a\x010W`\0\x80\xFD[Pa\x01K`\x04\x806\x03\x81\x01\x90a\x01F\x91\x90a\x18 V[a\x04\xE8V[\0[4\x80\x15a\x01YW`\0\x80\xFD[Pa\x01t`\x04\x806\x03\x81\x01\x90a\x01o\x91\x90a\x18`V[a\x05\x9CV[`@Qa\x01\x81\x91\x90a\x18\xECV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x96W`\0\x80\xFD[Pa\x01\xB1`\x04\x806\x03\x81\x01\x90a\x01\xAC\x91\x90a\x19=V[a\x05\xCFV[\0[4\x80\x15a\x01\xBFW`\0\x80\xFD[Pa\x01\xDA`\x04\x806\x03\x81\x01\x90a\x01\xD5\x91\x90a\x19}V[a\x063V[`@Qa\x01\xE7\x91\x90a\x1C/V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xFCW`\0\x80\xFD[Pa\x02\x05a\x08_V[`@Qa\x02\x12\x91\x90a\x1CmV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02'W`\0\x80\xFD[Pa\x020a\x08\x87V[`@Qa\x02=\x91\x90a\x1C\xA9V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02RW`\0\x80\xFD[Pa\x02[a\n\xE0V[`@Qa\x02h\x91\x90a\x1C\xD3V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02}W`\0\x80\xFD[Pa\x02\x86a\n\xEDV[`@Qa\x02\x93\x91\x90a\x1DCV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xA8W`\0\x80\xFD[Pa\x02\xC3`\x04\x806\x03\x81\x01\x90a\x02\xBE\x91\x90a\x1D\xF6V[a\x0B&V[`@Qa\x02\xD1\x92\x91\x90a\x1EyV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xE6W`\0\x80\xFD[Pa\x03\x01`\x04\x806\x03\x81\x01\x90a\x02\xFC\x91\x90a\x18`V[a\x0BsV[`@Qa\x03\x0E\x91\x90a\x1C\xD3V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03#W`\0\x80\xFD[Pa\x03,a\x0B\x8BV[\0[4\x80\x15a\x03:W`\0\x80\xFD[Pa\x03U`\x04\x806\x03\x81\x01\x90a\x03P\x91\x90a\x18`V[a\x0B\x9FV[`@Qa\x03b\x91\x90a\x1E\xECV[`@Q\x80\x91\x03\x90\xF3[a\x03\x85`\x04\x806\x03\x81\x01\x90a\x03\x80\x91\x90a\x1D\xF6V[a\x0C?V[`@Qa\x03\x92\x91\x90a\x18\xECV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xA7W`\0\x80\xFD[Pa\x03\xB0a\x0FCV[`@Qa\x03\xBD\x91\x90a\x1F\x1DV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xD2W`\0\x80\xFD[Pa\x03\xED`\x04\x806\x03\x81\x01\x90a\x03\xE8\x91\x90a\x1D\xF6V[a\x0FmV[`@Qa\x03\xFA\x91\x90a\x1FGV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x0FW`\0\x80\xFD[Pa\x04*`\x04\x806\x03\x81\x01\x90a\x04%\x91\x90a\x1FbV[a\x0F\xA6V[\0[4\x80\x15a\x048W`\0\x80\xFD[Pa\x04S`\x04\x806\x03\x81\x01\x90a\x04N\x91\x90a\x1F\xD6V[a\x10\xCBV[`@Qa\x04b\x93\x92\x91\x90a 4V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04wW`\0\x80\xFD[Pa\x04\x92`\x04\x806\x03\x81\x01\x90a\x04\x8D\x91\x90a \x97V[a\x11\x1AV[\0[4\x80\x15a\x04\xA0W`\0\x80\xFD[Pa\x04\xA9a\x123V[`@Qa\x04\xB6\x91\x90a\x1F\x1DV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xCBW`\0\x80\xFD[Pa\x04\xE6`\x04\x806\x03\x81\x01\x90a\x04\xE1\x91\x90a \x97V[a\x12\xB0V[\0[a\x04\xF0a\x133V[\x80`e`\0\x84c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81c\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFFQ=\x80\xE2\xC7\xFAHv\x08\xF7\na\x8D\xFB\xC0\xCFAV\x99\xDCiX\x8Ct~\x8CqVl\x88\xDE`@Q`@Q\x80\x91\x03\x90\xA3PPV[`e` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[a\x05\xD7a\x133V[\x80`f`\0\x84c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x80\x82c\xFF\xFF\xFF\xFF\x16\x7Ft\xD6f\\K&\xD5YjZ\xA1=0\x14\xE0\xC0j\xF4\xD3\"\x07Zy\x7F\x87\xB0<\xD4\xC5\xBC\x91\xCA`@Q`@Q\x80\x91\x03\x90\xA3PPV[```h\x80T\x90P\x83\x10\x15\x80a\x06IWP`\0\x82\x14[a\x08XW`@Q\x90P\x81`\x05\x1B` \x01\x81\x01`@R`\0\x83\x90P[`\0\x81\x10\x15\x80\x15a\x06uWP\x83\x81\x11\x15[\x15a\x08VW`\0`h\x82\x81T\x81\x10a\x06\x90Wa\x06\x8Fa \xC4V[[\x90`\0R` `\0 \x01T\x90P`\0\x80`\0a\x06\xAB\x84a\x13\xB1V[\x92P\x92P\x92Pa\x06\xC0\x89c\xFF\xFF\xFF\xFF\x16a\x13\xECV[c\xFF\xFF\xFF\xFF\x16a\x06\xD5\x84c\xFF\xFF\xFF\xFF\x16a\x13\xECV[c\xFF\xFF\xFF\xFF\x16\x03a\x08DW`\x01\x86Q\x01\x86R`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c`\x9D34`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x074W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07]\x91\x90a\"\x14V[\x90P`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBC\xEF;U`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xACW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xD0\x91\x90a\"rV[\x90P`@Q\x80`\xA0\x01`@R\x80\x88\x81R` \x01\x87\x81R` \x01\x85g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x83\x81RP\x88`\x01\x8AQa\x08\x12\x91\x90a\"\xCEV[\x81Q\x81\x10a\x08#Wa\x08\"a \xC4V[[` \x02` \x01\x01\x81\x90RP\x88\x88Q\x10a\x08AWPPPPPPa\x08VV[PP[\x84\x80`\x01\x90\x03\x95PPPPPPa\x06dV[P[\x93\x92PPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80a\x08\xB6\x7F\xB51'hJV\x8B1s\xAE\x13\xB9\xF8\xA6\x01n$>c\xB6\xE8\xEE\x11x\xD6\xA7\x17\x85\x0B]a\x03`\0\x1Ba\x13\xF6V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x08\xF5W\x80\x91PPa\n\xDDV[`\x02`@Q\x80`@\x01`@R\x80`\x1A\x81R` \x01\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0\x81RPQa\t8\x91\x90a#\x02V[\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0`\0\x1C\x17`\0\x1Ba\t\x920`\0`@Q` \x01a\tw\x92\x91\x90a#\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x14\x01V[\x14a\t\xC9W`@Q\x7FT\xE43\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\t\xFD0`\x01`@Q` \x01a\t\xE2\x92\x91\x90a#\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x13\xF6V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\n\xABW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n~W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xA2\x91\x90a#\x9AV[\x92PPPa\n\xDDV[`@Q\x7F3!D\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x90V[`\0`h\x80T\x90P\x90P\x90V[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F1.3.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\0\x80`\0a\x0B7\x87\x87\x87\x87a\x0FmV[\x90P`\0\x80a\x0BX`g`\0\x85\x81R` \x01\x90\x81R` \x01`\0 Ta\x13\xB1V[\x92P\x92PP\x80\x82\x80\x95P\x81\x96PPPPPP\x94P\x94\x92PPPV[`f` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[a\x0B\x93a\x133V[a\x0B\x9D`\0a\x14\x0CV[V[`i` R\x80`\0R`@`\0 `\0\x91P\x90P\x80Ta\x0B\xBE\x90a#\xF6V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xEA\x90a#\xF6V[\x80\x15a\x0C7W\x80`\x1F\x10a\x0C\x0CWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C7V[\x82\x01\x91\x90`\0R` `\0 \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\x1AW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81V[`\0\x80`e`\0\x87c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x0C\xF5W\x85`@Q\x7F\x03\x1Cm\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x0C\xEC\x91\x90a$'V[`@Q\x80\x91\x03\x90\xFD[`f`\0\x87c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T4\x14a\rMW`@Q\x7F\x86 \xAA\x19\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`\x01Ca\r\\\x91\x90a\"\xCEV[@\x90Pa\r\xCF3\x87\x83\x88\x88`i`\0\x8Ec\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `@Q` \x01a\r\x9B\x96\x95\x94\x93\x92\x91\x90a%\x99V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x14\xD2\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x92P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x81)\xFC\x1C4`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x0E\x19W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x0E-W=`\0\x80>=`\0\xFD[PPPPP`\0a\x0E@\x88\x88\x88\x88a\x0FmV[\x90P`\0\x80\x1B`g`\0\x83\x81R` \x01\x90\x81R` \x01`\0 T\x14a\x0E\x9CW\x80`@Q\x7F\x01Oo\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x0E\x93\x91\x90a\x1FGV[`@Q\x80\x91\x03\x90\xFD[`\0a\x0E\xA9\x89B\x87a\x14\xE8V[\x90P\x80`g`\0\x84\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP`h\x81\x90\x80`\x01\x81T\x01\x80\x82U\x80\x91PP`\x01\x90\x03\x90`\0R` `\0 \x01`\0\x90\x91\x90\x91\x90\x91PU\x87\x89c\xFF\xFF\xFF\xFF\x16\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F[V^\xFE\x82A\x1D\xA9\x88\x14\xF3V\xD0\xE7\xBC\xB8\xF0!\x9B\x8D\x97\x03\x07\xC5\xAF\xB4\xA6\x90:\x8B.5`@Q`@Q\x80\x91\x03\x90\xA4PPPP\x94\x93PPPPV[`\0`3`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x90V[`\0\x84\x84\x84\x84`@Q` \x01a\x0F\x86\x94\x93\x92\x91\x90a&.V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x94\x93PPPPV[a\x0F\xAEa\x133V[\x82`e`\0\x86c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81\x81`i`\0\x87c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x91\x82a\x10:\x92\x91\x90a(\x06V[P\x83c\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFFQ=\x80\xE2\xC7\xFAHv\x08\xF7\na\x8D\xFB\xC0\xCFAV\x99\xDCiX\x8Ct~\x8CqVl\x88\xDE`@Q`@Q\x80\x91\x03\x90\xA3\x83c\xFF\xFF\xFF\xFF\x16\x7F\xA4\x7F\xCD\xF0u\xD6\x80\xD3\x81{\xFC\xA7\x97;7>\x1A_l\xFC;DGH)\x9C\xC2\xB8=\x83H\xF9\x83\x83`@Qa\x10\xBD\x92\x91\x90a(\xD6V[`@Q\x80\x91\x03\x90\xA2PPPPV[`\0\x80`\0\x80`\0\x80a\x10\xFB`h\x88\x81T\x81\x10a\x10\xEBWa\x10\xEAa \xC4V[[\x90`\0R` `\0 \x01Ta\x13\xB1V[\x92P\x92P\x92P\x82\x82\x82\x80\x96P\x81\x97P\x82\x98PPPPPPP\x91\x93\x90\x92PV[a\x11\"a\x08_V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15\x80\x15a\x11QWP\x80`\xFF\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10[a\x11\x90W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x11\x87\x90a)lV[`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP`\x01`\0`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPa\x11\xCDa\x14\xFEV[a\x11\xD5a\x15\xADV[a\x11\xDE\x82a\x14\x0CV[`\0\x80`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x81`@Qa\x12'\x91\x90a\x1CmV[`@Q\x80\x91\x03\x90\xA1PPV[`\0a\x12=a\x08\x87V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12\x87W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xAB\x91\x90a#\x9AV[\x90P\x90V[a\x12\xB8a\x133V[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x13'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x13\x1E\x90a)\xFEV[`@Q\x80\x91\x03\x90\xFD[a\x130\x81a\x14\x0CV[PV[a\x13;a\x16\x06V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x13Ya\x0FCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x13\xAFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x13\xA6\x90a*jV[`@Q\x80\x91\x03\x90\xFD[V[`\0\x80`\0\x83`\xE0\x1C\x92Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84`\xA0\x1C\x16\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90P\x91\x93\x90\x92PV[`\0\x81\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[`\0`3`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81`3`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0`@Q`@Q\x80\x91\x03\x90\xA3PPV[`\0a\x14\xE0`\0\x84\x84a\x16\x0EV[\x90P\x92\x91PPV[`\0\x81\x83`\xA0\x1B\x85`\xE0\x1B\x17\x17\x90P\x93\x92PPPV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x15\x1Da\x08\x87V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x15tWP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x15[a\x123V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x15a\x15\xABW`@Q\x7F\xC4\x05\n&\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\x15\xFCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x15\xF3\x90a*\xFCV[`@Q\x80\x91\x03\x90\xFD[a\x16\x04a\x16\xFFV[V[`\x003\x90P\x90V[`\0``\x82\x03Q`@\x83\x03Q` \x84\x03Q\x84Q\x80` \x87\x01\x01\x80Q`\x02\x83\x01lZ\xF4==\x93\x80>``W\xFD[\xF3\x89R\x89`\r\x8A\x03RxY=\xA1\0[6==7====a\0\0\x80`b696\x01=s\x81`H\x1B\x17`!\x8A\x03R\x7F\x9EJ\xC3O!\xC6\x19\xCE\xFC\x92l\x8B\xD9;T\xBFZ9\xC7\xAB!'\xA8\x95\xAF\x1C\xC0i\x1D~=\xFF`:\x8A\x03Rr\xFDa\0\0=\x81`\n=9\xF36`,W4=R\x7F`b\x82\x01`x\x1B\x17a\xFF\x9E\x82\x10`Y\x01\x8A\x03R\x80`\xF0\x1B\x83R`l\x81\x01`L\x8A\x03\x8C\xF0\x97P\x87a\x16\xD9Wc0\x11d%`\0R`\x04`\x1C\xFD[\x81\x83R\x83\x89R\x84` \x8A\x03R\x85`@\x8A\x03R\x86``\x8A\x03RPPPPPPP\x93\x92PPPV[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\x17NW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x17E\x90a*\xFCV[`@Q\x80\x91\x03\x90\xFD[a\x17^a\x17Ya\x16\x06V[a\x14\x0CV[V[`\0`@Q\x90P\x90V[`\0\x80\xFD[`\0\x80\xFD[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a\x17\x8D\x81a\x17tV[\x81\x14a\x17\x98W`\0\x80\xFD[PV[`\0\x815\x90Pa\x17\xAA\x81a\x17\x84V[\x92\x91PPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x17\xDB\x82a\x17\xB0V[\x90P\x91\x90PV[`\0a\x17\xED\x82a\x17\xD0V[\x90P\x91\x90PV[a\x17\xFD\x81a\x17\xE2V[\x81\x14a\x18\x08W`\0\x80\xFD[PV[`\0\x815\x90Pa\x18\x1A\x81a\x17\xF4V[\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15a\x187Wa\x186a\x17jV[[`\0a\x18E\x85\x82\x86\x01a\x17\x9BV[\x92PP` a\x18V\x85\x82\x86\x01a\x18\x0BV[\x91PP\x92P\x92\x90PV[`\0` \x82\x84\x03\x12\x15a\x18vWa\x18ua\x17jV[[`\0a\x18\x84\x84\x82\x85\x01a\x17\x9BV[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[`\0a\x18\xB2a\x18\xADa\x18\xA8\x84a\x17\xB0V[a\x18\x8DV[a\x17\xB0V[\x90P\x91\x90PV[`\0a\x18\xC4\x82a\x18\x97V[\x90P\x91\x90PV[`\0a\x18\xD6\x82a\x18\xB9V[\x90P\x91\x90PV[a\x18\xE6\x81a\x18\xCBV[\x82RPPV[`\0` \x82\x01\x90Pa\x19\x01`\0\x83\x01\x84a\x18\xDDV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\x19\x1A\x81a\x19\x07V[\x81\x14a\x19%W`\0\x80\xFD[PV[`\0\x815\x90Pa\x197\x81a\x19\x11V[\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15a\x19TWa\x19Sa\x17jV[[`\0a\x19b\x85\x82\x86\x01a\x17\x9BV[\x92PP` a\x19s\x85\x82\x86\x01a\x19(V[\x91PP\x92P\x92\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15a\x19\x96Wa\x19\x95a\x17jV[[`\0a\x19\xA4\x86\x82\x87\x01a\x17\x9BV[\x93PP` a\x19\xB5\x86\x82\x87\x01a\x19(V[\x92PP`@a\x19\xC6\x86\x82\x87\x01a\x19(V[\x91PP\x92P\x92P\x92V[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0\x81\x90P` \x82\x01\x90P\x91\x90PV[a\x1A\x05\x81a\x19\x07V[\x82RPPV[`\0\x81\x90P\x91\x90PV[`\0a\x1A \x82a\x1A\x0BV[\x90P\x91\x90PV[a\x1A0\x81a\x1A\x15V[\x82RPPV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x1Aea\x1A`a\x1A[\x84a\x1A6V[a\x18\x8DV[a\x1A6V[\x90P\x91\x90PV[a\x1Au\x81a\x1AJV[\x82RPPV[a\x1A\x84\x81a\x1A\x15V[\x82RPPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x1A\xC4W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x1A\xA9V[\x83\x81\x11\x15a\x1A\xD3W`\0\x84\x84\x01R[PPPPV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x1A\xF5\x82a\x1A\x8AV[a\x1A\xFF\x81\x85a\x1A\x95V[\x93Pa\x1B\x0F\x81\x85` \x86\x01a\x1A\xA6V[a\x1B\x18\x81a\x1A\xD9V[\x84\x01\x91PP\x92\x91PPV[`\0`\xA0\x83\x01`\0\x83\x01Qa\x1B;`\0\x86\x01\x82a\x19\xFCV[P` \x83\x01Qa\x1BN` \x86\x01\x82a\x1A'V[P`@\x83\x01Qa\x1Ba`@\x86\x01\x82a\x1AlV[P``\x83\x01Qa\x1Bt``\x86\x01\x82a\x1A{V[P`\x80\x83\x01Q\x84\x82\x03`\x80\x86\x01Ra\x1B\x8C\x82\x82a\x1A\xEAV[\x91PP\x80\x91PP\x92\x91PPV[`\0a\x1B\xA5\x83\x83a\x1B#V[\x90P\x92\x91PPV[`\0` \x82\x01\x90P\x91\x90PV[`\0a\x1B\xC5\x82a\x19\xD0V[a\x1B\xCF\x81\x85a\x19\xDBV[\x93P\x83` \x82\x02\x85\x01a\x1B\xE1\x85a\x19\xECV[\x80`\0[\x85\x81\x10\x15a\x1C\x1DW\x84\x84\x03\x89R\x81Qa\x1B\xFE\x85\x82a\x1B\x99V[\x94Pa\x1C\t\x83a\x1B\xADV[\x92P` \x8A\x01\x99PP`\x01\x81\x01\x90Pa\x1B\xE5V[P\x82\x97P\x87\x95PPPPPP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x1CI\x81\x84a\x1B\xBAV[\x90P\x92\x91PPV[`\0`\xFF\x82\x16\x90P\x91\x90PV[a\x1Cg\x81a\x1CQV[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\x82`\0\x83\x01\x84a\x1C^V[\x92\x91PPV[`\0a\x1C\x93\x82a\x18\xB9V[\x90P\x91\x90PV[a\x1C\xA3\x81a\x1C\x88V[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\xBE`\0\x83\x01\x84a\x1C\x9AV[\x92\x91PPV[a\x1C\xCD\x81a\x19\x07V[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\xE8`\0\x83\x01\x84a\x1C\xC4V[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0a\x1D\x15\x82a\x1C\xEEV[a\x1D\x1F\x81\x85a\x1C\xF9V[\x93Pa\x1D/\x81\x85` \x86\x01a\x1A\xA6V[a\x1D8\x81a\x1A\xD9V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x1D]\x81\x84a\x1D\nV[\x90P\x92\x91PPV[a\x1Dn\x81a\x1A\x0BV[\x81\x14a\x1DyW`\0\x80\xFD[PV[`\0\x815\x90Pa\x1D\x8B\x81a\x1DeV[\x92\x91PPV[`\0\x80\xFD[`\0\x80\xFD[`\0\x80\xFD[`\0\x80\x83`\x1F\x84\x01\x12a\x1D\xB6Wa\x1D\xB5a\x1D\x91V[[\x825\x90Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD3Wa\x1D\xD2a\x1D\x96V[[` \x83\x01\x91P\x83`\x01\x82\x02\x83\x01\x11\x15a\x1D\xEFWa\x1D\xEEa\x1D\x9BV[[\x92P\x92\x90PV[`\0\x80`\0\x80``\x85\x87\x03\x12\x15a\x1E\x10Wa\x1E\x0Fa\x17jV[[`\0a\x1E\x1E\x87\x82\x88\x01a\x17\x9BV[\x94PP` a\x1E/\x87\x82\x88\x01a\x1D|V[\x93PP`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1EPWa\x1EOa\x17oV[[a\x1E\\\x87\x82\x88\x01a\x1D\xA0V[\x92P\x92PP\x92\x95\x91\x94P\x92PV[a\x1Es\x81a\x1AJV[\x82RPPV[`\0`@\x82\x01\x90Pa\x1E\x8E`\0\x83\x01\x85a\x18\xDDV[a\x1E\x9B` \x83\x01\x84a\x1EjV[\x93\x92PPPV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0a\x1E\xBE\x82a\x1A\x8AV[a\x1E\xC8\x81\x85a\x1E\xA2V[\x93Pa\x1E\xD8\x81\x85` \x86\x01a\x1A\xA6V[a\x1E\xE1\x81a\x1A\xD9V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x1F\x06\x81\x84a\x1E\xB3V[\x90P\x92\x91PPV[a\x1F\x17\x81a\x17\xD0V[\x82RPPV[`\0` \x82\x01\x90Pa\x1F2`\0\x83\x01\x84a\x1F\x0EV[\x92\x91PPV[a\x1FA\x81a\x1A\x15V[\x82RPPV[`\0` \x82\x01\x90Pa\x1F\\`\0\x83\x01\x84a\x1F8V[\x92\x91PPV[`\0\x80`\0\x80``\x85\x87\x03\x12\x15a\x1F|Wa\x1F{a\x17jV[[`\0a\x1F\x8A\x87\x82\x88\x01a\x17\x9BV[\x94PP` a\x1F\x9B\x87\x82\x88\x01a\x18\x0BV[\x93PP`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xBCWa\x1F\xBBa\x17oV[[a\x1F\xC8\x87\x82\x88\x01a\x1D\xA0V[\x92P\x92PP\x92\x95\x91\x94P\x92PV[`\0` \x82\x84\x03\x12\x15a\x1F\xECWa\x1F\xEBa\x17jV[[`\0a\x1F\xFA\x84\x82\x85\x01a\x19(V[\x91PP\x92\x91PPV[`\0a \x1Ea \x19a \x14\x84a\x17tV[a\x18\x8DV[a\x17tV[\x90P\x91\x90PV[a .\x81a \x03V[\x82RPPV[`\0``\x82\x01\x90Pa I`\0\x83\x01\x86a %V[a V` \x83\x01\x85a\x1EjV[a c`@\x83\x01\x84a\x18\xDDV[\x94\x93PPPPV[a t\x81a\x17\xD0V[\x81\x14a \x7FW`\0\x80\xFD[PV[`\0\x815\x90Pa \x91\x81a kV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a \xADWa \xACa\x17jV[[`\0a \xBB\x84\x82\x85\x01a \x82V[\x91PP\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`2`\x04R`$`\0\xFD[`\0\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`A`\x04R`$`\0\xFD[a!0\x82a\x1A\xD9V[\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a!OWa!Na \xF8V[[\x80`@RPPPV[`\0a!ba\x17`V[\x90Pa!n\x82\x82a!'V[\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a!\x8EWa!\x8Da \xF8V[[a!\x97\x82a\x1A\xD9V[\x90P` \x81\x01\x90P\x91\x90PV[`\0a!\xB7a!\xB2\x84a!sV[a!XV[\x90P\x82\x81R` \x81\x01\x84\x84\x84\x01\x11\x15a!\xD3Wa!\xD2a \xF3V[[a!\xDE\x84\x82\x85a\x1A\xA6V[P\x93\x92PPPV[`\0\x82`\x1F\x83\x01\x12a!\xFBWa!\xFAa\x1D\x91V[[\x81Qa\"\x0B\x84\x82` \x86\x01a!\xA4V[\x91PP\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\"*Wa\")a\x17jV[[`\0\x82\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\"HWa\"Ga\x17oV[[a\"T\x84\x82\x85\x01a!\xE6V[\x91PP\x92\x91PPV[`\0\x81Q\x90Pa\"l\x81a\x1DeV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\"\x88Wa\"\x87a\x17jV[[`\0a\"\x96\x84\x82\x85\x01a\"]V[\x91PP\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x11`\x04R`$`\0\xFD[`\0a\"\xD9\x82a\x19\x07V[\x91Pa\"\xE4\x83a\x19\x07V[\x92P\x82\x82\x10\x15a\"\xF7Wa\"\xF6a\"\x9FV[[\x82\x82\x03\x90P\x92\x91PPV[`\0a#\r\x82a\x19\x07V[\x91Pa#\x18\x83a\x19\x07V[\x92P\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x04\x83\x11\x82\x15\x15\x16\x15a#QWa#Pa\"\x9FV[[\x82\x82\x02\x90P\x92\x91PPV[`\0`@\x82\x01\x90Pa#q`\0\x83\x01\x85a\x1F\x0EV[a#~` \x83\x01\x84a\x1C\xC4V[\x93\x92PPPV[`\0\x81Q\x90Pa#\x94\x81a kV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a#\xB0Wa#\xAFa\x17jV[[`\0a#\xBE\x84\x82\x85\x01a#\x85V[\x91PP\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\"`\x04R`$`\0\xFD[`\0`\x02\x82\x04\x90P`\x01\x82\x16\x80a$\x0EW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a$!Wa$ a#\xC7V[[P\x91\x90PV[`\0` \x82\x01\x90Pa$<`\0\x83\x01\x84a %V[\x92\x91PPV[`\0\x81``\x1B\x90P\x91\x90PV[`\0a$Z\x82a$BV[\x90P\x91\x90PV[`\0a$l\x82a$OV[\x90P\x91\x90PV[a$\x84a$\x7F\x82a\x17\xD0V[a$aV[\x82RPPV[`\0\x81\x90P\x91\x90PV[a$\xA5a$\xA0\x82a\x1A\x15V[a$\x8AV[\x82RPPV[a$\xBCa$\xB7\x82a\x1A\x0BV[a$\x8AV[\x82RPPV[`\0\x81\x90P\x92\x91PPV[\x82\x81\x837`\0\x83\x83\x01RPPPV[`\0a$\xE8\x83\x85a$\xC2V[\x93Pa$\xF5\x83\x85\x84a$\xCDV[\x82\x84\x01\x90P\x93\x92PPPV[`\0\x81\x90P\x81`\0R` `\0 \x90P\x91\x90PV[`\0\x81Ta%#\x81a#\xF6V[a%-\x81\x86a$\xC2V[\x94P`\x01\x82\x16`\0\x81\x14a%HW`\x01\x81\x14a%]Wa%\x90V[`\xFF\x19\x83\x16\x86R\x81\x15\x15\x82\x02\x86\x01\x93Pa%\x90V[a%f\x85a%\x01V[`\0[\x83\x81\x10\x15a%\x88W\x81T\x81\x89\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa%iV[\x83\x88\x01\x95PPP[PPP\x92\x91PPV[`\0a%\xA5\x82\x89a$sV[`\x14\x82\x01\x91Pa%\xB5\x82\x88a$\x94V[` \x82\x01\x91Pa%\xC5\x82\x87a$\xABV[` \x82\x01\x91Pa%\xD6\x82\x85\x87a$\xDCV[\x91Pa%\xE2\x82\x84a%\x16V[\x91P\x81\x90P\x97\x96PPPPPPPV[a%\xFB\x81a\x1A\x15V[\x82RPPV[`\0a&\r\x83\x85a\x1E\xA2V[\x93Pa&\x1A\x83\x85\x84a$\xCDV[a&#\x83a\x1A\xD9V[\x84\x01\x90P\x93\x92PPPV[`\0``\x82\x01\x90Pa&C`\0\x83\x01\x87a %V[a&P` \x83\x01\x86a%\xF2V[\x81\x81\x03`@\x83\x01Ra&c\x81\x84\x86a&\x01V[\x90P\x95\x94PPPPPV[`\0\x82\x90P\x92\x91PPV[`\0` `\x1F\x83\x01\x04\x90P\x91\x90PV[`\0\x82\x82\x1B\x90P\x92\x91PPV[`\0`\x08\x83\x02a&\xC6\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82a&\x89V[a&\xD0\x86\x83a&\x89V[\x95P\x80\x19\x84\x16\x93P\x80\x86\x16\x84\x17\x92PPP\x93\x92PPPV[`\0a'\x03a&\xFEa&\xF9\x84a\x19\x07V[a\x18\x8DV[a\x19\x07V[\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[a'\x1D\x83a&\xE8V[a'1a')\x82a'\nV[\x84\x84Ta&\x96V[\x82UPPPPV[`\0\x90V[a'Fa'9V[a'Q\x81\x84\x84a'\x14V[PPPV[[\x81\x81\x10\x15a'uWa'j`\0\x82a'>V[`\x01\x81\x01\x90Pa'WV[PPV[`\x1F\x82\x11\x15a'\xBAWa'\x8B\x81a%\x01V[a'\x94\x84a&yV[\x81\x01` \x85\x10\x15a'\xA3W\x81\x90P[a'\xB7a'\xAF\x85a&yV[\x83\x01\x82a'VV[PP[PPPV[`\0\x82\x82\x1C\x90P\x92\x91PPV[`\0a'\xDD`\0\x19\x84`\x08\x02a'\xBFV[\x19\x80\x83\x16\x91PP\x92\x91PPV[`\0a'\xF6\x83\x83a'\xCCV[\x91P\x82`\x02\x02\x82\x17\x90P\x92\x91PPV[a(\x10\x83\x83a&nV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a()Wa((a \xF8V[[a(3\x82Ta#\xF6V[a(>\x82\x82\x85a'yV[`\0`\x1F\x83\x11`\x01\x81\x14a(mW`\0\x84\x15a([W\x82\x87\x015\x90P[a(e\x85\x82a'\xEAV[\x86UPa(\xCDV[`\x1F\x19\x84\x16a({\x86a%\x01V[`\0[\x82\x81\x10\x15a(\xA3W\x84\x89\x015\x82U`\x01\x82\x01\x91P` \x85\x01\x94P` \x81\x01\x90Pa(~V[\x86\x83\x10\x15a(\xC0W\x84\x89\x015a(\xBC`\x1F\x89\x16\x82a'\xCCV[\x83UP[`\x01`\x02\x88\x02\x01\x88UPPP[PPPPPPPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra(\xF1\x81\x84\x86a&\x01V[\x90P\x93\x92PPPV[\x7FInitializable: contract is alrea`\0\x82\x01R\x7Fdy initialized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a)V`.\x83a\x1C\xF9V[\x91Pa)a\x82a(\xFAV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra)\x85\x81a)IV[\x90P\x91\x90PV[\x7FOwnable: new owner is the zero a`\0\x82\x01R\x7Fddress\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a)\xE8`&\x83a\x1C\xF9V[\x91Pa)\xF3\x82a)\x8CV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra*\x17\x81a)\xDBV[\x90P\x91\x90PV[\x7FOwnable: caller is not the owner`\0\x82\x01RPV[`\0a*T` \x83a\x1C\xF9V[\x91Pa*_\x82a*\x1EV[` \x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra*\x83\x81a*GV[\x90P\x91\x90PV[\x7FInitializable: contract is not i`\0\x82\x01R\x7Fnitializing\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a*\xE6`+\x83a\x1C\xF9V[\x91Pa*\xF1\x82a*\x8AV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra+\x15\x81a*\xD9V[\x90P\x91\x90PV\xFE\xA2dipfsX\"\x12 \x99\xD0-\xF5>%\xC6\x9CH\x18\"\xCA\xC2\xD3\xCC\x14\x91\x88\x1B\x84\xBB\xFAb;\xE7\n\x9D\xFA\xB8j\xD5\xBFdsolcC\0\x08\x0F\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R`\x046\x10a\x01\x1FW`\x005`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xA0W\x80c\xB1\x07\tW\x11a\0dW\x80c\xB1\x07\tW\x14a\x04\x03W\x80c\xBB\x8A\xA1\xFC\x14a\x04,W\x80c\xC4\xD6m\xE8\x14a\x04kW\x80c\xDA\xD5D\xE0\x14a\x04\x94W\x80c\xF2\xFD\xE3\x8B\x14a\x04\xBFWa\x01\x1FV[\x80cqP\x18\xA6\x14a\x03\x17W\x80ct\xCC\x86\xAC\x14a\x03.W\x80c\x82\xEC\xF2\xF6\x14a\x03kW\x80c\x8D\xA5\xCB[\x14a\x03\x9BW\x80c\x96\xCD\x97 \x14a\x03\xC6Wa\x01\x1FV[\x80c>G\x15\x8C\x11a\0\xE7W\x80c>G\x15\x8C\x14a\x02\x1BW\x80cM\x19u\xB4\x14a\x02FW\x80cT\xFDMP\x14a\x02qW\x80c_\x01P\xCB\x14a\x02\x9CW\x80ce\x93\xDCn\x14a\x02\xDAWa\x01\x1FV[\x80c\x14\xF6\xB1\xA3\x14a\x01$W\x80c\x1Bh[\x9E\x14a\x01MW\x80c\x1E3B@\x14a\x01\x8AW\x80c%K\xD6\x83\x14a\x01\xB3W\x80c8\xD3\x8C\x97\x14a\x01\xF0W[`\0\x80\xFD[4\x80\x15a\x010W`\0\x80\xFD[Pa\x01K`\x04\x806\x03\x81\x01\x90a\x01F\x91\x90a\x18 V[a\x04\xE8V[\0[4\x80\x15a\x01YW`\0\x80\xFD[Pa\x01t`\x04\x806\x03\x81\x01\x90a\x01o\x91\x90a\x18`V[a\x05\x9CV[`@Qa\x01\x81\x91\x90a\x18\xECV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x96W`\0\x80\xFD[Pa\x01\xB1`\x04\x806\x03\x81\x01\x90a\x01\xAC\x91\x90a\x19=V[a\x05\xCFV[\0[4\x80\x15a\x01\xBFW`\0\x80\xFD[Pa\x01\xDA`\x04\x806\x03\x81\x01\x90a\x01\xD5\x91\x90a\x19}V[a\x063V[`@Qa\x01\xE7\x91\x90a\x1C/V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xFCW`\0\x80\xFD[Pa\x02\x05a\x08_V[`@Qa\x02\x12\x91\x90a\x1CmV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02'W`\0\x80\xFD[Pa\x020a\x08\x87V[`@Qa\x02=\x91\x90a\x1C\xA9V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02RW`\0\x80\xFD[Pa\x02[a\n\xE0V[`@Qa\x02h\x91\x90a\x1C\xD3V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02}W`\0\x80\xFD[Pa\x02\x86a\n\xEDV[`@Qa\x02\x93\x91\x90a\x1DCV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xA8W`\0\x80\xFD[Pa\x02\xC3`\x04\x806\x03\x81\x01\x90a\x02\xBE\x91\x90a\x1D\xF6V[a\x0B&V[`@Qa\x02\xD1\x92\x91\x90a\x1EyV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xE6W`\0\x80\xFD[Pa\x03\x01`\x04\x806\x03\x81\x01\x90a\x02\xFC\x91\x90a\x18`V[a\x0BsV[`@Qa\x03\x0E\x91\x90a\x1C\xD3V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03#W`\0\x80\xFD[Pa\x03,a\x0B\x8BV[\0[4\x80\x15a\x03:W`\0\x80\xFD[Pa\x03U`\x04\x806\x03\x81\x01\x90a\x03P\x91\x90a\x18`V[a\x0B\x9FV[`@Qa\x03b\x91\x90a\x1E\xECV[`@Q\x80\x91\x03\x90\xF3[a\x03\x85`\x04\x806\x03\x81\x01\x90a\x03\x80\x91\x90a\x1D\xF6V[a\x0C?V[`@Qa\x03\x92\x91\x90a\x18\xECV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xA7W`\0\x80\xFD[Pa\x03\xB0a\x0FCV[`@Qa\x03\xBD\x91\x90a\x1F\x1DV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xD2W`\0\x80\xFD[Pa\x03\xED`\x04\x806\x03\x81\x01\x90a\x03\xE8\x91\x90a\x1D\xF6V[a\x0FmV[`@Qa\x03\xFA\x91\x90a\x1FGV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x0FW`\0\x80\xFD[Pa\x04*`\x04\x806\x03\x81\x01\x90a\x04%\x91\x90a\x1FbV[a\x0F\xA6V[\0[4\x80\x15a\x048W`\0\x80\xFD[Pa\x04S`\x04\x806\x03\x81\x01\x90a\x04N\x91\x90a\x1F\xD6V[a\x10\xCBV[`@Qa\x04b\x93\x92\x91\x90a 4V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04wW`\0\x80\xFD[Pa\x04\x92`\x04\x806\x03\x81\x01\x90a\x04\x8D\x91\x90a \x97V[a\x11\x1AV[\0[4\x80\x15a\x04\xA0W`\0\x80\xFD[Pa\x04\xA9a\x123V[`@Qa\x04\xB6\x91\x90a\x1F\x1DV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xCBW`\0\x80\xFD[Pa\x04\xE6`\x04\x806\x03\x81\x01\x90a\x04\xE1\x91\x90a \x97V[a\x12\xB0V[\0[a\x04\xF0a\x133V[\x80`e`\0\x84c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81c\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFFQ=\x80\xE2\xC7\xFAHv\x08\xF7\na\x8D\xFB\xC0\xCFAV\x99\xDCiX\x8Ct~\x8CqVl\x88\xDE`@Q`@Q\x80\x91\x03\x90\xA3PPV[`e` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[a\x05\xD7a\x133V[\x80`f`\0\x84c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x80\x82c\xFF\xFF\xFF\xFF\x16\x7Ft\xD6f\\K&\xD5YjZ\xA1=0\x14\xE0\xC0j\xF4\xD3\"\x07Zy\x7F\x87\xB0<\xD4\xC5\xBC\x91\xCA`@Q`@Q\x80\x91\x03\x90\xA3PPV[```h\x80T\x90P\x83\x10\x15\x80a\x06IWP`\0\x82\x14[a\x08XW`@Q\x90P\x81`\x05\x1B` \x01\x81\x01`@R`\0\x83\x90P[`\0\x81\x10\x15\x80\x15a\x06uWP\x83\x81\x11\x15[\x15a\x08VW`\0`h\x82\x81T\x81\x10a\x06\x90Wa\x06\x8Fa \xC4V[[\x90`\0R` `\0 \x01T\x90P`\0\x80`\0a\x06\xAB\x84a\x13\xB1V[\x92P\x92P\x92Pa\x06\xC0\x89c\xFF\xFF\xFF\xFF\x16a\x13\xECV[c\xFF\xFF\xFF\xFF\x16a\x06\xD5\x84c\xFF\xFF\xFF\xFF\x16a\x13\xECV[c\xFF\xFF\xFF\xFF\x16\x03a\x08DW`\x01\x86Q\x01\x86R`\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c`\x9D34`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x074W=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07]\x91\x90a\"\x14V[\x90P`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBC\xEF;U`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xACW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xD0\x91\x90a\"rV[\x90P`@Q\x80`\xA0\x01`@R\x80\x88\x81R` \x01\x87\x81R` \x01\x85g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x82\x81R` \x01\x83\x81RP\x88`\x01\x8AQa\x08\x12\x91\x90a\"\xCEV[\x81Q\x81\x10a\x08#Wa\x08\"a \xC4V[[` \x02` \x01\x01\x81\x90RP\x88\x88Q\x10a\x08AWPPPPPPa\x08VV[PP[\x84\x80`\x01\x90\x03\x95PPPPPPa\x06dV[P[\x93\x92PPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80a\x08\xB6\x7F\xB51'hJV\x8B1s\xAE\x13\xB9\xF8\xA6\x01n$>c\xB6\xE8\xEE\x11x\xD6\xA7\x17\x85\x0B]a\x03`\0\x1Ba\x13\xF6V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x08\xF5W\x80\x91PPa\n\xDDV[`\x02`@Q\x80`@\x01`@R\x80`\x1A\x81R` \x01\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0\x81RPQa\t8\x91\x90a#\x02V[\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0`\0\x1C\x17`\0\x1Ba\t\x920`\0`@Q` \x01a\tw\x92\x91\x90a#\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x14\x01V[\x14a\t\xC9W`@Q\x7FT\xE43\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\t\xFD0`\x01`@Q` \x01a\t\xE2\x92\x91\x90a#\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x13\xF6V[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\n\xABW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n~W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xA2\x91\x90a#\x9AV[\x92PPPa\n\xDDV[`@Q\x7F3!D\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x90V[`\0`h\x80T\x90P\x90P\x90V[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F1.3.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\0\x80`\0a\x0B7\x87\x87\x87\x87a\x0FmV[\x90P`\0\x80a\x0BX`g`\0\x85\x81R` \x01\x90\x81R` \x01`\0 Ta\x13\xB1V[\x92P\x92PP\x80\x82\x80\x95P\x81\x96PPPPPP\x94P\x94\x92PPPV[`f` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[a\x0B\x93a\x133V[a\x0B\x9D`\0a\x14\x0CV[V[`i` R\x80`\0R`@`\0 `\0\x91P\x90P\x80Ta\x0B\xBE\x90a#\xF6V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xEA\x90a#\xF6V[\x80\x15a\x0C7W\x80`\x1F\x10a\x0C\x0CWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C7V[\x82\x01\x91\x90`\0R` `\0 \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\x1AW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81V[`\0\x80`e`\0\x87c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x0C\xF5W\x85`@Q\x7F\x03\x1Cm\xE4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x0C\xEC\x91\x90a$'V[`@Q\x80\x91\x03\x90\xFD[`f`\0\x87c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T4\x14a\rMW`@Q\x7F\x86 \xAA\x19\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`\x01Ca\r\\\x91\x90a\"\xCEV[@\x90Pa\r\xCF3\x87\x83\x88\x88`i`\0\x8Ec\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `@Q` \x01a\r\x9B\x96\x95\x94\x93\x92\x91\x90a%\x99V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x14\xD2\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x92P\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x81)\xFC\x1C4`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01`\0`@Q\x80\x83\x03\x81\x85\x88\x80;\x15\x80\x15a\x0E\x19W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x0E-W=`\0\x80>=`\0\xFD[PPPPP`\0a\x0E@\x88\x88\x88\x88a\x0FmV[\x90P`\0\x80\x1B`g`\0\x83\x81R` \x01\x90\x81R` \x01`\0 T\x14a\x0E\x9CW\x80`@Q\x7F\x01Oo\xE5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x0E\x93\x91\x90a\x1FGV[`@Q\x80\x91\x03\x90\xFD[`\0a\x0E\xA9\x89B\x87a\x14\xE8V[\x90P\x80`g`\0\x84\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP`h\x81\x90\x80`\x01\x81T\x01\x80\x82U\x80\x91PP`\x01\x90\x03\x90`\0R` `\0 \x01`\0\x90\x91\x90\x91\x90\x91PU\x87\x89c\xFF\xFF\xFF\xFF\x16\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F[V^\xFE\x82A\x1D\xA9\x88\x14\xF3V\xD0\xE7\xBC\xB8\xF0!\x9B\x8D\x97\x03\x07\xC5\xAF\xB4\xA6\x90:\x8B.5`@Q`@Q\x80\x91\x03\x90\xA4PPPP\x94\x93PPPPV[`\0`3`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x90V[`\0\x84\x84\x84\x84`@Q` \x01a\x0F\x86\x94\x93\x92\x91\x90a&.V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x94\x93PPPPV[a\x0F\xAEa\x133V[\x82`e`\0\x86c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81\x81`i`\0\x87c\xFF\xFF\xFF\xFF\x16c\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x91\x82a\x10:\x92\x91\x90a(\x06V[P\x83c\xFF\xFF\xFF\xFF\x16\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xFFQ=\x80\xE2\xC7\xFAHv\x08\xF7\na\x8D\xFB\xC0\xCFAV\x99\xDCiX\x8Ct~\x8CqVl\x88\xDE`@Q`@Q\x80\x91\x03\x90\xA3\x83c\xFF\xFF\xFF\xFF\x16\x7F\xA4\x7F\xCD\xF0u\xD6\x80\xD3\x81{\xFC\xA7\x97;7>\x1A_l\xFC;DGH)\x9C\xC2\xB8=\x83H\xF9\x83\x83`@Qa\x10\xBD\x92\x91\x90a(\xD6V[`@Q\x80\x91\x03\x90\xA2PPPPV[`\0\x80`\0\x80`\0\x80a\x10\xFB`h\x88\x81T\x81\x10a\x10\xEBWa\x10\xEAa \xC4V[[\x90`\0R` `\0 \x01Ta\x13\xB1V[\x92P\x92P\x92P\x82\x82\x82\x80\x96P\x81\x97P\x82\x98PPPPPPP\x91\x93\x90\x92PV[a\x11\"a\x08_V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15\x80\x15a\x11QWP\x80`\xFF\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10[a\x11\x90W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x11\x87\x90a)lV[`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP`\x01`\0`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPa\x11\xCDa\x14\xFEV[a\x11\xD5a\x15\xADV[a\x11\xDE\x82a\x14\x0CV[`\0\x80`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x81`@Qa\x12'\x91\x90a\x1CmV[`@Q\x80\x91\x03\x90\xA1PPV[`\0a\x12=a\x08\x87V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12\x87W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xAB\x91\x90a#\x9AV[\x90P\x90V[a\x12\xB8a\x133V[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x13'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x13\x1E\x90a)\xFEV[`@Q\x80\x91\x03\x90\xFD[a\x130\x81a\x14\x0CV[PV[a\x13;a\x16\x06V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x13Ya\x0FCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x13\xAFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x13\xA6\x90a*jV[`@Q\x80\x91\x03\x90\xFD[V[`\0\x80`\0\x83`\xE0\x1C\x92Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84`\xA0\x1C\x16\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x90P\x91\x93\x90\x92PV[`\0\x81\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[`\0`3`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x81`3`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0`@Q`@Q\x80\x91\x03\x90\xA3PPV[`\0a\x14\xE0`\0\x84\x84a\x16\x0EV[\x90P\x92\x91PPV[`\0\x81\x83`\xA0\x1B\x85`\xE0\x1B\x17\x17\x90P\x93\x92PPPV[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x15\x1Da\x08\x87V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x15tWP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x15[a\x123V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x15a\x15\xABW`@Q\x7F\xC4\x05\n&\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\x15\xFCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x15\xF3\x90a*\xFCV[`@Q\x80\x91\x03\x90\xFD[a\x16\x04a\x16\xFFV[V[`\x003\x90P\x90V[`\0``\x82\x03Q`@\x83\x03Q` \x84\x03Q\x84Q\x80` \x87\x01\x01\x80Q`\x02\x83\x01lZ\xF4==\x93\x80>``W\xFD[\xF3\x89R\x89`\r\x8A\x03RxY=\xA1\0[6==7====a\0\0\x80`b696\x01=s\x81`H\x1B\x17`!\x8A\x03R\x7F\x9EJ\xC3O!\xC6\x19\xCE\xFC\x92l\x8B\xD9;T\xBFZ9\xC7\xAB!'\xA8\x95\xAF\x1C\xC0i\x1D~=\xFF`:\x8A\x03Rr\xFDa\0\0=\x81`\n=9\xF36`,W4=R\x7F`b\x82\x01`x\x1B\x17a\xFF\x9E\x82\x10`Y\x01\x8A\x03R\x80`\xF0\x1B\x83R`l\x81\x01`L\x8A\x03\x8C\xF0\x97P\x87a\x16\xD9Wc0\x11d%`\0R`\x04`\x1C\xFD[\x81\x83R\x83\x89R\x84` \x8A\x03R\x85`@\x8A\x03R\x86``\x8A\x03RPPPPPPP\x93\x92PPPV[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\x17NW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x17E\x90a*\xFCV[`@Q\x80\x91\x03\x90\xFD[a\x17^a\x17Ya\x16\x06V[a\x14\x0CV[V[`\0`@Q\x90P\x90V[`\0\x80\xFD[`\0\x80\xFD[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a\x17\x8D\x81a\x17tV[\x81\x14a\x17\x98W`\0\x80\xFD[PV[`\0\x815\x90Pa\x17\xAA\x81a\x17\x84V[\x92\x91PPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x17\xDB\x82a\x17\xB0V[\x90P\x91\x90PV[`\0a\x17\xED\x82a\x17\xD0V[\x90P\x91\x90PV[a\x17\xFD\x81a\x17\xE2V[\x81\x14a\x18\x08W`\0\x80\xFD[PV[`\0\x815\x90Pa\x18\x1A\x81a\x17\xF4V[\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15a\x187Wa\x186a\x17jV[[`\0a\x18E\x85\x82\x86\x01a\x17\x9BV[\x92PP` a\x18V\x85\x82\x86\x01a\x18\x0BV[\x91PP\x92P\x92\x90PV[`\0` \x82\x84\x03\x12\x15a\x18vWa\x18ua\x17jV[[`\0a\x18\x84\x84\x82\x85\x01a\x17\x9BV[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[`\0a\x18\xB2a\x18\xADa\x18\xA8\x84a\x17\xB0V[a\x18\x8DV[a\x17\xB0V[\x90P\x91\x90PV[`\0a\x18\xC4\x82a\x18\x97V[\x90P\x91\x90PV[`\0a\x18\xD6\x82a\x18\xB9V[\x90P\x91\x90PV[a\x18\xE6\x81a\x18\xCBV[\x82RPPV[`\0` \x82\x01\x90Pa\x19\x01`\0\x83\x01\x84a\x18\xDDV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\x19\x1A\x81a\x19\x07V[\x81\x14a\x19%W`\0\x80\xFD[PV[`\0\x815\x90Pa\x197\x81a\x19\x11V[\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15a\x19TWa\x19Sa\x17jV[[`\0a\x19b\x85\x82\x86\x01a\x17\x9BV[\x92PP` a\x19s\x85\x82\x86\x01a\x19(V[\x91PP\x92P\x92\x90PV[`\0\x80`\0``\x84\x86\x03\x12\x15a\x19\x96Wa\x19\x95a\x17jV[[`\0a\x19\xA4\x86\x82\x87\x01a\x17\x9BV[\x93PP` a\x19\xB5\x86\x82\x87\x01a\x19(V[\x92PP`@a\x19\xC6\x86\x82\x87\x01a\x19(V[\x91PP\x92P\x92P\x92V[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0\x81\x90P` \x82\x01\x90P\x91\x90PV[a\x1A\x05\x81a\x19\x07V[\x82RPPV[`\0\x81\x90P\x91\x90PV[`\0a\x1A \x82a\x1A\x0BV[\x90P\x91\x90PV[a\x1A0\x81a\x1A\x15V[\x82RPPV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x1Aea\x1A`a\x1A[\x84a\x1A6V[a\x18\x8DV[a\x1A6V[\x90P\x91\x90PV[a\x1Au\x81a\x1AJV[\x82RPPV[a\x1A\x84\x81a\x1A\x15V[\x82RPPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x1A\xC4W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x1A\xA9V[\x83\x81\x11\x15a\x1A\xD3W`\0\x84\x84\x01R[PPPPV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x1A\xF5\x82a\x1A\x8AV[a\x1A\xFF\x81\x85a\x1A\x95V[\x93Pa\x1B\x0F\x81\x85` \x86\x01a\x1A\xA6V[a\x1B\x18\x81a\x1A\xD9V[\x84\x01\x91PP\x92\x91PPV[`\0`\xA0\x83\x01`\0\x83\x01Qa\x1B;`\0\x86\x01\x82a\x19\xFCV[P` \x83\x01Qa\x1BN` \x86\x01\x82a\x1A'V[P`@\x83\x01Qa\x1Ba`@\x86\x01\x82a\x1AlV[P``\x83\x01Qa\x1Bt``\x86\x01\x82a\x1A{V[P`\x80\x83\x01Q\x84\x82\x03`\x80\x86\x01Ra\x1B\x8C\x82\x82a\x1A\xEAV[\x91PP\x80\x91PP\x92\x91PPV[`\0a\x1B\xA5\x83\x83a\x1B#V[\x90P\x92\x91PPV[`\0` \x82\x01\x90P\x91\x90PV[`\0a\x1B\xC5\x82a\x19\xD0V[a\x1B\xCF\x81\x85a\x19\xDBV[\x93P\x83` \x82\x02\x85\x01a\x1B\xE1\x85a\x19\xECV[\x80`\0[\x85\x81\x10\x15a\x1C\x1DW\x84\x84\x03\x89R\x81Qa\x1B\xFE\x85\x82a\x1B\x99V[\x94Pa\x1C\t\x83a\x1B\xADV[\x92P` \x8A\x01\x99PP`\x01\x81\x01\x90Pa\x1B\xE5V[P\x82\x97P\x87\x95PPPPPP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x1CI\x81\x84a\x1B\xBAV[\x90P\x92\x91PPV[`\0`\xFF\x82\x16\x90P\x91\x90PV[a\x1Cg\x81a\x1CQV[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\x82`\0\x83\x01\x84a\x1C^V[\x92\x91PPV[`\0a\x1C\x93\x82a\x18\xB9V[\x90P\x91\x90PV[a\x1C\xA3\x81a\x1C\x88V[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\xBE`\0\x83\x01\x84a\x1C\x9AV[\x92\x91PPV[a\x1C\xCD\x81a\x19\x07V[\x82RPPV[`\0` \x82\x01\x90Pa\x1C\xE8`\0\x83\x01\x84a\x1C\xC4V[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0a\x1D\x15\x82a\x1C\xEEV[a\x1D\x1F\x81\x85a\x1C\xF9V[\x93Pa\x1D/\x81\x85` \x86\x01a\x1A\xA6V[a\x1D8\x81a\x1A\xD9V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x1D]\x81\x84a\x1D\nV[\x90P\x92\x91PPV[a\x1Dn\x81a\x1A\x0BV[\x81\x14a\x1DyW`\0\x80\xFD[PV[`\0\x815\x90Pa\x1D\x8B\x81a\x1DeV[\x92\x91PPV[`\0\x80\xFD[`\0\x80\xFD[`\0\x80\xFD[`\0\x80\x83`\x1F\x84\x01\x12a\x1D\xB6Wa\x1D\xB5a\x1D\x91V[[\x825\x90Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD3Wa\x1D\xD2a\x1D\x96V[[` \x83\x01\x91P\x83`\x01\x82\x02\x83\x01\x11\x15a\x1D\xEFWa\x1D\xEEa\x1D\x9BV[[\x92P\x92\x90PV[`\0\x80`\0\x80``\x85\x87\x03\x12\x15a\x1E\x10Wa\x1E\x0Fa\x17jV[[`\0a\x1E\x1E\x87\x82\x88\x01a\x17\x9BV[\x94PP` a\x1E/\x87\x82\x88\x01a\x1D|V[\x93PP`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1EPWa\x1EOa\x17oV[[a\x1E\\\x87\x82\x88\x01a\x1D\xA0V[\x92P\x92PP\x92\x95\x91\x94P\x92PV[a\x1Es\x81a\x1AJV[\x82RPPV[`\0`@\x82\x01\x90Pa\x1E\x8E`\0\x83\x01\x85a\x18\xDDV[a\x1E\x9B` \x83\x01\x84a\x1EjV[\x93\x92PPPV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0a\x1E\xBE\x82a\x1A\x8AV[a\x1E\xC8\x81\x85a\x1E\xA2V[\x93Pa\x1E\xD8\x81\x85` \x86\x01a\x1A\xA6V[a\x1E\xE1\x81a\x1A\xD9V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x1F\x06\x81\x84a\x1E\xB3V[\x90P\x92\x91PPV[a\x1F\x17\x81a\x17\xD0V[\x82RPPV[`\0` \x82\x01\x90Pa\x1F2`\0\x83\x01\x84a\x1F\x0EV[\x92\x91PPV[a\x1FA\x81a\x1A\x15V[\x82RPPV[`\0` \x82\x01\x90Pa\x1F\\`\0\x83\x01\x84a\x1F8V[\x92\x91PPV[`\0\x80`\0\x80``\x85\x87\x03\x12\x15a\x1F|Wa\x1F{a\x17jV[[`\0a\x1F\x8A\x87\x82\x88\x01a\x17\x9BV[\x94PP` a\x1F\x9B\x87\x82\x88\x01a\x18\x0BV[\x93PP`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xBCWa\x1F\xBBa\x17oV[[a\x1F\xC8\x87\x82\x88\x01a\x1D\xA0V[\x92P\x92PP\x92\x95\x91\x94P\x92PV[`\0` \x82\x84\x03\x12\x15a\x1F\xECWa\x1F\xEBa\x17jV[[`\0a\x1F\xFA\x84\x82\x85\x01a\x19(V[\x91PP\x92\x91PPV[`\0a \x1Ea \x19a \x14\x84a\x17tV[a\x18\x8DV[a\x17tV[\x90P\x91\x90PV[a .\x81a \x03V[\x82RPPV[`\0``\x82\x01\x90Pa I`\0\x83\x01\x86a %V[a V` \x83\x01\x85a\x1EjV[a c`@\x83\x01\x84a\x18\xDDV[\x94\x93PPPPV[a t\x81a\x17\xD0V[\x81\x14a \x7FW`\0\x80\xFD[PV[`\0\x815\x90Pa \x91\x81a kV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a \xADWa \xACa\x17jV[[`\0a \xBB\x84\x82\x85\x01a \x82V[\x91PP\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`2`\x04R`$`\0\xFD[`\0\x80\xFD[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`A`\x04R`$`\0\xFD[a!0\x82a\x1A\xD9V[\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a!OWa!Na \xF8V[[\x80`@RPPPV[`\0a!ba\x17`V[\x90Pa!n\x82\x82a!'V[\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a!\x8EWa!\x8Da \xF8V[[a!\x97\x82a\x1A\xD9V[\x90P` \x81\x01\x90P\x91\x90PV[`\0a!\xB7a!\xB2\x84a!sV[a!XV[\x90P\x82\x81R` \x81\x01\x84\x84\x84\x01\x11\x15a!\xD3Wa!\xD2a \xF3V[[a!\xDE\x84\x82\x85a\x1A\xA6V[P\x93\x92PPPV[`\0\x82`\x1F\x83\x01\x12a!\xFBWa!\xFAa\x1D\x91V[[\x81Qa\"\x0B\x84\x82` \x86\x01a!\xA4V[\x91PP\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\"*Wa\")a\x17jV[[`\0\x82\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\"HWa\"Ga\x17oV[[a\"T\x84\x82\x85\x01a!\xE6V[\x91PP\x92\x91PPV[`\0\x81Q\x90Pa\"l\x81a\x1DeV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\"\x88Wa\"\x87a\x17jV[[`\0a\"\x96\x84\x82\x85\x01a\"]V[\x91PP\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x11`\x04R`$`\0\xFD[`\0a\"\xD9\x82a\x19\x07V[\x91Pa\"\xE4\x83a\x19\x07V[\x92P\x82\x82\x10\x15a\"\xF7Wa\"\xF6a\"\x9FV[[\x82\x82\x03\x90P\x92\x91PPV[`\0a#\r\x82a\x19\x07V[\x91Pa#\x18\x83a\x19\x07V[\x92P\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x04\x83\x11\x82\x15\x15\x16\x15a#QWa#Pa\"\x9FV[[\x82\x82\x02\x90P\x92\x91PPV[`\0`@\x82\x01\x90Pa#q`\0\x83\x01\x85a\x1F\x0EV[a#~` \x83\x01\x84a\x1C\xC4V[\x93\x92PPPV[`\0\x81Q\x90Pa#\x94\x81a kV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a#\xB0Wa#\xAFa\x17jV[[`\0a#\xBE\x84\x82\x85\x01a#\x85V[\x91PP\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\"`\x04R`$`\0\xFD[`\0`\x02\x82\x04\x90P`\x01\x82\x16\x80a$\x0EW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a$!Wa$ a#\xC7V[[P\x91\x90PV[`\0` \x82\x01\x90Pa$<`\0\x83\x01\x84a %V[\x92\x91PPV[`\0\x81``\x1B\x90P\x91\x90PV[`\0a$Z\x82a$BV[\x90P\x91\x90PV[`\0a$l\x82a$OV[\x90P\x91\x90PV[a$\x84a$\x7F\x82a\x17\xD0V[a$aV[\x82RPPV[`\0\x81\x90P\x91\x90PV[a$\xA5a$\xA0\x82a\x1A\x15V[a$\x8AV[\x82RPPV[a$\xBCa$\xB7\x82a\x1A\x0BV[a$\x8AV[\x82RPPV[`\0\x81\x90P\x92\x91PPV[\x82\x81\x837`\0\x83\x83\x01RPPPV[`\0a$\xE8\x83\x85a$\xC2V[\x93Pa$\xF5\x83\x85\x84a$\xCDV[\x82\x84\x01\x90P\x93\x92PPPV[`\0\x81\x90P\x81`\0R` `\0 \x90P\x91\x90PV[`\0\x81Ta%#\x81a#\xF6V[a%-\x81\x86a$\xC2V[\x94P`\x01\x82\x16`\0\x81\x14a%HW`\x01\x81\x14a%]Wa%\x90V[`\xFF\x19\x83\x16\x86R\x81\x15\x15\x82\x02\x86\x01\x93Pa%\x90V[a%f\x85a%\x01V[`\0[\x83\x81\x10\x15a%\x88W\x81T\x81\x89\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa%iV[\x83\x88\x01\x95PPP[PPP\x92\x91PPV[`\0a%\xA5\x82\x89a$sV[`\x14\x82\x01\x91Pa%\xB5\x82\x88a$\x94V[` \x82\x01\x91Pa%\xC5\x82\x87a$\xABV[` \x82\x01\x91Pa%\xD6\x82\x85\x87a$\xDCV[\x91Pa%\xE2\x82\x84a%\x16V[\x91P\x81\x90P\x97\x96PPPPPPPV[a%\xFB\x81a\x1A\x15V[\x82RPPV[`\0a&\r\x83\x85a\x1E\xA2V[\x93Pa&\x1A\x83\x85\x84a$\xCDV[a&#\x83a\x1A\xD9V[\x84\x01\x90P\x93\x92PPPV[`\0``\x82\x01\x90Pa&C`\0\x83\x01\x87a %V[a&P` \x83\x01\x86a%\xF2V[\x81\x81\x03`@\x83\x01Ra&c\x81\x84\x86a&\x01V[\x90P\x95\x94PPPPPV[`\0\x82\x90P\x92\x91PPV[`\0` `\x1F\x83\x01\x04\x90P\x91\x90PV[`\0\x82\x82\x1B\x90P\x92\x91PPV[`\0`\x08\x83\x02a&\xC6\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82a&\x89V[a&\xD0\x86\x83a&\x89V[\x95P\x80\x19\x84\x16\x93P\x80\x86\x16\x84\x17\x92PPP\x93\x92PPPV[`\0a'\x03a&\xFEa&\xF9\x84a\x19\x07V[a\x18\x8DV[a\x19\x07V[\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[a'\x1D\x83a&\xE8V[a'1a')\x82a'\nV[\x84\x84Ta&\x96V[\x82UPPPPV[`\0\x90V[a'Fa'9V[a'Q\x81\x84\x84a'\x14V[PPPV[[\x81\x81\x10\x15a'uWa'j`\0\x82a'>V[`\x01\x81\x01\x90Pa'WV[PPV[`\x1F\x82\x11\x15a'\xBAWa'\x8B\x81a%\x01V[a'\x94\x84a&yV[\x81\x01` \x85\x10\x15a'\xA3W\x81\x90P[a'\xB7a'\xAF\x85a&yV[\x83\x01\x82a'VV[PP[PPPV[`\0\x82\x82\x1C\x90P\x92\x91PPV[`\0a'\xDD`\0\x19\x84`\x08\x02a'\xBFV[\x19\x80\x83\x16\x91PP\x92\x91PPV[`\0a'\xF6\x83\x83a'\xCCV[\x91P\x82`\x02\x02\x82\x17\x90P\x92\x91PPV[a(\x10\x83\x83a&nV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a()Wa((a \xF8V[[a(3\x82Ta#\xF6V[a(>\x82\x82\x85a'yV[`\0`\x1F\x83\x11`\x01\x81\x14a(mW`\0\x84\x15a([W\x82\x87\x015\x90P[a(e\x85\x82a'\xEAV[\x86UPa(\xCDV[`\x1F\x19\x84\x16a({\x86a%\x01V[`\0[\x82\x81\x10\x15a(\xA3W\x84\x89\x015\x82U`\x01\x82\x01\x91P` \x85\x01\x94P` \x81\x01\x90Pa(~V[\x86\x83\x10\x15a(\xC0W\x84\x89\x015a(\xBC`\x1F\x89\x16\x82a'\xCCV[\x83UP[`\x01`\x02\x88\x02\x01\x88UPPP[PPPPPPPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra(\xF1\x81\x84\x86a&\x01V[\x90P\x93\x92PPPV[\x7FInitializable: contract is alrea`\0\x82\x01R\x7Fdy initialized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a)V`.\x83a\x1C\xF9V[\x91Pa)a\x82a(\xFAV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra)\x85\x81a)IV[\x90P\x91\x90PV[\x7FOwnable: new owner is the zero a`\0\x82\x01R\x7Fddress\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a)\xE8`&\x83a\x1C\xF9V[\x91Pa)\xF3\x82a)\x8CV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra*\x17\x81a)\xDBV[\x90P\x91\x90PV[\x7FOwnable: caller is not the owner`\0\x82\x01RPV[`\0a*T` \x83a\x1C\xF9V[\x91Pa*_\x82a*\x1EV[` \x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra*\x83\x81a*GV[\x90P\x91\x90PV[\x7FInitializable: contract is not i`\0\x82\x01R\x7Fnitializing\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a*\xE6`+\x83a\x1C\xF9V[\x91Pa*\xF1\x82a*\x8AV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra+\x15\x81a*\xD9V[\x90P\x91\x90PV\xFE\xA2dipfsX\"\x12 \x99\xD0-\xF5>%\xC6\x9CH\x18\"\xCA\xC2\xD3\xCC\x14\x91\x88\x1B\x84\xBB\xFAb;\xE7\n\x9D\xFA\xB8j\xD5\xBFdsolcC\0\x08\x0F\x003", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Claim(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Claim { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Claim { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Claim) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Claim { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Claim { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameId(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameId { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for GameId { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: GameId) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameId { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameId { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Hash(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Hash { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Hash { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Hash) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Hash { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Hash { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Timestamp(u64); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u64 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<64>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Timestamp { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u64) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u64 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Timestamp { + fn from(value: u64) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u64 { + fn from(value: Timestamp) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Timestamp { + type RustType = u64; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Timestamp { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**```solidity +struct GameSearchResult { uint256 index; GameId metadata; Timestamp timestamp; Claim rootClaim; bytes extraData; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameSearchResult { + #[allow(missing_docs)] + pub index: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub metadata: ::RustType, + #[allow(missing_docs)] + pub timestamp: ::RustType, + #[allow(missing_docs)] + pub rootClaim: ::RustType, + #[allow(missing_docs)] + pub extraData: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + GameId, + Timestamp, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameSearchResult) -> Self { + ( + value.index, + value.metadata, + value.timestamp, + value.rootClaim, + value.extraData, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameSearchResult { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + index: tuple.0, + metadata: tuple.1, + timestamp: tuple.2, + rootClaim: tuple.3, + extraData: tuple.4, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for GameSearchResult { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for GameSearchResult { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.index), + ::tokenize(&self.metadata), + ::tokenize(&self.timestamp), + ::tokenize(&self.rootClaim), + ::tokenize( + &self.extraData, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameSearchResult { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for GameSearchResult { + const NAME: &'static str = "GameSearchResult"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "GameSearchResult(uint256 index,bytes32 metadata,uint64 timestamp,bytes32 rootClaim,bytes extraData)", + ) + } + #[inline] + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { + alloy_sol_types::private::Vec::new() + } + #[inline] + fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.index) + .0, + ::eip712_data_word( + &self.metadata, + ) + .0, + ::eip712_data_word( + &self.timestamp, + ) + .0, + ::eip712_data_word( + &self.rootClaim, + ) + .0, + ::eip712_data_word( + &self.extraData, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameSearchResult { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.index) + + ::topic_preimage_length( + &rust.metadata, + ) + + ::topic_preimage_length( + &rust.timestamp, + ) + + ::topic_preimage_length( + &rust.rootClaim, + ) + + ::topic_preimage_length( + &rust.extraData, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.index, + out, + ); + ::encode_topic_preimage( + &rust.metadata, + out, + ); + ::encode_topic_preimage( + &rust.timestamp, + out, + ); + ::encode_topic_preimage( + &rust.rootClaim, + out, + ); + ::encode_topic_preimage( + &rust.extraData, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + /**Custom error with signature `GameAlreadyExists(bytes32)` and selector `0x014f6fe5`. +```solidity +error GameAlreadyExists(Hash uuid); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameAlreadyExists { + #[allow(missing_docs)] + pub uuid: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (::RustType,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameAlreadyExists) -> Self { + (value.uuid,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameAlreadyExists { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { uuid: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameAlreadyExists { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameAlreadyExists(bytes32)"; + const SELECTOR: [u8; 4] = [1u8, 79u8, 111u8, 229u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.uuid),) + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `IncorrectBondAmount()` and selector `0x8620aa19`. +```solidity +error IncorrectBondAmount(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IncorrectBondAmount; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IncorrectBondAmount) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IncorrectBondAmount { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for IncorrectBondAmount { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IncorrectBondAmount()"; + const SELECTOR: [u8; 4] = [134u8, 32u8, 170u8, 25u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `NoImplementation(uint32)` and selector `0x031c6de4`. +```solidity +error NoImplementation(GameType gameType); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct NoImplementation { + #[allow(missing_docs)] + pub gameType: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: NoImplementation) -> Self { + (value.gameType,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for NoImplementation { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { gameType: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for NoImplementation { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "NoImplementation(uint32)"; + const SELECTOR: [u8; 4] = [3u8, 28u8, 109u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.gameType),) + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdmin()` and selector `0xe818dcc3`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdmin(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdmin; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdmin) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdmin { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdmin { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdmin()"; + const SELECTOR: [u8; 4] = [232u8, 24u8, 220u8, 195u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()` and selector `0xc4050a26`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [196u8, 5u8, 10u8, 38u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOwner()` and selector `0x7f12c64b`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [127u8, 18u8, 198u8, 75u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotResolvedDelegateProxy()` and selector `0x54e433cd`. +```solidity +error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotResolvedDelegateProxy; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotResolvedDelegateProxy) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotResolvedDelegateProxy()"; + const SELECTOR: [u8; 4] = [84u8, 228u8, 51u8, 205u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotSharedProxyAdminOwner()` and selector `0x075c4314`. +```solidity +error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotSharedProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotSharedProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotSharedProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [7u8, 92u8, 67u8, 20u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_ProxyAdminNotFound()` and selector `0x332144db`. +```solidity +error ProxyAdminOwnedBase_ProxyAdminNotFound(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_ProxyAdminNotFound; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_ProxyAdminNotFound) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_ProxyAdminNotFound { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_ProxyAdminNotFound { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_ProxyAdminNotFound()"; + const SELECTOR: [u8; 4] = [51u8, 33u8, 68u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ReinitializableBase_ZeroInitVersion()` and selector `0x9b01afed`. +```solidity +error ReinitializableBase_ZeroInitVersion(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ReinitializableBase_ZeroInitVersion; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ReinitializableBase_ZeroInitVersion) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ReinitializableBase_ZeroInitVersion { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ReinitializableBase_ZeroInitVersion { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ReinitializableBase_ZeroInitVersion()"; + const SELECTOR: [u8; 4] = [155u8, 1u8, 175u8, 237u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Event with signature `DisputeGameCreated(address,uint32,bytes32)` and selector `0x5b565efe82411da98814f356d0e7bcb8f0219b8d970307c5afb4a6903a8b2e35`. +```solidity +event DisputeGameCreated(address indexed disputeProxy, GameType indexed gameType, Claim indexed rootClaim); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct DisputeGameCreated { + #[allow(missing_docs)] + pub disputeProxy: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub gameType: ::RustType, + #[allow(missing_docs)] + pub rootClaim: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for DisputeGameCreated { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + GameType, + Claim, + ); + const SIGNATURE: &'static str = "DisputeGameCreated(address,uint32,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 91u8, 86u8, 94u8, 254u8, 130u8, 65u8, 29u8, 169u8, 136u8, 20u8, 243u8, + 86u8, 208u8, 231u8, 188u8, 184u8, 240u8, 33u8, 155u8, 141u8, 151u8, 3u8, + 7u8, 197u8, 175u8, 180u8, 166u8, 144u8, 58u8, 139u8, 46u8, 53u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + disputeProxy: topics.1, + gameType: topics.2, + rootClaim: topics.3, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.disputeProxy.clone(), + self.gameType.clone(), + self.rootClaim.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.disputeProxy, + ); + out[2usize] = ::encode_topic( + &self.gameType, + ); + out[3usize] = ::encode_topic( + &self.rootClaim, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for DisputeGameCreated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&DisputeGameCreated> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &DisputeGameCreated) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `ImplementationArgsSet(uint32,bytes)` and selector `0xa47fcdf075d680d3817bfca7973b373e1a5f6cfc3b444748299cc2b83d8348f9`. +```solidity +event ImplementationArgsSet(GameType indexed gameType, bytes args); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct ImplementationArgsSet { + #[allow(missing_docs)] + pub gameType: ::RustType, + #[allow(missing_docs)] + pub args: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for ImplementationArgsSet { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>, GameType); + const SIGNATURE: &'static str = "ImplementationArgsSet(uint32,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 164u8, 127u8, 205u8, 240u8, 117u8, 214u8, 128u8, 211u8, 129u8, 123u8, + 252u8, 167u8, 151u8, 59u8, 55u8, 62u8, 26u8, 95u8, 108u8, 252u8, 59u8, + 68u8, 71u8, 72u8, 41u8, 156u8, 194u8, 184u8, 61u8, 131u8, 72u8, 249u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + gameType: topics.1, + args: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.gameType.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.gameType, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for ImplementationArgsSet { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ImplementationArgsSet> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &ImplementationArgsSet) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `ImplementationSet(address,uint32)` and selector `0xff513d80e2c7fa487608f70a618dfbc0cf415699dc69588c747e8c71566c88de`. +```solidity +event ImplementationSet(address indexed r#impl, GameType indexed gameType); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct ImplementationSet { + #[allow(missing_docs)] + pub r#impl: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub gameType: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for ImplementationSet { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + GameType, + ); + const SIGNATURE: &'static str = "ImplementationSet(address,uint32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 255u8, 81u8, 61u8, 128u8, 226u8, 199u8, 250u8, 72u8, 118u8, 8u8, 247u8, + 10u8, 97u8, 141u8, 251u8, 192u8, 207u8, 65u8, 86u8, 153u8, 220u8, 105u8, + 88u8, 140u8, 116u8, 126u8, 140u8, 113u8, 86u8, 108u8, 136u8, 222u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + r#impl: topics.1, + gameType: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.r#impl.clone(), self.gameType.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.r#impl, + ); + out[2usize] = ::encode_topic( + &self.gameType, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for ImplementationSet { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ImplementationSet> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &ImplementationSet) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `InitBondUpdated(uint32,uint256)` and selector `0x74d6665c4b26d5596a5aa13d3014e0c06af4d322075a797f87b03cd4c5bc91ca`. +```solidity +event InitBondUpdated(GameType indexed gameType, uint256 indexed newBond); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct InitBondUpdated { + #[allow(missing_docs)] + pub gameType: ::RustType, + #[allow(missing_docs)] + pub newBond: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for InitBondUpdated { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + GameType, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "InitBondUpdated(uint32,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 116u8, 214u8, 102u8, 92u8, 75u8, 38u8, 213u8, 89u8, 106u8, 90u8, 161u8, + 61u8, 48u8, 20u8, 224u8, 192u8, 106u8, 244u8, 211u8, 34u8, 7u8, 90u8, + 121u8, 127u8, 135u8, 176u8, 60u8, 212u8, 197u8, 188u8, 145u8, 202u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + gameType: topics.1, + newBond: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.gameType.clone(), + self.newBond.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.gameType, + ); + out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.newBond); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for InitBondUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&InitBondUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &InitBondUpdated) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`. +```solidity +event Initialized(uint8 version); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Initialized { + #[allow(missing_docs)] + pub version: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Initialized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Initialized(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { version: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Initialized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Initialized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Initialized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`. +```solidity +event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct OwnershipTransferred { + #[allow(missing_docs)] + pub previousOwner: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub newOwner: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "OwnershipTransferred(address,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, + 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, + 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.previousOwner.clone(), + self.newOwner.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::encode_topic( + &self.newOwner, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OwnershipTransferred { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall {} + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + } + }; + /**Function with signature `create(uint32,bytes32,bytes)` and selector `0x82ecf2f6`. +```solidity +function create(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external payable returns (address proxy_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _rootClaim: ::RustType, + #[allow(missing_docs)] + pub _extraData: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`create(uint32,bytes32,bytes)`](createCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createReturn { + #[allow(missing_docs)] + pub proxy_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createCall) -> Self { + (value._gameType, value._rootClaim, value._extraData) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _rootClaim: tuple.1, + _extraData: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createReturn) -> Self { + (value.proxy_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { proxy_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createCall { + type Parameters<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "create(uint32,bytes32,bytes)"; + const SELECTOR: [u8; 4] = [130u8, 236u8, 242u8, 246u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize(&self._rootClaim), + ::tokenize( + &self._extraData, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createReturn = r.into(); + r.proxy_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createReturn = r.into(); + r.proxy_ + }) + } + } + }; + /**Function with signature `findLatestGames(uint32,uint256,uint256)` and selector `0x254bd683`. +```solidity +function findLatestGames(GameType _gameType, uint256 _start, uint256 _n) external view returns (GameSearchResult[] memory games_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct findLatestGamesCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _start: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _n: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`findLatestGames(uint32,uint256,uint256)`](findLatestGamesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct findLatestGamesReturn { + #[allow(missing_docs)] + pub games_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: findLatestGamesCall) -> Self { + (value._gameType, value._start, value._n) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for findLatestGamesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _start: tuple.1, + _n: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: findLatestGamesReturn) -> Self { + (value.games_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for findLatestGamesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { games_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for findLatestGamesCall { + type Parameters<'a> = ( + GameType, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "findLatestGames(uint32,uint256,uint256)"; + const SELECTOR: [u8; 4] = [37u8, 75u8, 214u8, 131u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + as alloy_sol_types::SolType>::tokenize(&self._start), + as alloy_sol_types::SolType>::tokenize(&self._n), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: findLatestGamesReturn = r.into(); + r.games_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: findLatestGamesReturn = r.into(); + r.games_ + }) + } + } + }; + /**Function with signature `gameArgs(uint32)` and selector `0x74cc86ac`. +```solidity +function gameArgs(GameType) external view returns (bytes memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameArgsCall(pub ::RustType); + ///Container type for the return parameters of the [`gameArgs(uint32)`](gameArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameArgsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameArgsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameArgsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameArgsCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Bytes; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameArgs(uint32)"; + const SELECTOR: [u8; 4] = [116u8, 204u8, 134u8, 172u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.0),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameArgsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameArgsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `gameAtIndex(uint256)` and selector `0xbb8aa1fc`. +```solidity +function gameAtIndex(uint256 _index) external view returns (GameType gameType_, Timestamp timestamp_, address proxy_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameAtIndexCall { + #[allow(missing_docs)] + pub _index: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`gameAtIndex(uint256)`](gameAtIndexCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameAtIndexReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + #[allow(missing_docs)] + pub timestamp_: ::RustType, + #[allow(missing_docs)] + pub proxy_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameAtIndexCall) -> Self { + (value._index,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameAtIndexCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _index: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Timestamp, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameAtIndexReturn) -> Self { + (value.gameType_, value.timestamp_, value.proxy_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameAtIndexReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + gameType_: tuple.0, + timestamp_: tuple.1, + proxy_: tuple.2, + } + } + } + } + impl gameAtIndexReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.gameType_), + ::tokenize(&self.timestamp_), + ::tokenize( + &self.proxy_, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameAtIndexCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = gameAtIndexReturn; + type ReturnTuple<'a> = ( + GameType, + Timestamp, + alloy::sol_types::sol_data::Address, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameAtIndex(uint256)"; + const SELECTOR: [u8; 4] = [187u8, 138u8, 161u8, 252u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._index), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + gameAtIndexReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `gameCount()` and selector `0x4d1975b4`. +```solidity +function gameCount() external view returns (uint256 gameCount_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCountCall; + ///Container type for the return parameters of the [`gameCount()`](gameCountCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCountReturn { + #[allow(missing_docs)] + pub gameCount_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCountCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCountCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCountReturn) -> Self { + (value.gameCount_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCountReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { gameCount_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameCountCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameCount()"; + const SELECTOR: [u8; 4] = [77u8, 25u8, 117u8, 180u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameCountReturn = r.into(); + r.gameCount_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameCountReturn = r.into(); + r.gameCount_ + }) + } + } + }; + /**Function with signature `gameImpls(uint32)` and selector `0x1b685b9e`. +```solidity +function gameImpls(GameType) external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameImplsCall(pub ::RustType); + ///Container type for the return parameters of the [`gameImpls(uint32)`](gameImplsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameImplsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameImplsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameImplsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameImplsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameImplsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameImplsCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameImpls(uint32)"; + const SELECTOR: [u8; 4] = [27u8, 104u8, 91u8, 158u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.0),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameImplsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameImplsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `games(uint32,bytes32,bytes)` and selector `0x5f0150cb`. +```solidity +function games(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external view returns (address proxy_, Timestamp timestamp_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gamesCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _rootClaim: ::RustType, + #[allow(missing_docs)] + pub _extraData: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`games(uint32,bytes32,bytes)`](gamesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gamesReturn { + #[allow(missing_docs)] + pub proxy_: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub timestamp_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gamesCall) -> Self { + (value._gameType, value._rootClaim, value._extraData) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gamesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _rootClaim: tuple.1, + _extraData: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + Timestamp, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gamesReturn) -> Self { + (value.proxy_, value.timestamp_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gamesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + proxy_: tuple.0, + timestamp_: tuple.1, + } + } + } + } + impl gamesReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize( + &self.proxy_, + ), + ::tokenize(&self.timestamp_), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gamesCall { + type Parameters<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = gamesReturn; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address, Timestamp); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "games(uint32,bytes32,bytes)"; + const SELECTOR: [u8; 4] = [95u8, 1u8, 80u8, 203u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize(&self._rootClaim), + ::tokenize( + &self._extraData, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + gamesReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `getGameUUID(uint32,bytes32,bytes)` and selector `0x96cd9720`. +```solidity +function getGameUUID(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external pure returns (Hash uuid_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getGameUUIDCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _rootClaim: ::RustType, + #[allow(missing_docs)] + pub _extraData: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`getGameUUID(uint32,bytes32,bytes)`](getGameUUIDCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getGameUUIDReturn { + #[allow(missing_docs)] + pub uuid_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getGameUUIDCall) -> Self { + (value._gameType, value._rootClaim, value._extraData) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getGameUUIDCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _rootClaim: tuple.1, + _extraData: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getGameUUIDReturn) -> Self { + (value.uuid_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getGameUUIDReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { uuid_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getGameUUIDCall { + type Parameters<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Hash,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getGameUUID(uint32,bytes32,bytes)"; + const SELECTOR: [u8; 4] = [150u8, 205u8, 151u8, 32u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize(&self._rootClaim), + ::tokenize( + &self._extraData, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getGameUUIDReturn = r.into(); + r.uuid_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getGameUUIDReturn = r.into(); + r.uuid_ + }) + } + } + }; + /**Function with signature `initBonds(uint32)` and selector `0x6593dc6e`. +```solidity +function initBonds(GameType) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initBondsCall(pub ::RustType); + ///Container type for the return parameters of the [`initBonds(uint32)`](initBondsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initBondsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initBondsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initBondsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initBondsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initBondsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initBondsCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initBonds(uint32)"; + const SELECTOR: [u8; 4] = [101u8, 147u8, 220u8, 110u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.0),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: initBondsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: initBondsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initVersion()` and selector `0x38d38c97`. +```solidity +function initVersion() external view returns (uint8); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionCall; + ///Container type for the return parameters of the [`initVersion()`](initVersionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionReturn { + #[allow(missing_docs)] + pub _0: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u8,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initVersionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initVersion()"; + const SELECTOR: [u8; 4] = [56u8, 211u8, 140u8, 151u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initialize(address)` and selector `0xc4d66de8`. +```solidity +function initialize(address _owner) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall { + #[allow(missing_docs)] + pub _owner: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`initialize(address)`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + (value._owner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _owner: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize(address)"; + const SELECTOR: [u8; 4] = [196u8, 214u8, 109u8, 232u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._owner, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `owner()` and selector `0x8da5cb5b`. +```solidity +function owner() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ownerCall; + ///Container type for the return parameters of the [`owner()`](ownerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ownerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdmin()` and selector `0x3e47158c`. +```solidity +function proxyAdmin() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminCall; + ///Container type for the return parameters of the [`proxyAdmin()`](proxyAdminCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdmin()"; + const SELECTOR: [u8; 4] = [62u8, 71u8, 21u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdminOwner()` and selector `0xdad544e0`. +```solidity +function proxyAdminOwner() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerCall; + ///Container type for the return parameters of the [`proxyAdminOwner()`](proxyAdminOwnerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminOwnerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proxyAdminOwnerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminOwnerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdminOwner()"; + const SELECTOR: [u8; 4] = [218u8, 213u8, 68u8, 224u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `renounceOwnership()` and selector `0x715018a6`. +```solidity +function renounceOwnership() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct renounceOwnershipCall; + ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct renounceOwnershipReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl renounceOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for renounceOwnershipCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = renounceOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "renounceOwnership()"; + const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + renounceOwnershipReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setImplementation(uint32,address)` and selector `0x14f6b1a3`. +```solidity +function setImplementation(GameType _gameType, address _impl) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setImplementation_0Call { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _impl: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`setImplementation(uint32,address)`](setImplementation_0Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setImplementation_0Return {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setImplementation_0Call) -> Self { + (value._gameType, value._impl) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setImplementation_0Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _impl: tuple.1, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setImplementation_0Return) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setImplementation_0Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setImplementation_0Return { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setImplementation_0Call { + type Parameters<'a> = (GameType, alloy::sol_types::sol_data::Address); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setImplementation_0Return; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setImplementation(uint32,address)"; + const SELECTOR: [u8; 4] = [20u8, 246u8, 177u8, 163u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize( + &self._impl, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setImplementation_0Return::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setImplementation(uint32,address,bytes)` and selector `0xb1070957`. +```solidity +function setImplementation(GameType _gameType, address _impl, bytes memory _args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setImplementation_1Call { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _impl: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _args: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`setImplementation(uint32,address,bytes)`](setImplementation_1Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setImplementation_1Return {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::Address, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setImplementation_1Call) -> Self { + (value._gameType, value._impl, value._args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setImplementation_1Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _impl: tuple.1, + _args: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setImplementation_1Return) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setImplementation_1Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setImplementation_1Return { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setImplementation_1Call { + type Parameters<'a> = ( + GameType, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bytes, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setImplementation_1Return; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setImplementation(uint32,address,bytes)"; + const SELECTOR: [u8; 4] = [177u8, 7u8, 9u8, 87u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize( + &self._impl, + ), + ::tokenize( + &self._args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setImplementation_1Return::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setInitBond(uint32,uint256)` and selector `0x1e334240`. +```solidity +function setInitBond(GameType _gameType, uint256 _initBond) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setInitBondCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _initBond: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`setInitBond(uint32,uint256)`](setInitBondCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setInitBondReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setInitBondCall) -> Self { + (value._gameType, value._initBond) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setInitBondCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _initBond: tuple.1, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setInitBondReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setInitBondReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setInitBondReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setInitBondCall { + type Parameters<'a> = (GameType, alloy::sol_types::sol_data::Uint<256>); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setInitBondReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setInitBond(uint32,uint256)"; + const SELECTOR: [u8; 4] = [30u8, 51u8, 66u8, 64u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + as alloy_sol_types::SolType>::tokenize(&self._initBond), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setInitBondReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`. +```solidity +function transferOwnership(address newOwner) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct transferOwnershipCall { + #[allow(missing_docs)] + pub newOwner: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct transferOwnershipReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value.newOwner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newOwner: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.newOwner, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + transferOwnershipReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `version()` and selector `0x54fd4d50`. +```solidity +function version() external view returns (string memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionCall; + ///Container type for the return parameters of the [`version()`](versionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for versionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "version()"; + const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`DisputeGameFactory`](self) function calls. + #[derive(Clone)] + pub enum DisputeGameFactoryCalls { + #[allow(missing_docs)] + create(createCall), + #[allow(missing_docs)] + findLatestGames(findLatestGamesCall), + #[allow(missing_docs)] + gameArgs(gameArgsCall), + #[allow(missing_docs)] + gameAtIndex(gameAtIndexCall), + #[allow(missing_docs)] + gameCount(gameCountCall), + #[allow(missing_docs)] + gameImpls(gameImplsCall), + #[allow(missing_docs)] + games(gamesCall), + #[allow(missing_docs)] + getGameUUID(getGameUUIDCall), + #[allow(missing_docs)] + initBonds(initBondsCall), + #[allow(missing_docs)] + initVersion(initVersionCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + owner(ownerCall), + #[allow(missing_docs)] + proxyAdmin(proxyAdminCall), + #[allow(missing_docs)] + proxyAdminOwner(proxyAdminOwnerCall), + #[allow(missing_docs)] + renounceOwnership(renounceOwnershipCall), + #[allow(missing_docs)] + setImplementation_0(setImplementation_0Call), + #[allow(missing_docs)] + setImplementation_1(setImplementation_1Call), + #[allow(missing_docs)] + setInitBond(setInitBondCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + #[allow(missing_docs)] + version(versionCall), + } + impl DisputeGameFactoryCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [20u8, 246u8, 177u8, 163u8], + [27u8, 104u8, 91u8, 158u8], + [30u8, 51u8, 66u8, 64u8], + [37u8, 75u8, 214u8, 131u8], + [56u8, 211u8, 140u8, 151u8], + [62u8, 71u8, 21u8, 140u8], + [77u8, 25u8, 117u8, 180u8], + [84u8, 253u8, 77u8, 80u8], + [95u8, 1u8, 80u8, 203u8], + [101u8, 147u8, 220u8, 110u8], + [113u8, 80u8, 24u8, 166u8], + [116u8, 204u8, 134u8, 172u8], + [130u8, 236u8, 242u8, 246u8], + [141u8, 165u8, 203u8, 91u8], + [150u8, 205u8, 151u8, 32u8], + [177u8, 7u8, 9u8, 87u8], + [187u8, 138u8, 161u8, 252u8], + [196u8, 214u8, 109u8, 232u8], + [218u8, 213u8, 68u8, 224u8], + [242u8, 253u8, 227u8, 139u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(setImplementation_0), + ::core::stringify!(gameImpls), + ::core::stringify!(setInitBond), + ::core::stringify!(findLatestGames), + ::core::stringify!(initVersion), + ::core::stringify!(proxyAdmin), + ::core::stringify!(gameCount), + ::core::stringify!(version), + ::core::stringify!(games), + ::core::stringify!(initBonds), + ::core::stringify!(renounceOwnership), + ::core::stringify!(gameArgs), + ::core::stringify!(create), + ::core::stringify!(owner), + ::core::stringify!(getGameUUID), + ::core::stringify!(setImplementation_1), + ::core::stringify!(gameAtIndex), + ::core::stringify!(initialize), + ::core::stringify!(proxyAdminOwner), + ::core::stringify!(transferOwnership), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DisputeGameFactoryCalls { + const NAME: &'static str = "DisputeGameFactoryCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 20usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::create(_) => ::SELECTOR, + Self::findLatestGames(_) => { + ::SELECTOR + } + Self::gameArgs(_) => ::SELECTOR, + Self::gameAtIndex(_) => { + ::SELECTOR + } + Self::gameCount(_) => { + ::SELECTOR + } + Self::gameImpls(_) => { + ::SELECTOR + } + Self::games(_) => ::SELECTOR, + Self::getGameUUID(_) => { + ::SELECTOR + } + Self::initBonds(_) => { + ::SELECTOR + } + Self::initVersion(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } + Self::owner(_) => ::SELECTOR, + Self::proxyAdmin(_) => { + ::SELECTOR + } + Self::proxyAdminOwner(_) => { + ::SELECTOR + } + Self::renounceOwnership(_) => { + ::SELECTOR + } + Self::setImplementation_0(_) => { + ::SELECTOR + } + Self::setImplementation_1(_) => { + ::SELECTOR + } + Self::setInitBond(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::SELECTOR + } + Self::version(_) => ::SELECTOR, + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setImplementation_0( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::setImplementation_0) + } + setImplementation_0 + }, + { + fn gameImpls( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DisputeGameFactoryCalls::gameImpls) + } + gameImpls + }, + { + fn setInitBond( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::setInitBond) + } + setInitBond + }, + { + fn findLatestGames( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::findLatestGames) + } + findLatestGames + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::initVersion) + } + initVersion + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn gameCount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DisputeGameFactoryCalls::gameCount) + } + gameCount + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DisputeGameFactoryCalls::version) + } + version + }, + { + fn games( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DisputeGameFactoryCalls::games) + } + games + }, + { + fn initBonds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DisputeGameFactoryCalls::initBonds) + } + initBonds + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn gameArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DisputeGameFactoryCalls::gameArgs) + } + gameArgs + }, + { + fn create( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DisputeGameFactoryCalls::create) + } + create + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DisputeGameFactoryCalls::owner) + } + owner + }, + { + fn getGameUUID( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::getGameUUID) + } + getGameUUID + }, + { + fn setImplementation_1( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::setImplementation_1) + } + setImplementation_1 + }, + { + fn gameAtIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::gameAtIndex) + } + gameAtIndex + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::initialize) + } + initialize + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setImplementation_0( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::setImplementation_0) + } + setImplementation_0 + }, + { + fn gameImpls( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::gameImpls) + } + gameImpls + }, + { + fn setInitBond( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::setInitBond) + } + setInitBond + }, + { + fn findLatestGames( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::findLatestGames) + } + findLatestGames + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::initVersion) + } + initVersion + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn gameCount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::gameCount) + } + gameCount + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::version) + } + version + }, + { + fn games( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::games) + } + games + }, + { + fn initBonds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::initBonds) + } + initBonds + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn gameArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::gameArgs) + } + gameArgs + }, + { + fn create( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::create) + } + create + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::owner) + } + owner + }, + { + fn getGameUUID( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::getGameUUID) + } + getGameUUID + }, + { + fn setImplementation_1( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::setImplementation_1) + } + setImplementation_1 + }, + { + fn gameAtIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::gameAtIndex) + } + gameAtIndex + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::initialize) + } + initialize + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::create(inner) => { + ::abi_encoded_size(inner) + } + Self::findLatestGames(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::gameArgs(inner) => { + ::abi_encoded_size(inner) + } + Self::gameAtIndex(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::gameCount(inner) => { + ::abi_encoded_size(inner) + } + Self::gameImpls(inner) => { + ::abi_encoded_size(inner) + } + Self::games(inner) => { + ::abi_encoded_size(inner) + } + Self::getGameUUID(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initBonds(inner) => { + ::abi_encoded_size(inner) + } + Self::initVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdmin(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::renounceOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setImplementation_0(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setImplementation_1(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setInitBond(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::version(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::create(inner) => { + ::abi_encode_raw(inner, out) + } + Self::findLatestGames(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameAtIndex(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameCount(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameImpls(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::games(inner) => { + ::abi_encode_raw(inner, out) + } + Self::getGameUUID(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initBonds(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::proxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::renounceOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setImplementation_0(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setImplementation_1(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setInitBond(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::version(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`DisputeGameFactory`](self) custom errors. + #[derive(Clone)] + pub enum DisputeGameFactoryErrors { + #[allow(missing_docs)] + GameAlreadyExists(GameAlreadyExists), + #[allow(missing_docs)] + IncorrectBondAmount(IncorrectBondAmount), + #[allow(missing_docs)] + NoImplementation(NoImplementation), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdmin(ProxyAdminOwnedBase_NotProxyAdmin), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOwner(ProxyAdminOwnedBase_NotProxyAdminOwner), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotResolvedDelegateProxy( + ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_ProxyAdminNotFound(ProxyAdminOwnedBase_ProxyAdminNotFound), + #[allow(missing_docs)] + ReinitializableBase_ZeroInitVersion(ReinitializableBase_ZeroInitVersion), + } + impl DisputeGameFactoryErrors { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [1u8, 79u8, 111u8, 229u8], + [3u8, 28u8, 109u8, 228u8], + [7u8, 92u8, 67u8, 20u8], + [51u8, 33u8, 68u8, 219u8], + [84u8, 228u8, 51u8, 205u8], + [127u8, 18u8, 198u8, 75u8], + [134u8, 32u8, 170u8, 25u8], + [155u8, 1u8, 175u8, 237u8], + [196u8, 5u8, 10u8, 38u8], + [232u8, 24u8, 220u8, 195u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(GameAlreadyExists), + ::core::stringify!(NoImplementation), + ::core::stringify!(ProxyAdminOwnedBase_NotSharedProxyAdminOwner), + ::core::stringify!(ProxyAdminOwnedBase_ProxyAdminNotFound), + ::core::stringify!(ProxyAdminOwnedBase_NotResolvedDelegateProxy), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOwner), + ::core::stringify!(IncorrectBondAmount), + ::core::stringify!(ReinitializableBase_ZeroInitVersion), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdmin), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DisputeGameFactoryErrors { + const NAME: &'static str = "DisputeGameFactoryErrors"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 10usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::GameAlreadyExists(_) => { + ::SELECTOR + } + Self::IncorrectBondAmount(_) => { + ::SELECTOR + } + Self::NoImplementation(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(_) => { + ::SELECTOR + } + Self::ReinitializableBase_ZeroInitVersion(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn GameAlreadyExists( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryErrors::GameAlreadyExists) + } + GameAlreadyExists + }, + { + fn NoImplementation( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryErrors::NoImplementation) + } + NoImplementation + }, + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn IncorrectBondAmount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DisputeGameFactoryErrors::IncorrectBondAmount) + } + IncorrectBondAmount + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + DisputeGameFactoryErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn GameAlreadyExists( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryErrors::GameAlreadyExists) + } + GameAlreadyExists + }, + { + fn NoImplementation( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryErrors::NoImplementation) + } + NoImplementation + }, + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn IncorrectBondAmount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DisputeGameFactoryErrors::IncorrectBondAmount) + } + IncorrectBondAmount + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + DisputeGameFactoryErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + DisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::GameAlreadyExists(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::IncorrectBondAmount(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::NoImplementation(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::GameAlreadyExists(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::IncorrectBondAmount(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::NoImplementation(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`DisputeGameFactory`](self) events. + #[derive(Clone)] + pub enum DisputeGameFactoryEvents { + #[allow(missing_docs)] + DisputeGameCreated(DisputeGameCreated), + #[allow(missing_docs)] + ImplementationArgsSet(ImplementationArgsSet), + #[allow(missing_docs)] + ImplementationSet(ImplementationSet), + #[allow(missing_docs)] + InitBondUpdated(InitBondUpdated), + #[allow(missing_docs)] + Initialized(Initialized), + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + } + impl DisputeGameFactoryEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 91u8, 86u8, 94u8, 254u8, 130u8, 65u8, 29u8, 169u8, 136u8, 20u8, 243u8, + 86u8, 208u8, 231u8, 188u8, 184u8, 240u8, 33u8, 155u8, 141u8, 151u8, 3u8, + 7u8, 197u8, 175u8, 180u8, 166u8, 144u8, 58u8, 139u8, 46u8, 53u8, + ], + [ + 116u8, 214u8, 102u8, 92u8, 75u8, 38u8, 213u8, 89u8, 106u8, 90u8, 161u8, + 61u8, 48u8, 20u8, 224u8, 192u8, 106u8, 244u8, 211u8, 34u8, 7u8, 90u8, + 121u8, 127u8, 135u8, 176u8, 60u8, 212u8, 197u8, 188u8, 145u8, 202u8, + ], + [ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ], + [ + 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, + 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, + 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + ], + [ + 164u8, 127u8, 205u8, 240u8, 117u8, 214u8, 128u8, 211u8, 129u8, 123u8, + 252u8, 167u8, 151u8, 59u8, 55u8, 62u8, 26u8, 95u8, 108u8, 252u8, 59u8, + 68u8, 71u8, 72u8, 41u8, 156u8, 194u8, 184u8, 61u8, 131u8, 72u8, 249u8, + ], + [ + 255u8, 81u8, 61u8, 128u8, 226u8, 199u8, 250u8, 72u8, 118u8, 8u8, 247u8, + 10u8, 97u8, 141u8, 251u8, 192u8, 207u8, 65u8, 86u8, 153u8, 220u8, 105u8, + 88u8, 140u8, 116u8, 126u8, 140u8, 113u8, 86u8, 108u8, 136u8, 222u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(DisputeGameCreated), + ::core::stringify!(InitBondUpdated), + ::core::stringify!(Initialized), + ::core::stringify!(OwnershipTransferred), + ::core::stringify!(ImplementationArgsSet), + ::core::stringify!(ImplementationSet), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for DisputeGameFactoryEvents { + const NAME: &'static str = "DisputeGameFactoryEvents"; + const COUNT: usize = 6usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::DisputeGameCreated) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ImplementationArgsSet) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ImplementationSet) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::InitBondUpdated) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::Initialized) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for DisputeGameFactoryEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::DisputeGameCreated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::ImplementationArgsSet(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::ImplementationSet(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::InitBondUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::DisputeGameCreated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::ImplementationArgsSet(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::ImplementationSet(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::InitBondUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`DisputeGameFactory`](self) contract instance. + +See the [wrapper's documentation](`DisputeGameFactoryInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> DisputeGameFactoryInstance { + DisputeGameFactoryInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DisputeGameFactoryInstance::::deploy(__provider) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(__provider: P) -> alloy_contract::RawCallBuilder { + DisputeGameFactoryInstance::::deploy_builder(__provider) + } + /**A [`DisputeGameFactory`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DisputeGameFactory`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct DisputeGameFactoryInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DisputeGameFactoryInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DisputeGameFactoryInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DisputeGameFactoryInstance { + /**Creates a new wrapper around an on-chain [`DisputeGameFactory`](self) contract instance. + +See the [wrapper's documentation](`DisputeGameFactoryInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + ::core::clone::Clone::clone(&BYTECODE), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl DisputeGameFactoryInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> DisputeGameFactoryInstance { + DisputeGameFactoryInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DisputeGameFactoryInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`create`] function. + pub fn create( + &self, + _gameType: ::RustType, + _rootClaim: ::RustType, + _extraData: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, createCall, N> { + self.call_builder( + &createCall { + _gameType, + _rootClaim, + _extraData, + }, + ) + } + ///Creates a new call builder for the [`findLatestGames`] function. + pub fn findLatestGames( + &self, + _gameType: ::RustType, + _start: alloy::sol_types::private::primitives::aliases::U256, + _n: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, findLatestGamesCall, N> { + self.call_builder( + &findLatestGamesCall { + _gameType, + _start, + _n, + }, + ) + } + ///Creates a new call builder for the [`gameArgs`] function. + pub fn gameArgs( + &self, + _0: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, gameArgsCall, N> { + self.call_builder(&gameArgsCall(_0)) + } + ///Creates a new call builder for the [`gameAtIndex`] function. + pub fn gameAtIndex( + &self, + _index: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, gameAtIndexCall, N> { + self.call_builder(&gameAtIndexCall { _index }) + } + ///Creates a new call builder for the [`gameCount`] function. + pub fn gameCount(&self) -> alloy_contract::SolCallBuilder<&P, gameCountCall, N> { + self.call_builder(&gameCountCall) + } + ///Creates a new call builder for the [`gameImpls`] function. + pub fn gameImpls( + &self, + _0: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, gameImplsCall, N> { + self.call_builder(&gameImplsCall(_0)) + } + ///Creates a new call builder for the [`games`] function. + pub fn games( + &self, + _gameType: ::RustType, + _rootClaim: ::RustType, + _extraData: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, gamesCall, N> { + self.call_builder( + &gamesCall { + _gameType, + _rootClaim, + _extraData, + }, + ) + } + ///Creates a new call builder for the [`getGameUUID`] function. + pub fn getGameUUID( + &self, + _gameType: ::RustType, + _rootClaim: ::RustType, + _extraData: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, getGameUUIDCall, N> { + self.call_builder( + &getGameUUIDCall { + _gameType, + _rootClaim, + _extraData, + }, + ) + } + ///Creates a new call builder for the [`initBonds`] function. + pub fn initBonds( + &self, + _0: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, initBondsCall, N> { + self.call_builder(&initBondsCall(_0)) + } + ///Creates a new call builder for the [`initVersion`] function. + pub fn initVersion( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initVersionCall, N> { + self.call_builder(&initVersionCall) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + _owner: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder(&initializeCall { _owner }) + } + ///Creates a new call builder for the [`owner`] function. + pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> { + self.call_builder(&ownerCall) + } + ///Creates a new call builder for the [`proxyAdmin`] function. + pub fn proxyAdmin( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminCall, N> { + self.call_builder(&proxyAdminCall) + } + ///Creates a new call builder for the [`proxyAdminOwner`] function. + pub fn proxyAdminOwner( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminOwnerCall, N> { + self.call_builder(&proxyAdminOwnerCall) + } + ///Creates a new call builder for the [`renounceOwnership`] function. + pub fn renounceOwnership( + &self, + ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> { + self.call_builder(&renounceOwnershipCall) + } + ///Creates a new call builder for the [`setImplementation_0`] function. + pub fn setImplementation_0( + &self, + _gameType: ::RustType, + _impl: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, setImplementation_0Call, N> { + self.call_builder( + &setImplementation_0Call { + _gameType, + _impl, + }, + ) + } + ///Creates a new call builder for the [`setImplementation_1`] function. + pub fn setImplementation_1( + &self, + _gameType: ::RustType, + _impl: alloy::sol_types::private::Address, + _args: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, setImplementation_1Call, N> { + self.call_builder( + &setImplementation_1Call { + _gameType, + _impl, + _args, + }, + ) + } + ///Creates a new call builder for the [`setInitBond`] function. + pub fn setInitBond( + &self, + _gameType: ::RustType, + _initBond: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, setInitBondCall, N> { + self.call_builder( + &setInitBondCall { + _gameType, + _initBond, + }, + ) + } + ///Creates a new call builder for the [`transferOwnership`] function. + pub fn transferOwnership( + &self, + newOwner: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> { + self.call_builder(&transferOwnershipCall { newOwner }) + } + ///Creates a new call builder for the [`version`] function. + pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> { + self.call_builder(&versionCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DisputeGameFactoryInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`DisputeGameCreated`] event. + pub fn DisputeGameCreated_filter( + &self, + ) -> alloy_contract::Event<&P, DisputeGameCreated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`ImplementationArgsSet`] event. + pub fn ImplementationArgsSet_filter( + &self, + ) -> alloy_contract::Event<&P, ImplementationArgsSet, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`ImplementationSet`] event. + pub fn ImplementationSet_filter( + &self, + ) -> alloy_contract::Event<&P, ImplementationSet, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`InitBondUpdated`] event. + pub fn InitBondUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, InitBondUpdated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Initialized`] event. + pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/erc1967_proxy.rs b/bindings/src/codegen/erc1967_proxy.rs new file mode 100644 index 000000000..7784e4831 --- /dev/null +++ b/bindings/src/codegen/erc1967_proxy.rs @@ -0,0 +1,872 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ERC1967Proxy { + event AdminChanged(address previousAdmin, address newAdmin); + event BeaconUpgraded(address indexed beacon); + event Upgraded(address indexed implementation); + + constructor(address _logic, bytes _data) payable; + + fallback() external payable; + + receive() external payable; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_logic", + "type": "address", + "internalType": "address" + }, + { + "name": "_data", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "payable" + }, + { + "type": "fallback", + "stateMutability": "payable" + }, + { + "type": "receive", + "stateMutability": "payable" + }, + { + "type": "event", + "name": "AdminChanged", + "inputs": [ + { + "name": "previousAdmin", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "newAdmin", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "BeaconUpgraded", + "inputs": [ + { + "name": "beacon", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Upgraded", + "inputs": [ + { + "name": "implementation", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod ERC1967Proxy { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R`@Qb\0\x0Cy8\x03\x80b\0\x0Cy\x839\x81\x81\x01`@R\x81\x01\x90b\0\0)\x91\x90b\0\x05jV[b\0\0=\x82\x82`\0b\0\0E` \x1B` \x1CV[PPb\0\x07\xE7V[b\0\0V\x83b\0\0\x88` \x1B` \x1CV[`\0\x82Q\x11\x80b\0\0dWP\x80[\x15b\0\0\x83Wb\0\0\x81\x83\x83b\0\0\xDF` \x1Bb\0\x007\x17` \x1CV[P[PPPV[b\0\0\x99\x81b\0\x01\x15` \x1B` \x1CV[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;`@Q`@Q\x80\x91\x03\x90\xA2PV[``b\0\x01\r\x83\x83`@Q\x80``\x01`@R\x80`'\x81R` \x01b\0\x0CR`'\x919b\0\x01\xEB` \x1B` \x1CV[\x90P\x92\x91PPV[b\0\x01+\x81b\0\x02\xCF` \x1Bb\0\0d\x17` \x1CV[b\0\x01mW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01b\0\x01d\x90b\0\x06WV[`@Q\x80\x91\x03\x90\xFD[\x80b\0\x01\xA7\x7F6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC`\0\x1Bb\0\x02\xF2` \x1Bb\0\0\x87\x17` \x1CV[`\0\x01`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPV[``b\0\x01\xFE\x84b\0\x02\xCF` \x1B` \x1CV[b\0\x02@W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01b\0\x027\x90b\0\x06\xEFV[`@Q\x80\x91\x03\x90\xFD[`\0\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85`@Qb\0\x02j\x91\x90b\0\x07^V[`\0`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80`\0\x81\x14b\0\x02\xA7W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>b\0\x02\xACV[``\x91P[P\x91P\x91Pb\0\x02\xC4\x82\x82\x86b\0\x02\xFC` \x1B` \x1CV[\x92PPP\x93\x92PPPV[`\0\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16;\x11\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[``\x83\x15b\0\x03\x0EW\x82\x90Pb\0\x03aV[`\0\x83Q\x11\x15b\0\x03\"W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01b\0\x03X\x91\x90b\0\x07\xC3V[`@Q\x80\x91\x03\x90\xFD[\x93\x92PPPV[`\0`@Q\x90P\x90V[`\0\x80\xFD[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0b\0\x03\xA9\x82b\0\x03|V[\x90P\x91\x90PV[b\0\x03\xBB\x81b\0\x03\x9CV[\x81\x14b\0\x03\xC7W`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x03\xDB\x81b\0\x03\xB0V[\x92\x91PPV[`\0\x80\xFD[`\0\x80\xFD[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`A`\x04R`$`\0\xFD[b\0\x046\x82b\0\x03\xEBV[\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15b\0\x04XWb\0\x04Wb\0\x03\xFCV[[\x80`@RPPPV[`\0b\0\x04mb\0\x03hV[\x90Pb\0\x04{\x82\x82b\0\x04+V[\x91\x90PV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15b\0\x04\x9EWb\0\x04\x9Db\0\x03\xFCV[[b\0\x04\xA9\x82b\0\x03\xEBV[\x90P` \x81\x01\x90P\x91\x90PV[`\0[\x83\x81\x10\x15b\0\x04\xD6W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pb\0\x04\xB9V[\x83\x81\x11\x15b\0\x04\xE6W`\0\x84\x84\x01R[PPPPV[`\0b\0\x05\x03b\0\x04\xFD\x84b\0\x04\x80V[b\0\x04aV[\x90P\x82\x81R` \x81\x01\x84\x84\x84\x01\x11\x15b\0\x05\"Wb\0\x05!b\0\x03\xE6V[[b\0\x05/\x84\x82\x85b\0\x04\xB6V[P\x93\x92PPPV[`\0\x82`\x1F\x83\x01\x12b\0\x05OWb\0\x05Nb\0\x03\xE1V[[\x81Qb\0\x05a\x84\x82` \x86\x01b\0\x04\xECV[\x91PP\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15b\0\x05\x84Wb\0\x05\x83b\0\x03rV[[`\0b\0\x05\x94\x85\x82\x86\x01b\0\x03\xCAV[\x92PP` \x83\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15b\0\x05\xB8Wb\0\x05\xB7b\0\x03wV[[b\0\x05\xC6\x85\x82\x86\x01b\0\x057V[\x91PP\x92P\x92\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[\x7FERC1967: new implementation is n`\0\x82\x01R\x7Fot a contract\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0b\0\x06?`-\x83b\0\x05\xD0V[\x91Pb\0\x06L\x82b\0\x05\xE1V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Rb\0\x06r\x81b\0\x060V[\x90P\x91\x90PV[\x7FAddress: delegate call to non-co`\0\x82\x01R\x7Fntract\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0b\0\x06\xD7`&\x83b\0\x05\xD0V[\x91Pb\0\x06\xE4\x82b\0\x06yV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Rb\0\x07\n\x81b\0\x06\xC8V[\x90P\x91\x90PV[`\0\x81Q\x90P\x91\x90PV[`\0\x81\x90P\x92\x91PPV[`\0b\0\x074\x82b\0\x07\x11V[b\0\x07@\x81\x85b\0\x07\x1CV[\x93Pb\0\x07R\x81\x85` \x86\x01b\0\x04\xB6V[\x80\x84\x01\x91PP\x92\x91PPV[`\0b\0\x07l\x82\x84b\0\x07'V[\x91P\x81\x90P\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0b\0\x07\x8F\x82b\0\x07wV[b\0\x07\x9B\x81\x85b\0\x05\xD0V[\x93Pb\0\x07\xAD\x81\x85` \x86\x01b\0\x04\xB6V[b\0\x07\xB8\x81b\0\x03\xEBV[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Rb\0\x07\xDF\x81\x84b\0\x07\x82V[\x90P\x92\x91PPV[a\x04[\x80b\0\x07\xF7`\09`\0\xF3\xFE`\x80`@R6a\0\x13Wa\0\x11a\0\x1DV[\0[a\0\x1Ba\0\x1DV[\0[a\0%a\0\x91V[a\x005a\x000a\0\x93V[a\0\xA2V[V[``a\0\\\x83\x83`@Q\x80``\x01`@R\x80`'\x81R` \x01a\x03\xFF`'\x919a\0\xC8V[\x90P\x92\x91PPV[`\0\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16;\x11\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[V[`\0a\0\x9Da\x01\x95V[\x90P\x90V[6`\0\x807`\0\x806`\0\x84Z\xF4=`\0\x80>\x80`\0\x81\x14a\0\xC3W=`\0\xF3[=`\0\xFD[``a\0\xD3\x84a\0dV[a\x01\x12W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x01\t\x90a\x02\xD6V[`@Q\x80\x91\x03\x90\xFD[`\0\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85`@Qa\x01:\x91\x90a\x03pV[`\0`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80`\0\x81\x14a\x01uW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x01zV[``\x91P[P\x91P\x91Pa\x01\x8A\x82\x82\x86a\x01\xECV[\x92PPP\x93\x92PPPV[`\0a\x01\xC3\x7F6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC`\0\x1Ba\0\x87V[`\0\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x90V[``\x83\x15a\x01\xFCW\x82\x90Pa\x02LV[`\0\x83Q\x11\x15a\x02\x0FW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x02C\x91\x90a\x03\xDCV[`@Q\x80\x91\x03\x90\xFD[\x93\x92PPPV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[\x7FAddress: delegate call to non-co`\0\x82\x01R\x7Fntract\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a\x02\xC0`&\x83a\x02SV[\x91Pa\x02\xCB\x82a\x02dV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x02\xEF\x81a\x02\xB3V[\x90P\x91\x90PV[`\0\x81Q\x90P\x91\x90PV[`\0\x81\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x03*W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x03\x0FV[\x83\x81\x11\x15a\x039W`\0\x84\x84\x01R[PPPPV[`\0a\x03J\x82a\x02\xF6V[a\x03T\x81\x85a\x03\x01V[\x93Pa\x03d\x81\x85` \x86\x01a\x03\x0CV[\x80\x84\x01\x91PP\x92\x91PPV[`\0a\x03|\x82\x84a\x03?V[\x91P\x81\x90P\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x03\xAE\x82a\x03\x87V[a\x03\xB8\x81\x85a\x02SV[\x93Pa\x03\xC8\x81\x85` \x86\x01a\x03\x0CV[a\x03\xD1\x81a\x03\x92V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x03\xF6\x81\x84a\x03\xA3V[\x90P\x92\x91PPV\xFEAddress: low-level delegate call failed\xA2dipfsX\"\x12 \xD0\xA4\x83\xFA\xCCP\xF9\x0B\t\xC5<\x0E\xE8 \x9B\xFB\xEFP_@\xB3\xEE0!\xED\xDEDa\xCDk*fdsolcC\0\x08\x0F\x003Address: low-level delegate call failed", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R6a\0\x13Wa\0\x11a\0\x1DV[\0[a\0\x1Ba\0\x1DV[\0[a\0%a\0\x91V[a\x005a\x000a\0\x93V[a\0\xA2V[V[``a\0\\\x83\x83`@Q\x80``\x01`@R\x80`'\x81R` \x01a\x03\xFF`'\x919a\0\xC8V[\x90P\x92\x91PPV[`\0\x80\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16;\x11\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[V[`\0a\0\x9Da\x01\x95V[\x90P\x90V[6`\0\x807`\0\x806`\0\x84Z\xF4=`\0\x80>\x80`\0\x81\x14a\0\xC3W=`\0\xF3[=`\0\xFD[``a\0\xD3\x84a\0dV[a\x01\x12W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x01\t\x90a\x02\xD6V[`@Q\x80\x91\x03\x90\xFD[`\0\x80\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x85`@Qa\x01:\x91\x90a\x03pV[`\0`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80`\0\x81\x14a\x01uW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x01zV[``\x91P[P\x91P\x91Pa\x01\x8A\x82\x82\x86a\x01\xECV[\x92PPP\x93\x92PPPV[`\0a\x01\xC3\x7F6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC`\0\x1Ba\0\x87V[`\0\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x90V[``\x83\x15a\x01\xFCW\x82\x90Pa\x02LV[`\0\x83Q\x11\x15a\x02\x0FW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x02C\x91\x90a\x03\xDCV[`@Q\x80\x91\x03\x90\xFD[\x93\x92PPPV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[\x7FAddress: delegate call to non-co`\0\x82\x01R\x7Fntract\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a\x02\xC0`&\x83a\x02SV[\x91Pa\x02\xCB\x82a\x02dV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x02\xEF\x81a\x02\xB3V[\x90P\x91\x90PV[`\0\x81Q\x90P\x91\x90PV[`\0\x81\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x03*W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x03\x0FV[\x83\x81\x11\x15a\x039W`\0\x84\x84\x01R[PPPPV[`\0a\x03J\x82a\x02\xF6V[a\x03T\x81\x85a\x03\x01V[\x93Pa\x03d\x81\x85` \x86\x01a\x03\x0CV[\x80\x84\x01\x91PP\x92\x91PPV[`\0a\x03|\x82\x84a\x03?V[\x91P\x81\x90P\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x03\xAE\x82a\x03\x87V[a\x03\xB8\x81\x85a\x02SV[\x93Pa\x03\xC8\x81\x85` \x86\x01a\x03\x0CV[a\x03\xD1\x81a\x03\x92V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x03\xF6\x81\x84a\x03\xA3V[\x90P\x92\x91PPV\xFEAddress: low-level delegate call failed\xA2dipfsX\"\x12 \xD0\xA4\x83\xFA\xCCP\xF9\x0B\t\xC5<\x0E\xE8 \x9B\xFB\xEFP_@\xB3\xEE0!\xED\xDEDa\xCDk*fdsolcC\0\x08\x0F\x003", + ); + /**Event with signature `AdminChanged(address,address)` and selector `0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f`. +```solidity +event AdminChanged(address previousAdmin, address newAdmin); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct AdminChanged { + #[allow(missing_docs)] + pub previousAdmin: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub newAdmin: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for AdminChanged { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "AdminChanged(address,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 126u8, 100u8, 77u8, 121u8, 66u8, 47u8, 23u8, 192u8, 30u8, 72u8, 148u8, + 181u8, 244u8, 245u8, 136u8, 211u8, 49u8, 235u8, 250u8, 40u8, 101u8, 61u8, + 66u8, 174u8, 131u8, 45u8, 197u8, 158u8, 56u8, 201u8, 121u8, 143u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousAdmin: data.0, + newAdmin: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.previousAdmin, + ), + ::tokenize( + &self.newAdmin, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for AdminChanged { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&AdminChanged> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &AdminChanged) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `BeaconUpgraded(address)` and selector `0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e`. +```solidity +event BeaconUpgraded(address indexed beacon); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct BeaconUpgraded { + #[allow(missing_docs)] + pub beacon: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for BeaconUpgraded { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "BeaconUpgraded(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 28u8, 243u8, 176u8, 58u8, 108u8, 241u8, 159u8, 162u8, 186u8, 186u8, 77u8, + 241u8, 72u8, 233u8, 220u8, 171u8, 237u8, 234u8, 127u8, 138u8, 92u8, 7u8, + 132u8, 14u8, 32u8, 126u8, 92u8, 8u8, 155u8, 233u8, 93u8, 62u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { beacon: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.beacon.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.beacon, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for BeaconUpgraded { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&BeaconUpgraded> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &BeaconUpgraded) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Upgraded(address)` and selector `0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b`. +```solidity +event Upgraded(address indexed implementation); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Upgraded { + #[allow(missing_docs)] + pub implementation: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Upgraded { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "Upgraded(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, + 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, + 12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { implementation: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.implementation.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.implementation, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Upgraded { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Upgraded> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Upgraded) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _logic, bytes _data) payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _logic: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _data: alloy::sol_types::private::Bytes, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._logic, value._data) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _logic: tuple.0, + _data: tuple.1, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bytes, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._logic, + ), + ::tokenize( + &self._data, + ), + ) + } + } + }; + ///Container for all the [`ERC1967Proxy`](self) events. + #[derive(Clone)] + pub enum ERC1967ProxyEvents { + #[allow(missing_docs)] + AdminChanged(AdminChanged), + #[allow(missing_docs)] + BeaconUpgraded(BeaconUpgraded), + #[allow(missing_docs)] + Upgraded(Upgraded), + } + impl ERC1967ProxyEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 28u8, 243u8, 176u8, 58u8, 108u8, 241u8, 159u8, 162u8, 186u8, 186u8, 77u8, + 241u8, 72u8, 233u8, 220u8, 171u8, 237u8, 234u8, 127u8, 138u8, 92u8, 7u8, + 132u8, 14u8, 32u8, 126u8, 92u8, 8u8, 155u8, 233u8, 93u8, 62u8, + ], + [ + 126u8, 100u8, 77u8, 121u8, 66u8, 47u8, 23u8, 192u8, 30u8, 72u8, 148u8, + 181u8, 244u8, 245u8, 136u8, 211u8, 49u8, 235u8, 250u8, 40u8, 101u8, 61u8, + 66u8, 174u8, 131u8, 45u8, 197u8, 158u8, 56u8, 201u8, 121u8, 143u8, + ], + [ + 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, + 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, + 12u8, 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(BeaconUpgraded), + ::core::stringify!(AdminChanged), + ::core::stringify!(Upgraded), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for ERC1967ProxyEvents { + const NAME: &'static str = "ERC1967ProxyEvents"; + const COUNT: usize = 3usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::AdminChanged) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::BeaconUpgraded) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Upgraded) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for ERC1967ProxyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::AdminChanged(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::BeaconUpgraded(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Upgraded(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::AdminChanged(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::BeaconUpgraded(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Upgraded(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ERC1967Proxy`](self) contract instance. + +See the [wrapper's documentation](`ERC1967ProxyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> ERC1967ProxyInstance { + ERC1967ProxyInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _logic: alloy::sol_types::private::Address, + _data: alloy::sol_types::private::Bytes, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ERC1967ProxyInstance::::deploy(__provider, _logic, _data) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _logic: alloy::sol_types::private::Address, + _data: alloy::sol_types::private::Bytes, + ) -> alloy_contract::RawCallBuilder { + ERC1967ProxyInstance::::deploy_builder(__provider, _logic, _data) + } + /**A [`ERC1967Proxy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ERC1967Proxy`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct ERC1967ProxyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ERC1967ProxyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ERC1967ProxyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC1967ProxyInstance { + /**Creates a new wrapper around an on-chain [`ERC1967Proxy`](self) contract instance. + +See the [wrapper's documentation](`ERC1967ProxyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + _logic: alloy::sol_types::private::Address, + _data: alloy::sol_types::private::Bytes, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider, _logic, _data); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder( + __provider: P, + _logic: alloy::sol_types::private::Address, + _data: alloy::sol_types::private::Bytes, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { _logic, _data }, + )[..], + ] + .concat() + .into(), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl ERC1967ProxyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ERC1967ProxyInstance { + ERC1967ProxyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC1967ProxyInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC1967ProxyInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`AdminChanged`] event. + pub fn AdminChanged_filter(&self) -> alloy_contract::Event<&P, AdminChanged, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`BeaconUpgraded`] event. + pub fn BeaconUpgraded_filter( + &self, + ) -> alloy_contract::Event<&P, BeaconUpgraded, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Upgraded`] event. + pub fn Upgraded_filter(&self) -> alloy_contract::Event<&P, Upgraded, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/i_anchor_state_registry.rs b/bindings/src/codegen/i_anchor_state_registry.rs new file mode 100644 index 000000000..be499f442 --- /dev/null +++ b/bindings/src/codegen/i_anchor_state_registry.rs @@ -0,0 +1,9009 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IAnchorStateRegistry { + type GameType is uint32; + type Hash is bytes32; + struct Proposal { + Hash root; + uint256 l2SequenceNumber; + } + + error AnchorStateRegistry_InvalidAnchorGame(); + error AnchorStateRegistry_Unauthorized(); + error ProxyAdminOwnedBase_NotProxyAdmin(); + error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); + error ProxyAdminOwnedBase_NotProxyAdminOwner(); + error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); + error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); + error ProxyAdminOwnedBase_ProxyAdminNotFound(); + error ReinitializableBase_ZeroInitVersion(); + + event AnchorUpdated(address indexed game); + event DisputeGameBlacklisted(address indexed disputeGame); + event Initialized(uint8 version); + event RespectedGameTypeSet(GameType gameType); + event RetirementTimestampSet(uint256 timestamp); + + function __constructor__(uint256 _disputeGameFinalityDelaySeconds) external; + function anchorGame() external view returns (address); + function anchors(GameType) external view returns (Hash, uint256); + function blacklistDisputeGame(address _disputeGame) external; + function disputeGameBlacklist(address) external view returns (bool); + function disputeGameFactory() external view returns (address); + function disputeGameFinalityDelaySeconds() external view returns (uint256); + function getAnchorRoot() external view returns (Hash, uint256); + function initVersion() external view returns (uint8); + function initialize(address _systemConfig, address _disputeGameFactory, Proposal memory _startingAnchorRoot, GameType _startingRespectedGameType) external; + function isGameBlacklisted(address _game) external view returns (bool); + function isGameClaimValid(address _game) external view returns (bool); + function isGameFinalized(address _game) external view returns (bool); + function isGameProper(address _game) external view returns (bool); + function isGameRegistered(address _game) external view returns (bool); + function isGameResolved(address _game) external view returns (bool); + function isGameRespected(address _game) external view returns (bool); + function isGameRetired(address _game) external view returns (bool); + function paused() external view returns (bool); + function proxyAdmin() external view returns (address); + function proxyAdminOwner() external view returns (address); + function respectedGameType() external view returns (GameType); + function retirementTimestamp() external view returns (uint64); + function setAnchorState(address _game) external; + function setRespectedGameType(GameType _gameType) external; + function superchainConfig() external view returns (address); + function systemConfig() external view returns (address); + function updateRetirementTimestamp() external; + function version() external view returns (string memory); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "__constructor__", + "inputs": [ + { + "name": "_disputeGameFinalityDelaySeconds", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "anchorGame", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IFaultDisputeGame" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "anchors", + "inputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "Hash" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "blacklistDisputeGame", + "inputs": [ + { + "name": "_disputeGame", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "disputeGameBlacklist", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "disputeGameFactory", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IDisputeGameFactory" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "disputeGameFinalityDelaySeconds", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getAnchorRoot", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "Hash" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initVersion", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [ + { + "name": "_systemConfig", + "type": "address", + "internalType": "contract ISystemConfig" + }, + { + "name": "_disputeGameFactory", + "type": "address", + "internalType": "contract IDisputeGameFactory" + }, + { + "name": "_startingAnchorRoot", + "type": "tuple", + "internalType": "struct Proposal", + "components": [ + { + "name": "root", + "type": "bytes32", + "internalType": "Hash" + }, + { + "name": "l2SequenceNumber", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_startingRespectedGameType", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "isGameBlacklisted", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameClaimValid", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameFinalized", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameProper", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameRegistered", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameResolved", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameRespected", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isGameRetired", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "paused", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdmin", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IProxyAdmin" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdminOwner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "respectedGameType", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "retirementTimestamp", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "uint64" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setAnchorState", + "inputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setRespectedGameType", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "superchainConfig", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISuperchainConfig" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "systemConfig", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISystemConfig" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "updateRetirementTimestamp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "AnchorUpdated", + "inputs": [ + { + "name": "game", + "type": "address", + "indexed": true, + "internalType": "contract IFaultDisputeGame" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "DisputeGameBlacklisted", + "inputs": [ + { + "name": "disputeGame", + "type": "address", + "indexed": true, + "internalType": "contract IDisputeGame" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Initialized", + "inputs": [ + { + "name": "version", + "type": "uint8", + "indexed": false, + "internalType": "uint8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "RespectedGameTypeSet", + "inputs": [ + { + "name": "gameType", + "type": "uint32", + "indexed": false, + "internalType": "GameType" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "RetirementTimestampSet", + "inputs": [ + { + "name": "timestamp", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "AnchorStateRegistry_InvalidAnchorGame", + "inputs": [] + }, + { + "type": "error", + "name": "AnchorStateRegistry_Unauthorized", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdmin", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotResolvedDelegateProxy", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotSharedProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_ProxyAdminNotFound", + "inputs": [] + }, + { + "type": "error", + "name": "ReinitializableBase_ZeroInitVersion", + "inputs": [] + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod IAnchorStateRegistry { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Hash(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Hash { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Hash { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Hash) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Hash { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Hash { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**```solidity +struct Proposal { Hash root; uint256 l2SequenceNumber; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Proposal { + #[allow(missing_docs)] + pub root: ::RustType, + #[allow(missing_docs)] + pub l2SequenceNumber: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: Proposal) -> Self { + (value.root, value.l2SequenceNumber) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for Proposal { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + root: tuple.0, + l2SequenceNumber: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for Proposal { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for Proposal { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize(&self.root), + as alloy_sol_types::SolType>::tokenize(&self.l2SequenceNumber), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Proposal { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for Proposal { + const NAME: &'static str = "Proposal"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "Proposal(bytes32 root,uint256 l2SequenceNumber)", + ) + } + #[inline] + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { + alloy_sol_types::private::Vec::new() + } + #[inline] + fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word(&self.root).0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.l2SequenceNumber, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Proposal { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.root, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.l2SequenceNumber, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.root, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.l2SequenceNumber, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + /**Custom error with signature `AnchorStateRegistry_InvalidAnchorGame()` and selector `0x47ad367a`. +```solidity +error AnchorStateRegistry_InvalidAnchorGame(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct AnchorStateRegistry_InvalidAnchorGame; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: AnchorStateRegistry_InvalidAnchorGame) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for AnchorStateRegistry_InvalidAnchorGame { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for AnchorStateRegistry_InvalidAnchorGame { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "AnchorStateRegistry_InvalidAnchorGame()"; + const SELECTOR: [u8; 4] = [71u8, 173u8, 54u8, 122u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `AnchorStateRegistry_Unauthorized()` and selector `0x2e5321ac`. +```solidity +error AnchorStateRegistry_Unauthorized(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct AnchorStateRegistry_Unauthorized; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: AnchorStateRegistry_Unauthorized) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for AnchorStateRegistry_Unauthorized { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for AnchorStateRegistry_Unauthorized { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "AnchorStateRegistry_Unauthorized()"; + const SELECTOR: [u8; 4] = [46u8, 83u8, 33u8, 172u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdmin()` and selector `0xe818dcc3`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdmin(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdmin; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdmin) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdmin { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdmin { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdmin()"; + const SELECTOR: [u8; 4] = [232u8, 24u8, 220u8, 195u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()` and selector `0xc4050a26`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [196u8, 5u8, 10u8, 38u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOwner()` and selector `0x7f12c64b`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [127u8, 18u8, 198u8, 75u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotResolvedDelegateProxy()` and selector `0x54e433cd`. +```solidity +error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotResolvedDelegateProxy; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotResolvedDelegateProxy) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotResolvedDelegateProxy()"; + const SELECTOR: [u8; 4] = [84u8, 228u8, 51u8, 205u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotSharedProxyAdminOwner()` and selector `0x075c4314`. +```solidity +error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotSharedProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotSharedProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotSharedProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [7u8, 92u8, 67u8, 20u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_ProxyAdminNotFound()` and selector `0x332144db`. +```solidity +error ProxyAdminOwnedBase_ProxyAdminNotFound(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_ProxyAdminNotFound; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_ProxyAdminNotFound) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_ProxyAdminNotFound { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_ProxyAdminNotFound { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_ProxyAdminNotFound()"; + const SELECTOR: [u8; 4] = [51u8, 33u8, 68u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ReinitializableBase_ZeroInitVersion()` and selector `0x9b01afed`. +```solidity +error ReinitializableBase_ZeroInitVersion(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ReinitializableBase_ZeroInitVersion; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ReinitializableBase_ZeroInitVersion) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ReinitializableBase_ZeroInitVersion { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ReinitializableBase_ZeroInitVersion { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ReinitializableBase_ZeroInitVersion()"; + const SELECTOR: [u8; 4] = [155u8, 1u8, 175u8, 237u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Event with signature `AnchorUpdated(address)` and selector `0x474f180d74ea8751955ee261c93ff8270411b180408d1014c49f552c92a4d11e`. +```solidity +event AnchorUpdated(address indexed game); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct AnchorUpdated { + #[allow(missing_docs)] + pub game: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for AnchorUpdated { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "AnchorUpdated(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 71u8, 79u8, 24u8, 13u8, 116u8, 234u8, 135u8, 81u8, 149u8, 94u8, 226u8, + 97u8, 201u8, 63u8, 248u8, 39u8, 4u8, 17u8, 177u8, 128u8, 64u8, 141u8, + 16u8, 20u8, 196u8, 159u8, 85u8, 44u8, 146u8, 164u8, 209u8, 30u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { game: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.game.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.game, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for AnchorUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&AnchorUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &AnchorUpdated) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `DisputeGameBlacklisted(address)` and selector `0x192c289026d59a41a27f5aea08f3969b57931b0589202d14f4368cded95d3cda`. +```solidity +event DisputeGameBlacklisted(address indexed disputeGame); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct DisputeGameBlacklisted { + #[allow(missing_docs)] + pub disputeGame: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for DisputeGameBlacklisted { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "DisputeGameBlacklisted(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 25u8, 44u8, 40u8, 144u8, 38u8, 213u8, 154u8, 65u8, 162u8, 127u8, 90u8, + 234u8, 8u8, 243u8, 150u8, 155u8, 87u8, 147u8, 27u8, 5u8, 137u8, 32u8, + 45u8, 20u8, 244u8, 54u8, 140u8, 222u8, 217u8, 93u8, 60u8, 218u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { disputeGame: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.disputeGame.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.disputeGame, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for DisputeGameBlacklisted { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&DisputeGameBlacklisted> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &DisputeGameBlacklisted) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`. +```solidity +event Initialized(uint8 version); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Initialized { + #[allow(missing_docs)] + pub version: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Initialized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Initialized(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { version: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Initialized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Initialized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Initialized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `RespectedGameTypeSet(uint32)` and selector `0xcee0703b5e4bad4efededab85c9fd1aec17dee7c5f6c584330e0509b677745a2`. +```solidity +event RespectedGameTypeSet(GameType gameType); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct RespectedGameTypeSet { + #[allow(missing_docs)] + pub gameType: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for RespectedGameTypeSet { + type DataTuple<'a> = (GameType,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "RespectedGameTypeSet(uint32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 206u8, 224u8, 112u8, 59u8, 94u8, 75u8, 173u8, 78u8, 254u8, 222u8, 218u8, + 184u8, 92u8, 159u8, 209u8, 174u8, 193u8, 125u8, 238u8, 124u8, 95u8, + 108u8, 88u8, 67u8, 48u8, 224u8, 80u8, 155u8, 103u8, 119u8, 69u8, 162u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { gameType: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + (::tokenize(&self.gameType),) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for RespectedGameTypeSet { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&RespectedGameTypeSet> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &RespectedGameTypeSet) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `RetirementTimestampSet(uint256)` and selector `0x6e5b1ba771e8e484f741ed085f039ff4e5c6e882eaf68f550fb390922d0ae4a7`. +```solidity +event RetirementTimestampSet(uint256 timestamp); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct RetirementTimestampSet { + #[allow(missing_docs)] + pub timestamp: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for RetirementTimestampSet { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "RetirementTimestampSet(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 110u8, 91u8, 27u8, 167u8, 113u8, 232u8, 228u8, 132u8, 247u8, 65u8, 237u8, + 8u8, 95u8, 3u8, 159u8, 244u8, 229u8, 198u8, 232u8, 130u8, 234u8, 246u8, + 143u8, 85u8, 15u8, 179u8, 144u8, 146u8, 45u8, 10u8, 228u8, 167u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { timestamp: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.timestamp), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for RetirementTimestampSet { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&RetirementTimestampSet> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &RetirementTimestampSet) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Function with signature `__constructor__(uint256)` and selector `0x41232a17`. +```solidity +function __constructor__(uint256 _disputeGameFinalityDelaySeconds) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct __constructor__Call { + #[allow(missing_docs)] + pub _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`__constructor__(uint256)`](__constructor__Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct __constructor__Return {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From<__constructor__Call> for UnderlyingRustTuple<'_> { + fn from(value: __constructor__Call) -> Self { + (value._disputeGameFinalityDelaySeconds,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for __constructor__Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _disputeGameFinalityDelaySeconds: tuple.0, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From<__constructor__Return> + for UnderlyingRustTuple<'_> { + fn from(value: __constructor__Return) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for __constructor__Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl __constructor__Return { + fn _tokenize( + &self, + ) -> <__constructor__Call as alloy_sol_types::SolCall>::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for __constructor__Call { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = __constructor__Return; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "__constructor__(uint256)"; + const SELECTOR: [u8; 4] = [65u8, 35u8, 42u8, 23u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize( + &self._disputeGameFinalityDelaySeconds, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + __constructor__Return::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `anchorGame()` and selector `0xe0a840eb`. +```solidity +function anchorGame() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorGameCall; + ///Container type for the return parameters of the [`anchorGame()`](anchorGameCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorGameReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: anchorGameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for anchorGameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: anchorGameReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for anchorGameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for anchorGameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "anchorGame()"; + const SELECTOR: [u8; 4] = [224u8, 168u8, 64u8, 235u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: anchorGameReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: anchorGameReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `anchors(uint32)` and selector `0x7258a807`. +```solidity +function anchors(GameType) external view returns (Hash, uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorsCall(pub ::RustType); + ///Container type for the return parameters of the [`anchors(uint32)`](anchorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorsReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + #[allow(missing_docs)] + pub _1: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: anchorsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for anchorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: anchorsReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for anchorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl anchorsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self._0), + as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for anchorsCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = anchorsReturn; + type ReturnTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "anchors(uint32)"; + const SELECTOR: [u8; 4] = [114u8, 88u8, 168u8, 7u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.0),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + anchorsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `blacklistDisputeGame(address)` and selector `0x7d6be8dc`. +```solidity +function blacklistDisputeGame(address _disputeGame) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct blacklistDisputeGameCall { + #[allow(missing_docs)] + pub _disputeGame: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`blacklistDisputeGame(address)`](blacklistDisputeGameCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct blacklistDisputeGameReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: blacklistDisputeGameCall) -> Self { + (value._disputeGame,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for blacklistDisputeGameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _disputeGame: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: blacklistDisputeGameReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for blacklistDisputeGameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl blacklistDisputeGameReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for blacklistDisputeGameCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = blacklistDisputeGameReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "blacklistDisputeGame(address)"; + const SELECTOR: [u8; 4] = [125u8, 107u8, 232u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._disputeGame, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + blacklistDisputeGameReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `disputeGameBlacklist(address)` and selector `0x45884d32`. +```solidity +function disputeGameBlacklist(address) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameBlacklistCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`disputeGameBlacklist(address)`](disputeGameBlacklistCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameBlacklistReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameBlacklistCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameBlacklistCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameBlacklistReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameBlacklistReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameBlacklistCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameBlacklist(address)"; + const SELECTOR: [u8; 4] = [69u8, 136u8, 77u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameBlacklistReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameBlacklistReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `disputeGameFactory()` and selector `0xf2b4e617`. +```solidity +function disputeGameFactory() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFactoryCall; + ///Container type for the return parameters of the [`disputeGameFactory()`](disputeGameFactoryCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFactoryReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFactoryCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFactoryCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFactoryReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFactoryReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameFactoryCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameFactory()"; + const SELECTOR: [u8; 4] = [242u8, 180u8, 230u8, 23u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameFactoryReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameFactoryReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `disputeGameFinalityDelaySeconds()` and selector `0x952b2797`. +```solidity +function disputeGameFinalityDelaySeconds() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFinalityDelaySecondsCall; + ///Container type for the return parameters of the [`disputeGameFinalityDelaySeconds()`](disputeGameFinalityDelaySecondsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFinalityDelaySecondsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFinalityDelaySecondsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFinalityDelaySecondsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFinalityDelaySecondsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFinalityDelaySecondsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameFinalityDelaySecondsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameFinalityDelaySeconds()"; + const SELECTOR: [u8; 4] = [149u8, 43u8, 39u8, 151u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameFinalityDelaySecondsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameFinalityDelaySecondsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `getAnchorRoot()` and selector `0xd83ef267`. +```solidity +function getAnchorRoot() external view returns (Hash, uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getAnchorRootCall; + ///Container type for the return parameters of the [`getAnchorRoot()`](getAnchorRootCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getAnchorRootReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + #[allow(missing_docs)] + pub _1: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getAnchorRootCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getAnchorRootCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getAnchorRootReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getAnchorRootReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl getAnchorRootReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self._0), + as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getAnchorRootCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getAnchorRootReturn; + type ReturnTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getAnchorRoot()"; + const SELECTOR: [u8; 4] = [216u8, 62u8, 242u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getAnchorRootReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `initVersion()` and selector `0x38d38c97`. +```solidity +function initVersion() external view returns (uint8); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionCall; + ///Container type for the return parameters of the [`initVersion()`](initVersionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionReturn { + #[allow(missing_docs)] + pub _0: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u8,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initVersionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initVersion()"; + const SELECTOR: [u8; 4] = [56u8, 211u8, 140u8, 151u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initialize(address,address,(bytes32,uint256),uint32)` and selector `0x47a222c5`. +```solidity +function initialize(address _systemConfig, address _disputeGameFactory, Proposal memory _startingAnchorRoot, GameType _startingRespectedGameType) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall { + #[allow(missing_docs)] + pub _systemConfig: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _disputeGameFactory: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _startingAnchorRoot: ::RustType, + #[allow(missing_docs)] + pub _startingRespectedGameType: ::RustType, + } + ///Container type for the return parameters of the [`initialize(address,address,(bytes32,uint256),uint32)`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + Proposal, + GameType, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + ::RustType, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + ( + value._systemConfig, + value._disputeGameFactory, + value._startingAnchorRoot, + value._startingRespectedGameType, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _systemConfig: tuple.0, + _disputeGameFactory: tuple.1, + _startingAnchorRoot: tuple.2, + _startingRespectedGameType: tuple.3, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + Proposal, + GameType, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize(address,address,(bytes32,uint256),uint32)"; + const SELECTOR: [u8; 4] = [71u8, 162u8, 34u8, 197u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._systemConfig, + ), + ::tokenize( + &self._disputeGameFactory, + ), + ::tokenize( + &self._startingAnchorRoot, + ), + ::tokenize( + &self._startingRespectedGameType, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `isGameBlacklisted(address)` and selector `0x34a346ea`. +```solidity +function isGameBlacklisted(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameBlacklistedCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameBlacklisted(address)`](isGameBlacklistedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameBlacklistedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameBlacklistedCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameBlacklistedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameBlacklistedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameBlacklistedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameBlacklistedCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameBlacklisted(address)"; + const SELECTOR: [u8; 4] = [52u8, 163u8, 70u8, 234u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameBlacklistedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameBlacklistedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameClaimValid(address)` and selector `0x6c4f4467`. +```solidity +function isGameClaimValid(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameClaimValidCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameClaimValid(address)`](isGameClaimValidCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameClaimValidReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameClaimValidCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameClaimValidCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameClaimValidReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameClaimValidReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameClaimValidCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameClaimValid(address)"; + const SELECTOR: [u8; 4] = [108u8, 79u8, 68u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameClaimValidReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameClaimValidReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameFinalized(address)` and selector `0x0314d2b3`. +```solidity +function isGameFinalized(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameFinalizedCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameFinalized(address)`](isGameFinalizedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameFinalizedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameFinalizedCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameFinalizedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameFinalizedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameFinalizedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameFinalizedCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameFinalized(address)"; + const SELECTOR: [u8; 4] = [3u8, 20u8, 210u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameFinalizedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameFinalizedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameProper(address)` and selector `0x496b9c16`. +```solidity +function isGameProper(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameProperCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameProper(address)`](isGameProperCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameProperReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameProperCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameProperCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameProperReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameProperReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameProperCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameProper(address)"; + const SELECTOR: [u8; 4] = [73u8, 107u8, 156u8, 22u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameProperReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameProperReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameRegistered(address)` and selector `0xee658e45`. +```solidity +function isGameRegistered(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRegisteredCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameRegistered(address)`](isGameRegisteredCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRegisteredReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameRegisteredCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameRegisteredCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameRegisteredReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameRegisteredReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameRegisteredCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameRegistered(address)"; + const SELECTOR: [u8; 4] = [238u8, 101u8, 142u8, 69u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameRegisteredReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameRegisteredReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameResolved(address)` and selector `0xfdbb3dcf`. +```solidity +function isGameResolved(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameResolvedCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameResolved(address)`](isGameResolvedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameResolvedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameResolvedCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameResolvedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameResolvedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameResolvedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameResolvedCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameResolved(address)"; + const SELECTOR: [u8; 4] = [253u8, 187u8, 61u8, 207u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameResolvedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameResolvedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameRespected(address)` and selector `0x04e50fed`. +```solidity +function isGameRespected(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRespectedCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameRespected(address)`](isGameRespectedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRespectedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameRespectedCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameRespectedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isGameRespectedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isGameRespectedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameRespectedCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameRespected(address)"; + const SELECTOR: [u8; 4] = [4u8, 229u8, 15u8, 237u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameRespectedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameRespectedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isGameRetired(address)` and selector `0x5958a193`. +```solidity +function isGameRetired(address _game) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRetiredCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`isGameRetired(address)`](isGameRetiredCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isGameRetiredReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameRetiredCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameRetiredCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isGameRetiredReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isGameRetiredReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isGameRetiredCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isGameRetired(address)"; + const SELECTOR: [u8; 4] = [89u8, 88u8, 161u8, 147u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isGameRetiredReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isGameRetiredReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `paused()` and selector `0x5c975abb`. +```solidity +function paused() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pausedCall; + ///Container type for the return parameters of the [`paused()`](pausedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pausedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pausedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pausedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pausedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pausedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pausedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "paused()"; + const SELECTOR: [u8; 4] = [92u8, 151u8, 90u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: pausedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: pausedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdmin()` and selector `0x3e47158c`. +```solidity +function proxyAdmin() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminCall; + ///Container type for the return parameters of the [`proxyAdmin()`](proxyAdminCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdmin()"; + const SELECTOR: [u8; 4] = [62u8, 71u8, 21u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdminOwner()` and selector `0xdad544e0`. +```solidity +function proxyAdminOwner() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerCall; + ///Container type for the return parameters of the [`proxyAdminOwner()`](proxyAdminOwnerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminOwnerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proxyAdminOwnerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminOwnerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdminOwner()"; + const SELECTOR: [u8; 4] = [218u8, 213u8, 68u8, 224u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `respectedGameType()` and selector `0x3c9f397c`. +```solidity +function respectedGameType() external view returns (GameType); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct respectedGameTypeCall; + ///Container type for the return parameters of the [`respectedGameType()`](respectedGameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct respectedGameTypeReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: respectedGameTypeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for respectedGameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: respectedGameTypeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for respectedGameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for respectedGameTypeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameType,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "respectedGameType()"; + const SELECTOR: [u8; 4] = [60u8, 159u8, 57u8, 124u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: respectedGameTypeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: respectedGameTypeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `retirementTimestamp()` and selector `0x4086d183`. +```solidity +function retirementTimestamp() external view returns (uint64); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct retirementTimestampCall; + ///Container type for the return parameters of the [`retirementTimestamp()`](retirementTimestampCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct retirementTimestampReturn { + #[allow(missing_docs)] + pub _0: u64, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: retirementTimestampCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for retirementTimestampCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u64,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: retirementTimestampReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for retirementTimestampReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for retirementTimestampCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u64; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "retirementTimestamp()"; + const SELECTOR: [u8; 4] = [64u8, 134u8, 209u8, 131u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: retirementTimestampReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: retirementTimestampReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `setAnchorState(address)` and selector `0x17cf21a9`. +```solidity +function setAnchorState(address _game) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setAnchorStateCall { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`setAnchorState(address)`](setAnchorStateCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setAnchorStateReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setAnchorStateCall) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setAnchorStateCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setAnchorStateReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setAnchorStateReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setAnchorStateReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setAnchorStateCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setAnchorStateReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setAnchorState(address)"; + const SELECTOR: [u8; 4] = [23u8, 207u8, 33u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._game, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setAnchorStateReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setRespectedGameType(uint32)` and selector `0x7fc48504`. +```solidity +function setRespectedGameType(GameType _gameType) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setRespectedGameTypeCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + } + ///Container type for the return parameters of the [`setRespectedGameType(uint32)`](setRespectedGameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setRespectedGameTypeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setRespectedGameTypeCall) -> Self { + (value._gameType,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setRespectedGameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _gameType: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setRespectedGameTypeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setRespectedGameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setRespectedGameTypeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setRespectedGameTypeCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setRespectedGameTypeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setRespectedGameType(uint32)"; + const SELECTOR: [u8; 4] = [127u8, 196u8, 133u8, 4u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self._gameType),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setRespectedGameTypeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `superchainConfig()` and selector `0x35e80ab3`. +```solidity +function superchainConfig() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct superchainConfigCall; + ///Container type for the return parameters of the [`superchainConfig()`](superchainConfigCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct superchainConfigReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: superchainConfigCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for superchainConfigCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: superchainConfigReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for superchainConfigReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for superchainConfigCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "superchainConfig()"; + const SELECTOR: [u8; 4] = [53u8, 232u8, 10u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: superchainConfigReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: superchainConfigReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `systemConfig()` and selector `0x33d7e2bd`. +```solidity +function systemConfig() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct systemConfigCall; + ///Container type for the return parameters of the [`systemConfig()`](systemConfigCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct systemConfigReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: systemConfigCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for systemConfigCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: systemConfigReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for systemConfigReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for systemConfigCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "systemConfig()"; + const SELECTOR: [u8; 4] = [51u8, 215u8, 226u8, 189u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: systemConfigReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: systemConfigReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `updateRetirementTimestamp()` and selector `0xd5a3e12e`. +```solidity +function updateRetirementTimestamp() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct updateRetirementTimestampCall; + ///Container type for the return parameters of the [`updateRetirementTimestamp()`](updateRetirementTimestampCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct updateRetirementTimestampReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: updateRetirementTimestampCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for updateRetirementTimestampCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: updateRetirementTimestampReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for updateRetirementTimestampReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl updateRetirementTimestampReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for updateRetirementTimestampCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = updateRetirementTimestampReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "updateRetirementTimestamp()"; + const SELECTOR: [u8; 4] = [213u8, 163u8, 225u8, 46u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + updateRetirementTimestampReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `version()` and selector `0x54fd4d50`. +```solidity +function version() external view returns (string memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionCall; + ///Container type for the return parameters of the [`version()`](versionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for versionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "version()"; + const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IAnchorStateRegistry`](self) function calls. + #[derive(Clone)] + pub enum IAnchorStateRegistryCalls { + #[allow(missing_docs)] + __constructor__(__constructor__Call), + #[allow(missing_docs)] + anchorGame(anchorGameCall), + #[allow(missing_docs)] + anchors(anchorsCall), + #[allow(missing_docs)] + blacklistDisputeGame(blacklistDisputeGameCall), + #[allow(missing_docs)] + disputeGameBlacklist(disputeGameBlacklistCall), + #[allow(missing_docs)] + disputeGameFactory(disputeGameFactoryCall), + #[allow(missing_docs)] + disputeGameFinalityDelaySeconds(disputeGameFinalityDelaySecondsCall), + #[allow(missing_docs)] + getAnchorRoot(getAnchorRootCall), + #[allow(missing_docs)] + initVersion(initVersionCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + isGameBlacklisted(isGameBlacklistedCall), + #[allow(missing_docs)] + isGameClaimValid(isGameClaimValidCall), + #[allow(missing_docs)] + isGameFinalized(isGameFinalizedCall), + #[allow(missing_docs)] + isGameProper(isGameProperCall), + #[allow(missing_docs)] + isGameRegistered(isGameRegisteredCall), + #[allow(missing_docs)] + isGameResolved(isGameResolvedCall), + #[allow(missing_docs)] + isGameRespected(isGameRespectedCall), + #[allow(missing_docs)] + isGameRetired(isGameRetiredCall), + #[allow(missing_docs)] + paused(pausedCall), + #[allow(missing_docs)] + proxyAdmin(proxyAdminCall), + #[allow(missing_docs)] + proxyAdminOwner(proxyAdminOwnerCall), + #[allow(missing_docs)] + respectedGameType(respectedGameTypeCall), + #[allow(missing_docs)] + retirementTimestamp(retirementTimestampCall), + #[allow(missing_docs)] + setAnchorState(setAnchorStateCall), + #[allow(missing_docs)] + setRespectedGameType(setRespectedGameTypeCall), + #[allow(missing_docs)] + superchainConfig(superchainConfigCall), + #[allow(missing_docs)] + systemConfig(systemConfigCall), + #[allow(missing_docs)] + updateRetirementTimestamp(updateRetirementTimestampCall), + #[allow(missing_docs)] + version(versionCall), + } + impl IAnchorStateRegistryCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [3u8, 20u8, 210u8, 179u8], + [4u8, 229u8, 15u8, 237u8], + [23u8, 207u8, 33u8, 169u8], + [51u8, 215u8, 226u8, 189u8], + [52u8, 163u8, 70u8, 234u8], + [53u8, 232u8, 10u8, 179u8], + [56u8, 211u8, 140u8, 151u8], + [60u8, 159u8, 57u8, 124u8], + [62u8, 71u8, 21u8, 140u8], + [64u8, 134u8, 209u8, 131u8], + [65u8, 35u8, 42u8, 23u8], + [69u8, 136u8, 77u8, 50u8], + [71u8, 162u8, 34u8, 197u8], + [73u8, 107u8, 156u8, 22u8], + [84u8, 253u8, 77u8, 80u8], + [89u8, 88u8, 161u8, 147u8], + [92u8, 151u8, 90u8, 187u8], + [108u8, 79u8, 68u8, 103u8], + [114u8, 88u8, 168u8, 7u8], + [125u8, 107u8, 232u8, 220u8], + [127u8, 196u8, 133u8, 4u8], + [149u8, 43u8, 39u8, 151u8], + [213u8, 163u8, 225u8, 46u8], + [216u8, 62u8, 242u8, 103u8], + [218u8, 213u8, 68u8, 224u8], + [224u8, 168u8, 64u8, 235u8], + [238u8, 101u8, 142u8, 69u8], + [242u8, 180u8, 230u8, 23u8], + [253u8, 187u8, 61u8, 207u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(isGameFinalized), + ::core::stringify!(isGameRespected), + ::core::stringify!(setAnchorState), + ::core::stringify!(systemConfig), + ::core::stringify!(isGameBlacklisted), + ::core::stringify!(superchainConfig), + ::core::stringify!(initVersion), + ::core::stringify!(respectedGameType), + ::core::stringify!(proxyAdmin), + ::core::stringify!(retirementTimestamp), + ::core::stringify!(__constructor__), + ::core::stringify!(disputeGameBlacklist), + ::core::stringify!(initialize), + ::core::stringify!(isGameProper), + ::core::stringify!(version), + ::core::stringify!(isGameRetired), + ::core::stringify!(paused), + ::core::stringify!(isGameClaimValid), + ::core::stringify!(anchors), + ::core::stringify!(blacklistDisputeGame), + ::core::stringify!(setRespectedGameType), + ::core::stringify!(disputeGameFinalityDelaySeconds), + ::core::stringify!(updateRetirementTimestamp), + ::core::stringify!(getAnchorRoot), + ::core::stringify!(proxyAdminOwner), + ::core::stringify!(anchorGame), + ::core::stringify!(isGameRegistered), + ::core::stringify!(disputeGameFactory), + ::core::stringify!(isGameResolved), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + <__constructor__Call as alloy_sol_types::SolCall>::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IAnchorStateRegistryCalls { + const NAME: &'static str = "IAnchorStateRegistryCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 29usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::__constructor__(_) => { + <__constructor__Call as alloy_sol_types::SolCall>::SELECTOR + } + Self::anchorGame(_) => { + ::SELECTOR + } + Self::anchors(_) => ::SELECTOR, + Self::blacklistDisputeGame(_) => { + ::SELECTOR + } + Self::disputeGameBlacklist(_) => { + ::SELECTOR + } + Self::disputeGameFactory(_) => { + ::SELECTOR + } + Self::disputeGameFinalityDelaySeconds(_) => { + ::SELECTOR + } + Self::getAnchorRoot(_) => { + ::SELECTOR + } + Self::initVersion(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } + Self::isGameBlacklisted(_) => { + ::SELECTOR + } + Self::isGameClaimValid(_) => { + ::SELECTOR + } + Self::isGameFinalized(_) => { + ::SELECTOR + } + Self::isGameProper(_) => { + ::SELECTOR + } + Self::isGameRegistered(_) => { + ::SELECTOR + } + Self::isGameResolved(_) => { + ::SELECTOR + } + Self::isGameRespected(_) => { + ::SELECTOR + } + Self::isGameRetired(_) => { + ::SELECTOR + } + Self::paused(_) => ::SELECTOR, + Self::proxyAdmin(_) => { + ::SELECTOR + } + Self::proxyAdminOwner(_) => { + ::SELECTOR + } + Self::respectedGameType(_) => { + ::SELECTOR + } + Self::retirementTimestamp(_) => { + ::SELECTOR + } + Self::setAnchorState(_) => { + ::SELECTOR + } + Self::setRespectedGameType(_) => { + ::SELECTOR + } + Self::superchainConfig(_) => { + ::SELECTOR + } + Self::systemConfig(_) => { + ::SELECTOR + } + Self::updateRetirementTimestamp(_) => { + ::SELECTOR + } + Self::version(_) => ::SELECTOR, + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isGameFinalized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::isGameFinalized) + } + isGameFinalized + }, + { + fn isGameRespected( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::isGameRespected) + } + isGameRespected + }, + { + fn setAnchorState( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::setAnchorState) + } + setAnchorState + }, + { + fn systemConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::systemConfig) + } + systemConfig + }, + { + fn isGameBlacklisted( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::isGameBlacklisted) + } + isGameBlacklisted + }, + { + fn superchainConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::superchainConfig) + } + superchainConfig + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::initVersion) + } + initVersion + }, + { + fn respectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::respectedGameType) + } + respectedGameType + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn retirementTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::retirementTimestamp) + } + retirementTimestamp + }, + { + fn __constructor__( + data: &[u8], + ) -> alloy_sol_types::Result { + <__constructor__Call as alloy_sol_types::SolCall>::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::__constructor__) + } + __constructor__ + }, + { + fn disputeGameBlacklist( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::disputeGameBlacklist) + } + disputeGameBlacklist + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::initialize) + } + initialize + }, + { + fn isGameProper( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::isGameProper) + } + isGameProper + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IAnchorStateRegistryCalls::version) + } + version + }, + { + fn isGameRetired( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::isGameRetired) + } + isGameRetired + }, + { + fn paused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IAnchorStateRegistryCalls::paused) + } + paused + }, + { + fn isGameClaimValid( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::isGameClaimValid) + } + isGameClaimValid + }, + { + fn anchors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IAnchorStateRegistryCalls::anchors) + } + anchors + }, + { + fn blacklistDisputeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::blacklistDisputeGame) + } + blacklistDisputeGame + }, + { + fn setRespectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::setRespectedGameType) + } + setRespectedGameType + }, + { + fn disputeGameFinalityDelaySeconds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryCalls::disputeGameFinalityDelaySeconds, + ) + } + disputeGameFinalityDelaySeconds + }, + { + fn updateRetirementTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::updateRetirementTimestamp) + } + updateRetirementTimestamp + }, + { + fn getAnchorRoot( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::getAnchorRoot) + } + getAnchorRoot + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn anchorGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::anchorGame) + } + anchorGame + }, + { + fn isGameRegistered( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::isGameRegistered) + } + isGameRegistered + }, + { + fn disputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::disputeGameFactory) + } + disputeGameFactory + }, + { + fn isGameResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IAnchorStateRegistryCalls::isGameResolved) + } + isGameResolved + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isGameFinalized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::isGameFinalized) + } + isGameFinalized + }, + { + fn isGameRespected( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::isGameRespected) + } + isGameRespected + }, + { + fn setAnchorState( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::setAnchorState) + } + setAnchorState + }, + { + fn systemConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::systemConfig) + } + systemConfig + }, + { + fn isGameBlacklisted( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::isGameBlacklisted) + } + isGameBlacklisted + }, + { + fn superchainConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::superchainConfig) + } + superchainConfig + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::initVersion) + } + initVersion + }, + { + fn respectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::respectedGameType) + } + respectedGameType + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn retirementTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::retirementTimestamp) + } + retirementTimestamp + }, + { + fn __constructor__( + data: &[u8], + ) -> alloy_sol_types::Result { + <__constructor__Call as alloy_sol_types::SolCall>::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::__constructor__) + } + __constructor__ + }, + { + fn disputeGameBlacklist( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::disputeGameBlacklist) + } + disputeGameBlacklist + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::initialize) + } + initialize + }, + { + fn isGameProper( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::isGameProper) + } + isGameProper + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::version) + } + version + }, + { + fn isGameRetired( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::isGameRetired) + } + isGameRetired + }, + { + fn paused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::paused) + } + paused + }, + { + fn isGameClaimValid( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::isGameClaimValid) + } + isGameClaimValid + }, + { + fn anchors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::anchors) + } + anchors + }, + { + fn blacklistDisputeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::blacklistDisputeGame) + } + blacklistDisputeGame + }, + { + fn setRespectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::setRespectedGameType) + } + setRespectedGameType + }, + { + fn disputeGameFinalityDelaySeconds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryCalls::disputeGameFinalityDelaySeconds, + ) + } + disputeGameFinalityDelaySeconds + }, + { + fn updateRetirementTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::updateRetirementTimestamp) + } + updateRetirementTimestamp + }, + { + fn getAnchorRoot( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::getAnchorRoot) + } + getAnchorRoot + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn anchorGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::anchorGame) + } + anchorGame + }, + { + fn isGameRegistered( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::isGameRegistered) + } + isGameRegistered + }, + { + fn disputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::disputeGameFactory) + } + disputeGameFactory + }, + { + fn isGameResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAnchorStateRegistryCalls::isGameResolved) + } + isGameResolved + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::__constructor__(inner) => { + <__constructor__Call as alloy_sol_types::SolCall>::abi_encoded_size( + inner, + ) + } + Self::anchorGame(inner) => { + ::abi_encoded_size(inner) + } + Self::anchors(inner) => { + ::abi_encoded_size(inner) + } + Self::blacklistDisputeGame(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disputeGameBlacklist(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disputeGameFactory(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disputeGameFinalityDelaySeconds(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getAnchorRoot(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::isGameBlacklisted(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameClaimValid(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameFinalized(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameProper(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameRegistered(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameResolved(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameRespected(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isGameRetired(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::paused(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdmin(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::respectedGameType(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::retirementTimestamp(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setAnchorState(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setRespectedGameType(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::superchainConfig(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::systemConfig(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::updateRetirementTimestamp(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::version(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::__constructor__(inner) => { + <__constructor__Call as alloy_sol_types::SolCall>::abi_encode_raw( + inner, + out, + ) + } + Self::anchorGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::anchors(inner) => { + ::abi_encode_raw(inner, out) + } + Self::blacklistDisputeGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disputeGameBlacklist(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disputeGameFactory(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disputeGameFinalityDelaySeconds(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getAnchorRoot(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameBlacklisted(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameClaimValid(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameFinalized(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameProper(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameRegistered(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameResolved(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameRespected(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isGameRetired(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::paused(inner) => { + ::abi_encode_raw(inner, out) + } + Self::proxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::respectedGameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::retirementTimestamp(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setAnchorState(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setRespectedGameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::superchainConfig(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::systemConfig(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::updateRetirementTimestamp(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::version(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`IAnchorStateRegistry`](self) custom errors. + #[derive(Clone)] + pub enum IAnchorStateRegistryErrors { + #[allow(missing_docs)] + AnchorStateRegistry_InvalidAnchorGame(AnchorStateRegistry_InvalidAnchorGame), + #[allow(missing_docs)] + AnchorStateRegistry_Unauthorized(AnchorStateRegistry_Unauthorized), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdmin(ProxyAdminOwnedBase_NotProxyAdmin), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOwner(ProxyAdminOwnedBase_NotProxyAdminOwner), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotResolvedDelegateProxy( + ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_ProxyAdminNotFound(ProxyAdminOwnedBase_ProxyAdminNotFound), + #[allow(missing_docs)] + ReinitializableBase_ZeroInitVersion(ReinitializableBase_ZeroInitVersion), + } + impl IAnchorStateRegistryErrors { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [7u8, 92u8, 67u8, 20u8], + [46u8, 83u8, 33u8, 172u8], + [51u8, 33u8, 68u8, 219u8], + [71u8, 173u8, 54u8, 122u8], + [84u8, 228u8, 51u8, 205u8], + [127u8, 18u8, 198u8, 75u8], + [155u8, 1u8, 175u8, 237u8], + [196u8, 5u8, 10u8, 38u8], + [232u8, 24u8, 220u8, 195u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(ProxyAdminOwnedBase_NotSharedProxyAdminOwner), + ::core::stringify!(AnchorStateRegistry_Unauthorized), + ::core::stringify!(ProxyAdminOwnedBase_ProxyAdminNotFound), + ::core::stringify!(AnchorStateRegistry_InvalidAnchorGame), + ::core::stringify!(ProxyAdminOwnedBase_NotResolvedDelegateProxy), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOwner), + ::core::stringify!(ReinitializableBase_ZeroInitVersion), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdmin), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IAnchorStateRegistryErrors { + const NAME: &'static str = "IAnchorStateRegistryErrors"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 9usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::AnchorStateRegistry_InvalidAnchorGame(_) => { + ::SELECTOR + } + Self::AnchorStateRegistry_Unauthorized(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(_) => { + ::SELECTOR + } + Self::ReinitializableBase_ZeroInitVersion(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn AnchorStateRegistry_Unauthorized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryErrors::AnchorStateRegistry_Unauthorized, + ) + } + AnchorStateRegistry_Unauthorized + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn AnchorStateRegistry_InvalidAnchorGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryErrors::AnchorStateRegistry_InvalidAnchorGame, + ) + } + AnchorStateRegistry_InvalidAnchorGame + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn AnchorStateRegistry_Unauthorized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryErrors::AnchorStateRegistry_Unauthorized, + ) + } + AnchorStateRegistry_Unauthorized + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn AnchorStateRegistry_InvalidAnchorGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryErrors::AnchorStateRegistry_InvalidAnchorGame, + ) + } + AnchorStateRegistry_InvalidAnchorGame + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IAnchorStateRegistryErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::AnchorStateRegistry_InvalidAnchorGame(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::AnchorStateRegistry_Unauthorized(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::AnchorStateRegistry_InvalidAnchorGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::AnchorStateRegistry_Unauthorized(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`IAnchorStateRegistry`](self) events. + #[derive(Clone)] + pub enum IAnchorStateRegistryEvents { + #[allow(missing_docs)] + AnchorUpdated(AnchorUpdated), + #[allow(missing_docs)] + DisputeGameBlacklisted(DisputeGameBlacklisted), + #[allow(missing_docs)] + Initialized(Initialized), + #[allow(missing_docs)] + RespectedGameTypeSet(RespectedGameTypeSet), + #[allow(missing_docs)] + RetirementTimestampSet(RetirementTimestampSet), + } + impl IAnchorStateRegistryEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 25u8, 44u8, 40u8, 144u8, 38u8, 213u8, 154u8, 65u8, 162u8, 127u8, 90u8, + 234u8, 8u8, 243u8, 150u8, 155u8, 87u8, 147u8, 27u8, 5u8, 137u8, 32u8, + 45u8, 20u8, 244u8, 54u8, 140u8, 222u8, 217u8, 93u8, 60u8, 218u8, + ], + [ + 71u8, 79u8, 24u8, 13u8, 116u8, 234u8, 135u8, 81u8, 149u8, 94u8, 226u8, + 97u8, 201u8, 63u8, 248u8, 39u8, 4u8, 17u8, 177u8, 128u8, 64u8, 141u8, + 16u8, 20u8, 196u8, 159u8, 85u8, 44u8, 146u8, 164u8, 209u8, 30u8, + ], + [ + 110u8, 91u8, 27u8, 167u8, 113u8, 232u8, 228u8, 132u8, 247u8, 65u8, 237u8, + 8u8, 95u8, 3u8, 159u8, 244u8, 229u8, 198u8, 232u8, 130u8, 234u8, 246u8, + 143u8, 85u8, 15u8, 179u8, 144u8, 146u8, 45u8, 10u8, 228u8, 167u8, + ], + [ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ], + [ + 206u8, 224u8, 112u8, 59u8, 94u8, 75u8, 173u8, 78u8, 254u8, 222u8, 218u8, + 184u8, 92u8, 159u8, 209u8, 174u8, 193u8, 125u8, 238u8, 124u8, 95u8, + 108u8, 88u8, 67u8, 48u8, 224u8, 80u8, 155u8, 103u8, 119u8, 69u8, 162u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(DisputeGameBlacklisted), + ::core::stringify!(AnchorUpdated), + ::core::stringify!(RetirementTimestampSet), + ::core::stringify!(Initialized), + ::core::stringify!(RespectedGameTypeSet), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IAnchorStateRegistryEvents { + const NAME: &'static str = "IAnchorStateRegistryEvents"; + const COUNT: usize = 5usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::AnchorUpdated) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::DisputeGameBlacklisted) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::Initialized) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::RespectedGameTypeSet) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::RetirementTimestampSet) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for IAnchorStateRegistryEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::AnchorUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::DisputeGameBlacklisted(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::RespectedGameTypeSet(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::RetirementTimestampSet(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::AnchorUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::DisputeGameBlacklisted(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::RespectedGameTypeSet(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::RetirementTimestampSet(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IAnchorStateRegistry`](self) contract instance. + +See the [wrapper's documentation](`IAnchorStateRegistryInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> IAnchorStateRegistryInstance { + IAnchorStateRegistryInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IAnchorStateRegistryInstance::::deploy(__provider) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(__provider: P) -> alloy_contract::RawCallBuilder { + IAnchorStateRegistryInstance::::deploy_builder(__provider) + } + /**A [`IAnchorStateRegistry`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IAnchorStateRegistry`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct IAnchorStateRegistryInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IAnchorStateRegistryInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IAnchorStateRegistryInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IAnchorStateRegistryInstance { + /**Creates a new wrapper around an on-chain [`IAnchorStateRegistry`](self) contract instance. + +See the [wrapper's documentation](`IAnchorStateRegistryInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + ::core::clone::Clone::clone(&BYTECODE), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl IAnchorStateRegistryInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IAnchorStateRegistryInstance { + IAnchorStateRegistryInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IAnchorStateRegistryInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`__constructor__`] function. + pub fn __constructor__( + &self, + _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, __constructor__Call, N> { + self.call_builder( + &__constructor__Call { + _disputeGameFinalityDelaySeconds, + }, + ) + } + ///Creates a new call builder for the [`anchorGame`] function. + pub fn anchorGame( + &self, + ) -> alloy_contract::SolCallBuilder<&P, anchorGameCall, N> { + self.call_builder(&anchorGameCall) + } + ///Creates a new call builder for the [`anchors`] function. + pub fn anchors( + &self, + _0: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, anchorsCall, N> { + self.call_builder(&anchorsCall(_0)) + } + ///Creates a new call builder for the [`blacklistDisputeGame`] function. + pub fn blacklistDisputeGame( + &self, + _disputeGame: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, blacklistDisputeGameCall, N> { + self.call_builder( + &blacklistDisputeGameCall { + _disputeGame, + }, + ) + } + ///Creates a new call builder for the [`disputeGameBlacklist`] function. + pub fn disputeGameBlacklist( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameBlacklistCall, N> { + self.call_builder(&disputeGameBlacklistCall(_0)) + } + ///Creates a new call builder for the [`disputeGameFactory`] function. + pub fn disputeGameFactory( + &self, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameFactoryCall, N> { + self.call_builder(&disputeGameFactoryCall) + } + ///Creates a new call builder for the [`disputeGameFinalityDelaySeconds`] function. + pub fn disputeGameFinalityDelaySeconds( + &self, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameFinalityDelaySecondsCall, N> { + self.call_builder(&disputeGameFinalityDelaySecondsCall) + } + ///Creates a new call builder for the [`getAnchorRoot`] function. + pub fn getAnchorRoot( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getAnchorRootCall, N> { + self.call_builder(&getAnchorRootCall) + } + ///Creates a new call builder for the [`initVersion`] function. + pub fn initVersion( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initVersionCall, N> { + self.call_builder(&initVersionCall) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + _systemConfig: alloy::sol_types::private::Address, + _disputeGameFactory: alloy::sol_types::private::Address, + _startingAnchorRoot: ::RustType, + _startingRespectedGameType: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder( + &initializeCall { + _systemConfig, + _disputeGameFactory, + _startingAnchorRoot, + _startingRespectedGameType, + }, + ) + } + ///Creates a new call builder for the [`isGameBlacklisted`] function. + pub fn isGameBlacklisted( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameBlacklistedCall, N> { + self.call_builder(&isGameBlacklistedCall { _game }) + } + ///Creates a new call builder for the [`isGameClaimValid`] function. + pub fn isGameClaimValid( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameClaimValidCall, N> { + self.call_builder(&isGameClaimValidCall { _game }) + } + ///Creates a new call builder for the [`isGameFinalized`] function. + pub fn isGameFinalized( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameFinalizedCall, N> { + self.call_builder(&isGameFinalizedCall { _game }) + } + ///Creates a new call builder for the [`isGameProper`] function. + pub fn isGameProper( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameProperCall, N> { + self.call_builder(&isGameProperCall { _game }) + } + ///Creates a new call builder for the [`isGameRegistered`] function. + pub fn isGameRegistered( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameRegisteredCall, N> { + self.call_builder(&isGameRegisteredCall { _game }) + } + ///Creates a new call builder for the [`isGameResolved`] function. + pub fn isGameResolved( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameResolvedCall, N> { + self.call_builder(&isGameResolvedCall { _game }) + } + ///Creates a new call builder for the [`isGameRespected`] function. + pub fn isGameRespected( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameRespectedCall, N> { + self.call_builder(&isGameRespectedCall { _game }) + } + ///Creates a new call builder for the [`isGameRetired`] function. + pub fn isGameRetired( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isGameRetiredCall, N> { + self.call_builder(&isGameRetiredCall { _game }) + } + ///Creates a new call builder for the [`paused`] function. + pub fn paused(&self) -> alloy_contract::SolCallBuilder<&P, pausedCall, N> { + self.call_builder(&pausedCall) + } + ///Creates a new call builder for the [`proxyAdmin`] function. + pub fn proxyAdmin( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminCall, N> { + self.call_builder(&proxyAdminCall) + } + ///Creates a new call builder for the [`proxyAdminOwner`] function. + pub fn proxyAdminOwner( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminOwnerCall, N> { + self.call_builder(&proxyAdminOwnerCall) + } + ///Creates a new call builder for the [`respectedGameType`] function. + pub fn respectedGameType( + &self, + ) -> alloy_contract::SolCallBuilder<&P, respectedGameTypeCall, N> { + self.call_builder(&respectedGameTypeCall) + } + ///Creates a new call builder for the [`retirementTimestamp`] function. + pub fn retirementTimestamp( + &self, + ) -> alloy_contract::SolCallBuilder<&P, retirementTimestampCall, N> { + self.call_builder(&retirementTimestampCall) + } + ///Creates a new call builder for the [`setAnchorState`] function. + pub fn setAnchorState( + &self, + _game: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, setAnchorStateCall, N> { + self.call_builder(&setAnchorStateCall { _game }) + } + ///Creates a new call builder for the [`setRespectedGameType`] function. + pub fn setRespectedGameType( + &self, + _gameType: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, setRespectedGameTypeCall, N> { + self.call_builder( + &setRespectedGameTypeCall { + _gameType, + }, + ) + } + ///Creates a new call builder for the [`superchainConfig`] function. + pub fn superchainConfig( + &self, + ) -> alloy_contract::SolCallBuilder<&P, superchainConfigCall, N> { + self.call_builder(&superchainConfigCall) + } + ///Creates a new call builder for the [`systemConfig`] function. + pub fn systemConfig( + &self, + ) -> alloy_contract::SolCallBuilder<&P, systemConfigCall, N> { + self.call_builder(&systemConfigCall) + } + ///Creates a new call builder for the [`updateRetirementTimestamp`] function. + pub fn updateRetirementTimestamp( + &self, + ) -> alloy_contract::SolCallBuilder<&P, updateRetirementTimestampCall, N> { + self.call_builder(&updateRetirementTimestampCall) + } + ///Creates a new call builder for the [`version`] function. + pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> { + self.call_builder(&versionCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IAnchorStateRegistryInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`AnchorUpdated`] event. + pub fn AnchorUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, AnchorUpdated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`DisputeGameBlacklisted`] event. + pub fn DisputeGameBlacklisted_filter( + &self, + ) -> alloy_contract::Event<&P, DisputeGameBlacklisted, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Initialized`] event. + pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`RespectedGameTypeSet`] event. + pub fn RespectedGameTypeSet_filter( + &self, + ) -> alloy_contract::Event<&P, RespectedGameTypeSet, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`RetirementTimestampSet`] event. + pub fn RetirementTimestampSet_filter( + &self, + ) -> alloy_contract::Event<&P, RetirementTimestampSet, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/i_dispute_game.rs b/bindings/src/codegen/i_dispute_game.rs new file mode 100644 index 000000000..17ad0a41a --- /dev/null +++ b/bindings/src/codegen/i_dispute_game.rs @@ -0,0 +1,3799 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IDisputeGame { + type GameStatus is uint8; + type Claim is bytes32; + type GameType is uint32; + type Hash is bytes32; + type Timestamp is uint64; + + event Resolved(GameStatus indexed status); + + function createdAt() external view returns (Timestamp); + function extraData() external pure returns (bytes memory extraData_); + function gameCreator() external pure returns (address creator_); + function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); + function gameType() external view returns (GameType gameType_); + function initialize() external payable; + function l1Head() external pure returns (Hash l1Head_); + function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); + function resolve() external returns (GameStatus status_); + function resolvedAt() external view returns (Timestamp); + function rootClaim() external pure returns (Claim rootClaim_); + function status() external view returns (GameStatus); + function wasRespectedGameTypeWhenCreated() external view returns (bool); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "createdAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "extraData", + "inputs": [], + "outputs": [ + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameCreator", + "inputs": [], + "outputs": [ + { + "name": "creator_", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameData", + "inputs": [], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "rootClaim_", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameType", + "inputs": [], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "l1Head", + "inputs": [], + "outputs": [ + { + "name": "l1Head_", + "type": "bytes32", + "internalType": "Hash" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "l2SequenceNumber", + "inputs": [], + "outputs": [ + { + "name": "l2SequenceNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "resolve", + "inputs": [], + "outputs": [ + { + "name": "status_", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "resolvedAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "rootClaim", + "inputs": [], + "outputs": [ + { + "name": "rootClaim_", + "type": "bytes32", + "internalType": "Claim" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "status", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "wasRespectedGameTypeWhenCreated", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "Resolved", + "inputs": [ + { + "name": "status", + "type": "uint8", + "indexed": true, + "internalType": "enum GameStatus" + } + ], + "anonymous": false + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod IDisputeGame { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameStatus(u8); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u8 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<8>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameStatus { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u8) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u8 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameStatus { + fn from(value: u8) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u8 { + fn from(value: GameStatus) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameStatus { + type RustType = u8; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameStatus { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Claim(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Claim { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Claim { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Claim) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Claim { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Claim { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Hash(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Hash { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Hash { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Hash) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Hash { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Hash { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Timestamp(u64); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u64 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<64>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Timestamp { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u64) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u64 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Timestamp { + fn from(value: u64) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u64 { + fn from(value: Timestamp) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Timestamp { + type RustType = u64; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Timestamp { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**Event with signature `Resolved(uint8)` and selector `0x5e186f09b9c93491f14e277eea7faa5de6a2d4bda75a79af7a3684fbfb42da60`. +```solidity +event Resolved(GameStatus indexed status); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Resolved { + #[allow(missing_docs)] + pub status: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Resolved { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>, GameStatus); + const SIGNATURE: &'static str = "Resolved(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { status: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.status.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.status, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Resolved { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Resolved> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Resolved) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Function with signature `createdAt()` and selector `0xcf09e0d0`. +```solidity +function createdAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtCall; + ///Container type for the return parameters of the [`createdAt()`](createdAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createdAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "createdAt()"; + const SELECTOR: [u8; 4] = [207u8, 9u8, 224u8, 208u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `extraData()` and selector `0x609d3334`. +```solidity +function extraData() external pure returns (bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataCall; + ///Container type for the return parameters of the [`extraData()`](extraDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataReturn { + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataReturn) -> Self { + (value.extraData_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { extraData_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for extraDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Bytes; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "extraData()"; + const SELECTOR: [u8; 4] = [96u8, 157u8, 51u8, 52u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + } + }; + /**Function with signature `gameCreator()` and selector `0x37b1b229`. +```solidity +function gameCreator() external pure returns (address creator_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorCall; + ///Container type for the return parameters of the [`gameCreator()`](gameCreatorCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorReturn { + #[allow(missing_docs)] + pub creator_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorReturn) -> Self { + (value.creator_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { creator_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameCreatorCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameCreator()"; + const SELECTOR: [u8; 4] = [55u8, 177u8, 178u8, 41u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r.creator_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r.creator_ + }) + } + } + }; + /**Function with signature `gameData()` and selector `0xfa24f743`. +```solidity +function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataCall; + ///Container type for the return parameters of the [`gameData()`](gameDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + #[allow(missing_docs)] + pub rootClaim_: ::RustType, + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataReturn) -> Self { + (value.gameType_, value.rootClaim_, value.extraData_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + gameType_: tuple.0, + rootClaim_: tuple.1, + extraData_: tuple.2, + } + } + } + } + impl gameDataReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.gameType_), + ::tokenize(&self.rootClaim_), + ::tokenize( + &self.extraData_, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = gameDataReturn; + type ReturnTuple<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameData()"; + const SELECTOR: [u8; 4] = [250u8, 36u8, 247u8, 67u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + gameDataReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `gameType()` and selector `0xbbdc02db`. +```solidity +function gameType() external view returns (GameType gameType_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeCall; + ///Container type for the return parameters of the [`gameType()`](gameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeReturn) -> Self { + (value.gameType_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { gameType_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameTypeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameType,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameType()"; + const SELECTOR: [u8; 4] = [187u8, 220u8, 2u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r.gameType_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r.gameType_ + }) + } + } + }; + /**Function with signature `initialize()` and selector `0x8129fc1c`. +```solidity +function initialize() external payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall; + ///Container type for the return parameters of the [`initialize()`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize()"; + const SELECTOR: [u8; 4] = [129u8, 41u8, 252u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `l1Head()` and selector `0x6361506d`. +```solidity +function l1Head() external pure returns (Hash l1Head_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadCall; + ///Container type for the return parameters of the [`l1Head()`](l1HeadCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadReturn { + #[allow(missing_docs)] + pub l1Head_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadReturn) -> Self { + (value.l1Head_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l1Head_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l1HeadCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Hash,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l1Head()"; + const SELECTOR: [u8; 4] = [99u8, 97u8, 80u8, 109u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r.l1Head_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r.l1Head_ + }) + } + } + }; + /**Function with signature `l2SequenceNumber()` and selector `0x99735e32`. +```solidity +function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberCall; + ///Container type for the return parameters of the [`l2SequenceNumber()`](l2SequenceNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberReturn { + #[allow(missing_docs)] + pub l2SequenceNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberReturn) -> Self { + (value.l2SequenceNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l2SequenceNumber_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2SequenceNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2SequenceNumber()"; + const SELECTOR: [u8; 4] = [153u8, 115u8, 94u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + } + }; + /**Function with signature `resolve()` and selector `0x2810e1d6`. +```solidity +function resolve() external returns (GameStatus status_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveCall; + ///Container type for the return parameters of the [`resolve()`](resolveCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveReturn { + #[allow(missing_docs)] + pub status_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveReturn) -> Self { + (value.status_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { status_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolveCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolve()"; + const SELECTOR: [u8; 4] = [40u8, 16u8, 225u8, 214u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolveReturn = r.into(); + r.status_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolveReturn = r.into(); + r.status_ + }) + } + } + }; + /**Function with signature `resolvedAt()` and selector `0x19effeb4`. +```solidity +function resolvedAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtCall; + ///Container type for the return parameters of the [`resolvedAt()`](resolvedAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolvedAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolvedAt()"; + const SELECTOR: [u8; 4] = [25u8, 239u8, 254u8, 180u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `rootClaim()` and selector `0xbcef3b55`. +```solidity +function rootClaim() external pure returns (Claim rootClaim_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimCall; + ///Container type for the return parameters of the [`rootClaim()`](rootClaimCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimReturn { + #[allow(missing_docs)] + pub rootClaim_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Claim,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimReturn) -> Self { + (value.rootClaim_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { rootClaim_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for rootClaimCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Claim,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "rootClaim()"; + const SELECTOR: [u8; 4] = [188u8, 239u8, 59u8, 85u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r.rootClaim_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r.rootClaim_ + }) + } + } + }; + /**Function with signature `status()` and selector `0x200d2ed2`. +```solidity +function status() external view returns (GameStatus); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusCall; + ///Container type for the return parameters of the [`status()`](statusCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for statusCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "status()"; + const SELECTOR: [u8; 4] = [32u8, 13u8, 46u8, 210u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `wasRespectedGameTypeWhenCreated()` and selector `0x250e69bd`. +```solidity +function wasRespectedGameTypeWhenCreated() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedCall; + ///Container type for the return parameters of the [`wasRespectedGameTypeWhenCreated()`](wasRespectedGameTypeWhenCreatedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for wasRespectedGameTypeWhenCreatedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "wasRespectedGameTypeWhenCreated()"; + const SELECTOR: [u8; 4] = [37u8, 14u8, 105u8, 189u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IDisputeGame`](self) function calls. + #[derive(Clone)] + pub enum IDisputeGameCalls { + #[allow(missing_docs)] + createdAt(createdAtCall), + #[allow(missing_docs)] + extraData(extraDataCall), + #[allow(missing_docs)] + gameCreator(gameCreatorCall), + #[allow(missing_docs)] + gameData(gameDataCall), + #[allow(missing_docs)] + gameType(gameTypeCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + l1Head(l1HeadCall), + #[allow(missing_docs)] + l2SequenceNumber(l2SequenceNumberCall), + #[allow(missing_docs)] + resolve(resolveCall), + #[allow(missing_docs)] + resolvedAt(resolvedAtCall), + #[allow(missing_docs)] + rootClaim(rootClaimCall), + #[allow(missing_docs)] + status(statusCall), + #[allow(missing_docs)] + wasRespectedGameTypeWhenCreated(wasRespectedGameTypeWhenCreatedCall), + } + impl IDisputeGameCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [25u8, 239u8, 254u8, 180u8], + [32u8, 13u8, 46u8, 210u8], + [37u8, 14u8, 105u8, 189u8], + [40u8, 16u8, 225u8, 214u8], + [55u8, 177u8, 178u8, 41u8], + [96u8, 157u8, 51u8, 52u8], + [99u8, 97u8, 80u8, 109u8], + [129u8, 41u8, 252u8, 28u8], + [153u8, 115u8, 94u8, 50u8], + [187u8, 220u8, 2u8, 219u8], + [188u8, 239u8, 59u8, 85u8], + [207u8, 9u8, 224u8, 208u8], + [250u8, 36u8, 247u8, 67u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(resolvedAt), + ::core::stringify!(status), + ::core::stringify!(wasRespectedGameTypeWhenCreated), + ::core::stringify!(resolve), + ::core::stringify!(gameCreator), + ::core::stringify!(extraData), + ::core::stringify!(l1Head), + ::core::stringify!(initialize), + ::core::stringify!(l2SequenceNumber), + ::core::stringify!(gameType), + ::core::stringify!(rootClaim), + ::core::stringify!(createdAt), + ::core::stringify!(gameData), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IDisputeGameCalls { + const NAME: &'static str = "IDisputeGameCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 13usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::createdAt(_) => { + ::SELECTOR + } + Self::extraData(_) => { + ::SELECTOR + } + Self::gameCreator(_) => { + ::SELECTOR + } + Self::gameData(_) => ::SELECTOR, + Self::gameType(_) => ::SELECTOR, + Self::initialize(_) => { + ::SELECTOR + } + Self::l1Head(_) => ::SELECTOR, + Self::l2SequenceNumber(_) => { + ::SELECTOR + } + Self::resolve(_) => ::SELECTOR, + Self::resolvedAt(_) => { + ::SELECTOR + } + Self::rootClaim(_) => { + ::SELECTOR + } + Self::status(_) => ::SELECTOR, + Self::wasRespectedGameTypeWhenCreated(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameCalls::status) + } + status + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameCalls::wasRespectedGameTypeWhenCreated) + } + wasRespectedGameTypeWhenCreated + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameCalls::resolve) + } + resolve + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameCalls::extraData) + } + extraData + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameCalls::initialize) + } + initialize + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameCalls::gameType) + } + gameType + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameCalls::gameData) + } + gameData + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::status) + } + status + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::wasRespectedGameTypeWhenCreated) + } + wasRespectedGameTypeWhenCreated + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::resolve) + } + resolve + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::extraData) + } + extraData + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::initialize) + } + initialize + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::gameType) + } + gameType + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameCalls::gameData) + } + gameData + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::createdAt(inner) => { + ::abi_encoded_size(inner) + } + Self::extraData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameCreator(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::gameData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameType(inner) => { + ::abi_encoded_size(inner) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::l1Head(inner) => { + ::abi_encoded_size(inner) + } + Self::l2SequenceNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::resolve(inner) => { + ::abi_encoded_size(inner) + } + Self::resolvedAt(inner) => { + ::abi_encoded_size(inner) + } + Self::rootClaim(inner) => { + ::abi_encoded_size(inner) + } + Self::status(inner) => { + ::abi_encoded_size(inner) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::createdAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::extraData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameCreator(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l1Head(inner) => { + ::abi_encode_raw(inner, out) + } + Self::l2SequenceNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::resolve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::resolvedAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::rootClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::status(inner) => { + ::abi_encode_raw(inner, out) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`IDisputeGame`](self) events. + #[derive(Clone)] + pub enum IDisputeGameEvents { + #[allow(missing_docs)] + Resolved(Resolved), + } + impl IDisputeGameEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(Resolved), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IDisputeGameEvents { + const NAME: &'static str = "IDisputeGameEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Resolved) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for IDisputeGameEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`IDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> IDisputeGameInstance { + IDisputeGameInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IDisputeGameInstance::::deploy(__provider) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(__provider: P) -> alloy_contract::RawCallBuilder { + IDisputeGameInstance::::deploy_builder(__provider) + } + /**A [`IDisputeGame`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IDisputeGame`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct IDisputeGameInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IDisputeGameInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IDisputeGameInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IDisputeGameInstance { + /**Creates a new wrapper around an on-chain [`IDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`IDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + ::core::clone::Clone::clone(&BYTECODE), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl IDisputeGameInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IDisputeGameInstance { + IDisputeGameInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IDisputeGameInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`createdAt`] function. + pub fn createdAt(&self) -> alloy_contract::SolCallBuilder<&P, createdAtCall, N> { + self.call_builder(&createdAtCall) + } + ///Creates a new call builder for the [`extraData`] function. + pub fn extraData(&self) -> alloy_contract::SolCallBuilder<&P, extraDataCall, N> { + self.call_builder(&extraDataCall) + } + ///Creates a new call builder for the [`gameCreator`] function. + pub fn gameCreator( + &self, + ) -> alloy_contract::SolCallBuilder<&P, gameCreatorCall, N> { + self.call_builder(&gameCreatorCall) + } + ///Creates a new call builder for the [`gameData`] function. + pub fn gameData(&self) -> alloy_contract::SolCallBuilder<&P, gameDataCall, N> { + self.call_builder(&gameDataCall) + } + ///Creates a new call builder for the [`gameType`] function. + pub fn gameType(&self) -> alloy_contract::SolCallBuilder<&P, gameTypeCall, N> { + self.call_builder(&gameTypeCall) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder(&initializeCall) + } + ///Creates a new call builder for the [`l1Head`] function. + pub fn l1Head(&self) -> alloy_contract::SolCallBuilder<&P, l1HeadCall, N> { + self.call_builder(&l1HeadCall) + } + ///Creates a new call builder for the [`l2SequenceNumber`] function. + pub fn l2SequenceNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2SequenceNumberCall, N> { + self.call_builder(&l2SequenceNumberCall) + } + ///Creates a new call builder for the [`resolve`] function. + pub fn resolve(&self) -> alloy_contract::SolCallBuilder<&P, resolveCall, N> { + self.call_builder(&resolveCall) + } + ///Creates a new call builder for the [`resolvedAt`] function. + pub fn resolvedAt( + &self, + ) -> alloy_contract::SolCallBuilder<&P, resolvedAtCall, N> { + self.call_builder(&resolvedAtCall) + } + ///Creates a new call builder for the [`rootClaim`] function. + pub fn rootClaim(&self) -> alloy_contract::SolCallBuilder<&P, rootClaimCall, N> { + self.call_builder(&rootClaimCall) + } + ///Creates a new call builder for the [`status`] function. + pub fn status(&self) -> alloy_contract::SolCallBuilder<&P, statusCall, N> { + self.call_builder(&statusCall) + } + ///Creates a new call builder for the [`wasRespectedGameTypeWhenCreated`] function. + pub fn wasRespectedGameTypeWhenCreated( + &self, + ) -> alloy_contract::SolCallBuilder<&P, wasRespectedGameTypeWhenCreatedCall, N> { + self.call_builder(&wasRespectedGameTypeWhenCreatedCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IDisputeGameInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`Resolved`] event. + pub fn Resolved_filter(&self) -> alloy_contract::Event<&P, Resolved, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/i_dispute_game_factory.rs b/bindings/src/codegen/i_dispute_game_factory.rs new file mode 100644 index 000000000..d10814134 --- /dev/null +++ b/bindings/src/codegen/i_dispute_game_factory.rs @@ -0,0 +1,8350 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IDisputeGameFactory { + type Claim is bytes32; + type GameId is bytes32; + type GameType is uint32; + type Hash is bytes32; + type Timestamp is uint64; + struct GameSearchResult { + uint256 index; + GameId metadata; + Timestamp timestamp; + Claim rootClaim; + bytes extraData; + } + + error GameAlreadyExists(Hash uuid); + error IncorrectBondAmount(); + error NoImplementation(GameType gameType); + error ProxyAdminOwnedBase_NotProxyAdmin(); + error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); + error ProxyAdminOwnedBase_NotProxyAdminOwner(); + error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); + error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); + error ProxyAdminOwnedBase_ProxyAdminNotFound(); + error ReinitializableBase_ZeroInitVersion(); + + event DisputeGameCreated(address indexed disputeProxy, GameType indexed gameType, Claim indexed rootClaim); + event ImplementationArgsSet(GameType indexed gameType, bytes args); + event ImplementationSet(address indexed impl, GameType indexed gameType); + event InitBondUpdated(GameType indexed gameType, uint256 indexed newBond); + event Initialized(uint8 version); + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + function __constructor__() external; + function create(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external payable returns (address proxy_); + function findLatestGames(GameType _gameType, uint256 _start, uint256 _n) external view returns (GameSearchResult[] memory games_); + function gameArgs(GameType) external view returns (bytes memory); + function gameAtIndex(uint256 _index) external view returns (GameType gameType_, Timestamp timestamp_, address proxy_); + function gameCount() external view returns (uint256 gameCount_); + function gameImpls(GameType) external view returns (address); + function games(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external view returns (address proxy_, Timestamp timestamp_); + function getGameUUID(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external pure returns (Hash uuid_); + function initBonds(GameType) external view returns (uint256); + function initVersion() external view returns (uint8); + function initialize(address _owner) external; + function owner() external view returns (address); + function proxyAdmin() external view returns (address); + function proxyAdminOwner() external view returns (address); + function renounceOwnership() external; + function setImplementation(GameType _gameType, address _impl) external; + function setImplementation(GameType _gameType, address _impl, bytes memory _args) external; + function setInitBond(GameType _gameType, uint256 _initBond) external; + function transferOwnership(address newOwner) external; + function version() external view returns (string memory); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "__constructor__", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "create", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_rootClaim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_extraData", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "proxy_", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "findLatestGames", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_start", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_n", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "games_", + "type": "tuple[]", + "internalType": "struct IDisputeGameFactory.GameSearchResult[]", + "components": [ + { + "name": "index", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "metadata", + "type": "bytes32", + "internalType": "GameId" + }, + { + "name": "timestamp", + "type": "uint64", + "internalType": "Timestamp" + }, + { + "name": "rootClaim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "extraData", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameArgs", + "inputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [ + { + "name": "", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameAtIndex", + "inputs": [ + { + "name": "_index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "timestamp_", + "type": "uint64", + "internalType": "Timestamp" + }, + { + "name": "proxy_", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameCount", + "inputs": [], + "outputs": [ + { + "name": "gameCount_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameImpls", + "inputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "games", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_rootClaim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_extraData", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "proxy_", + "type": "address", + "internalType": "contract IDisputeGame" + }, + { + "name": "timestamp_", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getGameUUID", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_rootClaim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_extraData", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "uuid_", + "type": "bytes32", + "internalType": "Hash" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "initBonds", + "inputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initVersion", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [ + { + "name": "_owner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdmin", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IProxyAdmin" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdminOwner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setImplementation", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_impl", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setImplementation", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_impl", + "type": "address", + "internalType": "contract IDisputeGame" + }, + { + "name": "_args", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setInitBond", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_initBond", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "DisputeGameCreated", + "inputs": [ + { + "name": "disputeProxy", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "gameType", + "type": "uint32", + "indexed": true, + "internalType": "GameType" + }, + { + "name": "rootClaim", + "type": "bytes32", + "indexed": true, + "internalType": "Claim" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ImplementationArgsSet", + "inputs": [ + { + "name": "gameType", + "type": "uint32", + "indexed": true, + "internalType": "GameType" + }, + { + "name": "args", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ImplementationSet", + "inputs": [ + { + "name": "impl", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "gameType", + "type": "uint32", + "indexed": true, + "internalType": "GameType" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "InitBondUpdated", + "inputs": [ + { + "name": "gameType", + "type": "uint32", + "indexed": true, + "internalType": "GameType" + }, + { + "name": "newBond", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Initialized", + "inputs": [ + { + "name": "version", + "type": "uint8", + "indexed": false, + "internalType": "uint8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "GameAlreadyExists", + "inputs": [ + { + "name": "uuid", + "type": "bytes32", + "internalType": "Hash" + } + ] + }, + { + "type": "error", + "name": "IncorrectBondAmount", + "inputs": [] + }, + { + "type": "error", + "name": "NoImplementation", + "inputs": [ + { + "name": "gameType", + "type": "uint32", + "internalType": "GameType" + } + ] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdmin", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotResolvedDelegateProxy", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotSharedProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_ProxyAdminNotFound", + "inputs": [] + }, + { + "type": "error", + "name": "ReinitializableBase_ZeroInitVersion", + "inputs": [] + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod IDisputeGameFactory { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Claim(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Claim { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Claim { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Claim) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Claim { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Claim { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameId(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameId { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for GameId { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: GameId) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameId { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameId { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Hash(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Hash { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Hash { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Hash) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Hash { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Hash { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Timestamp(u64); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u64 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<64>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Timestamp { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u64) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u64 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Timestamp { + fn from(value: u64) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u64 { + fn from(value: Timestamp) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Timestamp { + type RustType = u64; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Timestamp { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**```solidity +struct GameSearchResult { uint256 index; GameId metadata; Timestamp timestamp; Claim rootClaim; bytes extraData; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameSearchResult { + #[allow(missing_docs)] + pub index: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub metadata: ::RustType, + #[allow(missing_docs)] + pub timestamp: ::RustType, + #[allow(missing_docs)] + pub rootClaim: ::RustType, + #[allow(missing_docs)] + pub extraData: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + GameId, + Timestamp, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameSearchResult) -> Self { + ( + value.index, + value.metadata, + value.timestamp, + value.rootClaim, + value.extraData, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameSearchResult { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + index: tuple.0, + metadata: tuple.1, + timestamp: tuple.2, + rootClaim: tuple.3, + extraData: tuple.4, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for GameSearchResult { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for GameSearchResult { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.index), + ::tokenize(&self.metadata), + ::tokenize(&self.timestamp), + ::tokenize(&self.rootClaim), + ::tokenize( + &self.extraData, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameSearchResult { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for GameSearchResult { + const NAME: &'static str = "GameSearchResult"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "GameSearchResult(uint256 index,bytes32 metadata,uint64 timestamp,bytes32 rootClaim,bytes extraData)", + ) + } + #[inline] + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { + alloy_sol_types::private::Vec::new() + } + #[inline] + fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.index) + .0, + ::eip712_data_word( + &self.metadata, + ) + .0, + ::eip712_data_word( + &self.timestamp, + ) + .0, + ::eip712_data_word( + &self.rootClaim, + ) + .0, + ::eip712_data_word( + &self.extraData, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameSearchResult { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.index) + + ::topic_preimage_length( + &rust.metadata, + ) + + ::topic_preimage_length( + &rust.timestamp, + ) + + ::topic_preimage_length( + &rust.rootClaim, + ) + + ::topic_preimage_length( + &rust.extraData, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.index, + out, + ); + ::encode_topic_preimage( + &rust.metadata, + out, + ); + ::encode_topic_preimage( + &rust.timestamp, + out, + ); + ::encode_topic_preimage( + &rust.rootClaim, + out, + ); + ::encode_topic_preimage( + &rust.extraData, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + /**Custom error with signature `GameAlreadyExists(bytes32)` and selector `0x014f6fe5`. +```solidity +error GameAlreadyExists(Hash uuid); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameAlreadyExists { + #[allow(missing_docs)] + pub uuid: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (::RustType,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameAlreadyExists) -> Self { + (value.uuid,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameAlreadyExists { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { uuid: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameAlreadyExists { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameAlreadyExists(bytes32)"; + const SELECTOR: [u8; 4] = [1u8, 79u8, 111u8, 229u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.uuid),) + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `IncorrectBondAmount()` and selector `0x8620aa19`. +```solidity +error IncorrectBondAmount(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IncorrectBondAmount; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IncorrectBondAmount) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IncorrectBondAmount { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for IncorrectBondAmount { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IncorrectBondAmount()"; + const SELECTOR: [u8; 4] = [134u8, 32u8, 170u8, 25u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `NoImplementation(uint32)` and selector `0x031c6de4`. +```solidity +error NoImplementation(GameType gameType); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct NoImplementation { + #[allow(missing_docs)] + pub gameType: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: NoImplementation) -> Self { + (value.gameType,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for NoImplementation { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { gameType: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for NoImplementation { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "NoImplementation(uint32)"; + const SELECTOR: [u8; 4] = [3u8, 28u8, 109u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.gameType),) + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdmin()` and selector `0xe818dcc3`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdmin(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdmin; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdmin) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdmin { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdmin { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdmin()"; + const SELECTOR: [u8; 4] = [232u8, 24u8, 220u8, 195u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()` and selector `0xc4050a26`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [196u8, 5u8, 10u8, 38u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOwner()` and selector `0x7f12c64b`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [127u8, 18u8, 198u8, 75u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotResolvedDelegateProxy()` and selector `0x54e433cd`. +```solidity +error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotResolvedDelegateProxy; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotResolvedDelegateProxy) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotResolvedDelegateProxy()"; + const SELECTOR: [u8; 4] = [84u8, 228u8, 51u8, 205u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotSharedProxyAdminOwner()` and selector `0x075c4314`. +```solidity +error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotSharedProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotSharedProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotSharedProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [7u8, 92u8, 67u8, 20u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_ProxyAdminNotFound()` and selector `0x332144db`. +```solidity +error ProxyAdminOwnedBase_ProxyAdminNotFound(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_ProxyAdminNotFound; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_ProxyAdminNotFound) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_ProxyAdminNotFound { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_ProxyAdminNotFound { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_ProxyAdminNotFound()"; + const SELECTOR: [u8; 4] = [51u8, 33u8, 68u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ReinitializableBase_ZeroInitVersion()` and selector `0x9b01afed`. +```solidity +error ReinitializableBase_ZeroInitVersion(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ReinitializableBase_ZeroInitVersion; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ReinitializableBase_ZeroInitVersion) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ReinitializableBase_ZeroInitVersion { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ReinitializableBase_ZeroInitVersion { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ReinitializableBase_ZeroInitVersion()"; + const SELECTOR: [u8; 4] = [155u8, 1u8, 175u8, 237u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Event with signature `DisputeGameCreated(address,uint32,bytes32)` and selector `0x5b565efe82411da98814f356d0e7bcb8f0219b8d970307c5afb4a6903a8b2e35`. +```solidity +event DisputeGameCreated(address indexed disputeProxy, GameType indexed gameType, Claim indexed rootClaim); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct DisputeGameCreated { + #[allow(missing_docs)] + pub disputeProxy: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub gameType: ::RustType, + #[allow(missing_docs)] + pub rootClaim: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for DisputeGameCreated { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + GameType, + Claim, + ); + const SIGNATURE: &'static str = "DisputeGameCreated(address,uint32,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 91u8, 86u8, 94u8, 254u8, 130u8, 65u8, 29u8, 169u8, 136u8, 20u8, 243u8, + 86u8, 208u8, 231u8, 188u8, 184u8, 240u8, 33u8, 155u8, 141u8, 151u8, 3u8, + 7u8, 197u8, 175u8, 180u8, 166u8, 144u8, 58u8, 139u8, 46u8, 53u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + disputeProxy: topics.1, + gameType: topics.2, + rootClaim: topics.3, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.disputeProxy.clone(), + self.gameType.clone(), + self.rootClaim.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.disputeProxy, + ); + out[2usize] = ::encode_topic( + &self.gameType, + ); + out[3usize] = ::encode_topic( + &self.rootClaim, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for DisputeGameCreated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&DisputeGameCreated> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &DisputeGameCreated) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `ImplementationArgsSet(uint32,bytes)` and selector `0xa47fcdf075d680d3817bfca7973b373e1a5f6cfc3b444748299cc2b83d8348f9`. +```solidity +event ImplementationArgsSet(GameType indexed gameType, bytes args); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct ImplementationArgsSet { + #[allow(missing_docs)] + pub gameType: ::RustType, + #[allow(missing_docs)] + pub args: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for ImplementationArgsSet { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>, GameType); + const SIGNATURE: &'static str = "ImplementationArgsSet(uint32,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 164u8, 127u8, 205u8, 240u8, 117u8, 214u8, 128u8, 211u8, 129u8, 123u8, + 252u8, 167u8, 151u8, 59u8, 55u8, 62u8, 26u8, 95u8, 108u8, 252u8, 59u8, + 68u8, 71u8, 72u8, 41u8, 156u8, 194u8, 184u8, 61u8, 131u8, 72u8, 249u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + gameType: topics.1, + args: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.gameType.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.gameType, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for ImplementationArgsSet { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ImplementationArgsSet> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &ImplementationArgsSet) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `ImplementationSet(address,uint32)` and selector `0xff513d80e2c7fa487608f70a618dfbc0cf415699dc69588c747e8c71566c88de`. +```solidity +event ImplementationSet(address indexed r#impl, GameType indexed gameType); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct ImplementationSet { + #[allow(missing_docs)] + pub r#impl: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub gameType: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for ImplementationSet { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + GameType, + ); + const SIGNATURE: &'static str = "ImplementationSet(address,uint32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 255u8, 81u8, 61u8, 128u8, 226u8, 199u8, 250u8, 72u8, 118u8, 8u8, 247u8, + 10u8, 97u8, 141u8, 251u8, 192u8, 207u8, 65u8, 86u8, 153u8, 220u8, 105u8, + 88u8, 140u8, 116u8, 126u8, 140u8, 113u8, 86u8, 108u8, 136u8, 222u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + r#impl: topics.1, + gameType: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.r#impl.clone(), self.gameType.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.r#impl, + ); + out[2usize] = ::encode_topic( + &self.gameType, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for ImplementationSet { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ImplementationSet> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &ImplementationSet) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `InitBondUpdated(uint32,uint256)` and selector `0x74d6665c4b26d5596a5aa13d3014e0c06af4d322075a797f87b03cd4c5bc91ca`. +```solidity +event InitBondUpdated(GameType indexed gameType, uint256 indexed newBond); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct InitBondUpdated { + #[allow(missing_docs)] + pub gameType: ::RustType, + #[allow(missing_docs)] + pub newBond: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for InitBondUpdated { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + GameType, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "InitBondUpdated(uint32,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 116u8, 214u8, 102u8, 92u8, 75u8, 38u8, 213u8, 89u8, 106u8, 90u8, 161u8, + 61u8, 48u8, 20u8, 224u8, 192u8, 106u8, 244u8, 211u8, 34u8, 7u8, 90u8, + 121u8, 127u8, 135u8, 176u8, 60u8, 212u8, 197u8, 188u8, 145u8, 202u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + gameType: topics.1, + newBond: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.gameType.clone(), + self.newBond.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.gameType, + ); + out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.newBond); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for InitBondUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&InitBondUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &InitBondUpdated) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`. +```solidity +event Initialized(uint8 version); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Initialized { + #[allow(missing_docs)] + pub version: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Initialized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Initialized(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { version: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Initialized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Initialized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Initialized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`. +```solidity +event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct OwnershipTransferred { + #[allow(missing_docs)] + pub previousOwner: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub newOwner: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "OwnershipTransferred(address,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, + 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, + 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.previousOwner.clone(), + self.newOwner.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::encode_topic( + &self.newOwner, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OwnershipTransferred { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Function with signature `__constructor__()` and selector `0x1c0082a3`. +```solidity +function __constructor__() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct __constructor__Call; + ///Container type for the return parameters of the [`__constructor__()`](__constructor__Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct __constructor__Return {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From<__constructor__Call> for UnderlyingRustTuple<'_> { + fn from(value: __constructor__Call) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for __constructor__Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From<__constructor__Return> + for UnderlyingRustTuple<'_> { + fn from(value: __constructor__Return) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for __constructor__Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl __constructor__Return { + fn _tokenize( + &self, + ) -> <__constructor__Call as alloy_sol_types::SolCall>::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for __constructor__Call { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = __constructor__Return; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "__constructor__()"; + const SELECTOR: [u8; 4] = [28u8, 0u8, 130u8, 163u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + __constructor__Return::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `create(uint32,bytes32,bytes)` and selector `0x82ecf2f6`. +```solidity +function create(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external payable returns (address proxy_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _rootClaim: ::RustType, + #[allow(missing_docs)] + pub _extraData: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`create(uint32,bytes32,bytes)`](createCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createReturn { + #[allow(missing_docs)] + pub proxy_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createCall) -> Self { + (value._gameType, value._rootClaim, value._extraData) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _rootClaim: tuple.1, + _extraData: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createReturn) -> Self { + (value.proxy_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { proxy_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createCall { + type Parameters<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "create(uint32,bytes32,bytes)"; + const SELECTOR: [u8; 4] = [130u8, 236u8, 242u8, 246u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize(&self._rootClaim), + ::tokenize( + &self._extraData, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createReturn = r.into(); + r.proxy_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createReturn = r.into(); + r.proxy_ + }) + } + } + }; + /**Function with signature `findLatestGames(uint32,uint256,uint256)` and selector `0x254bd683`. +```solidity +function findLatestGames(GameType _gameType, uint256 _start, uint256 _n) external view returns (GameSearchResult[] memory games_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct findLatestGamesCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _start: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _n: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`findLatestGames(uint32,uint256,uint256)`](findLatestGamesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct findLatestGamesReturn { + #[allow(missing_docs)] + pub games_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: findLatestGamesCall) -> Self { + (value._gameType, value._start, value._n) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for findLatestGamesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _start: tuple.1, + _n: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: findLatestGamesReturn) -> Self { + (value.games_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for findLatestGamesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { games_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for findLatestGamesCall { + type Parameters<'a> = ( + GameType, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "findLatestGames(uint32,uint256,uint256)"; + const SELECTOR: [u8; 4] = [37u8, 75u8, 214u8, 131u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + as alloy_sol_types::SolType>::tokenize(&self._start), + as alloy_sol_types::SolType>::tokenize(&self._n), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: findLatestGamesReturn = r.into(); + r.games_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: findLatestGamesReturn = r.into(); + r.games_ + }) + } + } + }; + /**Function with signature `gameArgs(uint32)` and selector `0x74cc86ac`. +```solidity +function gameArgs(GameType) external view returns (bytes memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameArgsCall(pub ::RustType); + ///Container type for the return parameters of the [`gameArgs(uint32)`](gameArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameArgsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameArgsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameArgsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameArgsCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Bytes; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameArgs(uint32)"; + const SELECTOR: [u8; 4] = [116u8, 204u8, 134u8, 172u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.0),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameArgsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameArgsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `gameAtIndex(uint256)` and selector `0xbb8aa1fc`. +```solidity +function gameAtIndex(uint256 _index) external view returns (GameType gameType_, Timestamp timestamp_, address proxy_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameAtIndexCall { + #[allow(missing_docs)] + pub _index: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`gameAtIndex(uint256)`](gameAtIndexCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameAtIndexReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + #[allow(missing_docs)] + pub timestamp_: ::RustType, + #[allow(missing_docs)] + pub proxy_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameAtIndexCall) -> Self { + (value._index,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameAtIndexCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _index: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Timestamp, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameAtIndexReturn) -> Self { + (value.gameType_, value.timestamp_, value.proxy_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameAtIndexReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + gameType_: tuple.0, + timestamp_: tuple.1, + proxy_: tuple.2, + } + } + } + } + impl gameAtIndexReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.gameType_), + ::tokenize(&self.timestamp_), + ::tokenize( + &self.proxy_, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameAtIndexCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = gameAtIndexReturn; + type ReturnTuple<'a> = ( + GameType, + Timestamp, + alloy::sol_types::sol_data::Address, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameAtIndex(uint256)"; + const SELECTOR: [u8; 4] = [187u8, 138u8, 161u8, 252u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._index), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + gameAtIndexReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `gameCount()` and selector `0x4d1975b4`. +```solidity +function gameCount() external view returns (uint256 gameCount_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCountCall; + ///Container type for the return parameters of the [`gameCount()`](gameCountCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCountReturn { + #[allow(missing_docs)] + pub gameCount_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCountCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCountCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCountReturn) -> Self { + (value.gameCount_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCountReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { gameCount_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameCountCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameCount()"; + const SELECTOR: [u8; 4] = [77u8, 25u8, 117u8, 180u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameCountReturn = r.into(); + r.gameCount_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameCountReturn = r.into(); + r.gameCount_ + }) + } + } + }; + /**Function with signature `gameImpls(uint32)` and selector `0x1b685b9e`. +```solidity +function gameImpls(GameType) external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameImplsCall(pub ::RustType); + ///Container type for the return parameters of the [`gameImpls(uint32)`](gameImplsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameImplsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameImplsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameImplsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameImplsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameImplsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameImplsCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameImpls(uint32)"; + const SELECTOR: [u8; 4] = [27u8, 104u8, 91u8, 158u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.0),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameImplsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameImplsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `games(uint32,bytes32,bytes)` and selector `0x5f0150cb`. +```solidity +function games(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external view returns (address proxy_, Timestamp timestamp_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gamesCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _rootClaim: ::RustType, + #[allow(missing_docs)] + pub _extraData: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`games(uint32,bytes32,bytes)`](gamesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gamesReturn { + #[allow(missing_docs)] + pub proxy_: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub timestamp_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gamesCall) -> Self { + (value._gameType, value._rootClaim, value._extraData) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gamesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _rootClaim: tuple.1, + _extraData: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + Timestamp, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gamesReturn) -> Self { + (value.proxy_, value.timestamp_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gamesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + proxy_: tuple.0, + timestamp_: tuple.1, + } + } + } + } + impl gamesReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize( + &self.proxy_, + ), + ::tokenize(&self.timestamp_), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gamesCall { + type Parameters<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = gamesReturn; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address, Timestamp); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "games(uint32,bytes32,bytes)"; + const SELECTOR: [u8; 4] = [95u8, 1u8, 80u8, 203u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize(&self._rootClaim), + ::tokenize( + &self._extraData, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + gamesReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `getGameUUID(uint32,bytes32,bytes)` and selector `0x96cd9720`. +```solidity +function getGameUUID(GameType _gameType, Claim _rootClaim, bytes memory _extraData) external pure returns (Hash uuid_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getGameUUIDCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _rootClaim: ::RustType, + #[allow(missing_docs)] + pub _extraData: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`getGameUUID(uint32,bytes32,bytes)`](getGameUUIDCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getGameUUIDReturn { + #[allow(missing_docs)] + pub uuid_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getGameUUIDCall) -> Self { + (value._gameType, value._rootClaim, value._extraData) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getGameUUIDCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _rootClaim: tuple.1, + _extraData: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getGameUUIDReturn) -> Self { + (value.uuid_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getGameUUIDReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { uuid_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getGameUUIDCall { + type Parameters<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Hash,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getGameUUID(uint32,bytes32,bytes)"; + const SELECTOR: [u8; 4] = [150u8, 205u8, 151u8, 32u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize(&self._rootClaim), + ::tokenize( + &self._extraData, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getGameUUIDReturn = r.into(); + r.uuid_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getGameUUIDReturn = r.into(); + r.uuid_ + }) + } + } + }; + /**Function with signature `initBonds(uint32)` and selector `0x6593dc6e`. +```solidity +function initBonds(GameType) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initBondsCall(pub ::RustType); + ///Container type for the return parameters of the [`initBonds(uint32)`](initBondsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initBondsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initBondsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initBondsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initBondsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initBondsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initBondsCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initBonds(uint32)"; + const SELECTOR: [u8; 4] = [101u8, 147u8, 220u8, 110u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.0),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: initBondsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: initBondsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initVersion()` and selector `0x38d38c97`. +```solidity +function initVersion() external view returns (uint8); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionCall; + ///Container type for the return parameters of the [`initVersion()`](initVersionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionReturn { + #[allow(missing_docs)] + pub _0: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u8,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initVersionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initVersion()"; + const SELECTOR: [u8; 4] = [56u8, 211u8, 140u8, 151u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initialize(address)` and selector `0xc4d66de8`. +```solidity +function initialize(address _owner) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall { + #[allow(missing_docs)] + pub _owner: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`initialize(address)`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + (value._owner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _owner: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize(address)"; + const SELECTOR: [u8; 4] = [196u8, 214u8, 109u8, 232u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._owner, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `owner()` and selector `0x8da5cb5b`. +```solidity +function owner() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ownerCall; + ///Container type for the return parameters of the [`owner()`](ownerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ownerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdmin()` and selector `0x3e47158c`. +```solidity +function proxyAdmin() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminCall; + ///Container type for the return parameters of the [`proxyAdmin()`](proxyAdminCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdmin()"; + const SELECTOR: [u8; 4] = [62u8, 71u8, 21u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdminOwner()` and selector `0xdad544e0`. +```solidity +function proxyAdminOwner() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerCall; + ///Container type for the return parameters of the [`proxyAdminOwner()`](proxyAdminOwnerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminOwnerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proxyAdminOwnerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminOwnerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdminOwner()"; + const SELECTOR: [u8; 4] = [218u8, 213u8, 68u8, 224u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `renounceOwnership()` and selector `0x715018a6`. +```solidity +function renounceOwnership() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct renounceOwnershipCall; + ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct renounceOwnershipReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl renounceOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for renounceOwnershipCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = renounceOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "renounceOwnership()"; + const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + renounceOwnershipReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setImplementation(uint32,address)` and selector `0x14f6b1a3`. +```solidity +function setImplementation(GameType _gameType, address _impl) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setImplementation_0Call { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _impl: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`setImplementation(uint32,address)`](setImplementation_0Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setImplementation_0Return {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setImplementation_0Call) -> Self { + (value._gameType, value._impl) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setImplementation_0Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _impl: tuple.1, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setImplementation_0Return) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setImplementation_0Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setImplementation_0Return { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setImplementation_0Call { + type Parameters<'a> = (GameType, alloy::sol_types::sol_data::Address); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setImplementation_0Return; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setImplementation(uint32,address)"; + const SELECTOR: [u8; 4] = [20u8, 246u8, 177u8, 163u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize( + &self._impl, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setImplementation_0Return::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setImplementation(uint32,address,bytes)` and selector `0xb1070957`. +```solidity +function setImplementation(GameType _gameType, address _impl, bytes memory _args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setImplementation_1Call { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _impl: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _args: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`setImplementation(uint32,address,bytes)`](setImplementation_1Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setImplementation_1Return {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::Address, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setImplementation_1Call) -> Self { + (value._gameType, value._impl, value._args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setImplementation_1Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _impl: tuple.1, + _args: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setImplementation_1Return) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setImplementation_1Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setImplementation_1Return { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setImplementation_1Call { + type Parameters<'a> = ( + GameType, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bytes, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setImplementation_1Return; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setImplementation(uint32,address,bytes)"; + const SELECTOR: [u8; 4] = [177u8, 7u8, 9u8, 87u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + ::tokenize( + &self._impl, + ), + ::tokenize( + &self._args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setImplementation_1Return::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `setInitBond(uint32,uint256)` and selector `0x1e334240`. +```solidity +function setInitBond(GameType _gameType, uint256 _initBond) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setInitBondCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + #[allow(missing_docs)] + pub _initBond: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`setInitBond(uint32,uint256)`](setInitBondCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setInitBondReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setInitBondCall) -> Self { + (value._gameType, value._initBond) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setInitBondCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _gameType: tuple.0, + _initBond: tuple.1, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setInitBondReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setInitBondReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setInitBondReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setInitBondCall { + type Parameters<'a> = (GameType, alloy::sol_types::sol_data::Uint<256>); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setInitBondReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setInitBond(uint32,uint256)"; + const SELECTOR: [u8; 4] = [30u8, 51u8, 66u8, 64u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._gameType), + as alloy_sol_types::SolType>::tokenize(&self._initBond), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setInitBondReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`. +```solidity +function transferOwnership(address newOwner) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct transferOwnershipCall { + #[allow(missing_docs)] + pub newOwner: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct transferOwnershipReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value.newOwner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newOwner: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.newOwner, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + transferOwnershipReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `version()` and selector `0x54fd4d50`. +```solidity +function version() external view returns (string memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionCall; + ///Container type for the return parameters of the [`version()`](versionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for versionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "version()"; + const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IDisputeGameFactory`](self) function calls. + #[derive(Clone)] + pub enum IDisputeGameFactoryCalls { + #[allow(missing_docs)] + __constructor__(__constructor__Call), + #[allow(missing_docs)] + create(createCall), + #[allow(missing_docs)] + findLatestGames(findLatestGamesCall), + #[allow(missing_docs)] + gameArgs(gameArgsCall), + #[allow(missing_docs)] + gameAtIndex(gameAtIndexCall), + #[allow(missing_docs)] + gameCount(gameCountCall), + #[allow(missing_docs)] + gameImpls(gameImplsCall), + #[allow(missing_docs)] + games(gamesCall), + #[allow(missing_docs)] + getGameUUID(getGameUUIDCall), + #[allow(missing_docs)] + initBonds(initBondsCall), + #[allow(missing_docs)] + initVersion(initVersionCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + owner(ownerCall), + #[allow(missing_docs)] + proxyAdmin(proxyAdminCall), + #[allow(missing_docs)] + proxyAdminOwner(proxyAdminOwnerCall), + #[allow(missing_docs)] + renounceOwnership(renounceOwnershipCall), + #[allow(missing_docs)] + setImplementation_0(setImplementation_0Call), + #[allow(missing_docs)] + setImplementation_1(setImplementation_1Call), + #[allow(missing_docs)] + setInitBond(setInitBondCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + #[allow(missing_docs)] + version(versionCall), + } + impl IDisputeGameFactoryCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [20u8, 246u8, 177u8, 163u8], + [27u8, 104u8, 91u8, 158u8], + [28u8, 0u8, 130u8, 163u8], + [30u8, 51u8, 66u8, 64u8], + [37u8, 75u8, 214u8, 131u8], + [56u8, 211u8, 140u8, 151u8], + [62u8, 71u8, 21u8, 140u8], + [77u8, 25u8, 117u8, 180u8], + [84u8, 253u8, 77u8, 80u8], + [95u8, 1u8, 80u8, 203u8], + [101u8, 147u8, 220u8, 110u8], + [113u8, 80u8, 24u8, 166u8], + [116u8, 204u8, 134u8, 172u8], + [130u8, 236u8, 242u8, 246u8], + [141u8, 165u8, 203u8, 91u8], + [150u8, 205u8, 151u8, 32u8], + [177u8, 7u8, 9u8, 87u8], + [187u8, 138u8, 161u8, 252u8], + [196u8, 214u8, 109u8, 232u8], + [218u8, 213u8, 68u8, 224u8], + [242u8, 253u8, 227u8, 139u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(setImplementation_0), + ::core::stringify!(gameImpls), + ::core::stringify!(__constructor__), + ::core::stringify!(setInitBond), + ::core::stringify!(findLatestGames), + ::core::stringify!(initVersion), + ::core::stringify!(proxyAdmin), + ::core::stringify!(gameCount), + ::core::stringify!(version), + ::core::stringify!(games), + ::core::stringify!(initBonds), + ::core::stringify!(renounceOwnership), + ::core::stringify!(gameArgs), + ::core::stringify!(create), + ::core::stringify!(owner), + ::core::stringify!(getGameUUID), + ::core::stringify!(setImplementation_1), + ::core::stringify!(gameAtIndex), + ::core::stringify!(initialize), + ::core::stringify!(proxyAdminOwner), + ::core::stringify!(transferOwnership), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + <__constructor__Call as alloy_sol_types::SolCall>::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IDisputeGameFactoryCalls { + const NAME: &'static str = "IDisputeGameFactoryCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 21usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::__constructor__(_) => { + <__constructor__Call as alloy_sol_types::SolCall>::SELECTOR + } + Self::create(_) => ::SELECTOR, + Self::findLatestGames(_) => { + ::SELECTOR + } + Self::gameArgs(_) => ::SELECTOR, + Self::gameAtIndex(_) => { + ::SELECTOR + } + Self::gameCount(_) => { + ::SELECTOR + } + Self::gameImpls(_) => { + ::SELECTOR + } + Self::games(_) => ::SELECTOR, + Self::getGameUUID(_) => { + ::SELECTOR + } + Self::initBonds(_) => { + ::SELECTOR + } + Self::initVersion(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } + Self::owner(_) => ::SELECTOR, + Self::proxyAdmin(_) => { + ::SELECTOR + } + Self::proxyAdminOwner(_) => { + ::SELECTOR + } + Self::renounceOwnership(_) => { + ::SELECTOR + } + Self::setImplementation_0(_) => { + ::SELECTOR + } + Self::setImplementation_1(_) => { + ::SELECTOR + } + Self::setInitBond(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::SELECTOR + } + Self::version(_) => ::SELECTOR, + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setImplementation_0( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::setImplementation_0) + } + setImplementation_0 + }, + { + fn gameImpls( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameFactoryCalls::gameImpls) + } + gameImpls + }, + { + fn __constructor__( + data: &[u8], + ) -> alloy_sol_types::Result { + <__constructor__Call as alloy_sol_types::SolCall>::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::__constructor__) + } + __constructor__ + }, + { + fn setInitBond( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::setInitBond) + } + setInitBond + }, + { + fn findLatestGames( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::findLatestGames) + } + findLatestGames + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::initVersion) + } + initVersion + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn gameCount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameFactoryCalls::gameCount) + } + gameCount + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameFactoryCalls::version) + } + version + }, + { + fn games( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameFactoryCalls::games) + } + games + }, + { + fn initBonds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameFactoryCalls::initBonds) + } + initBonds + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn gameArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameFactoryCalls::gameArgs) + } + gameArgs + }, + { + fn create( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameFactoryCalls::create) + } + create + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IDisputeGameFactoryCalls::owner) + } + owner + }, + { + fn getGameUUID( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::getGameUUID) + } + getGameUUID + }, + { + fn setImplementation_1( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::setImplementation_1) + } + setImplementation_1 + }, + { + fn gameAtIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::gameAtIndex) + } + gameAtIndex + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::initialize) + } + initialize + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setImplementation_0( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::setImplementation_0) + } + setImplementation_0 + }, + { + fn gameImpls( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::gameImpls) + } + gameImpls + }, + { + fn __constructor__( + data: &[u8], + ) -> alloy_sol_types::Result { + <__constructor__Call as alloy_sol_types::SolCall>::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::__constructor__) + } + __constructor__ + }, + { + fn setInitBond( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::setInitBond) + } + setInitBond + }, + { + fn findLatestGames( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::findLatestGames) + } + findLatestGames + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::initVersion) + } + initVersion + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn gameCount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::gameCount) + } + gameCount + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::version) + } + version + }, + { + fn games( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::games) + } + games + }, + { + fn initBonds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::initBonds) + } + initBonds + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn gameArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::gameArgs) + } + gameArgs + }, + { + fn create( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::create) + } + create + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::owner) + } + owner + }, + { + fn getGameUUID( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::getGameUUID) + } + getGameUUID + }, + { + fn setImplementation_1( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::setImplementation_1) + } + setImplementation_1 + }, + { + fn gameAtIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::gameAtIndex) + } + gameAtIndex + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::initialize) + } + initialize + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::__constructor__(inner) => { + <__constructor__Call as alloy_sol_types::SolCall>::abi_encoded_size( + inner, + ) + } + Self::create(inner) => { + ::abi_encoded_size(inner) + } + Self::findLatestGames(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::gameArgs(inner) => { + ::abi_encoded_size(inner) + } + Self::gameAtIndex(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::gameCount(inner) => { + ::abi_encoded_size(inner) + } + Self::gameImpls(inner) => { + ::abi_encoded_size(inner) + } + Self::games(inner) => { + ::abi_encoded_size(inner) + } + Self::getGameUUID(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initBonds(inner) => { + ::abi_encoded_size(inner) + } + Self::initVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdmin(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::renounceOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setImplementation_0(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setImplementation_1(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setInitBond(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::version(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::__constructor__(inner) => { + <__constructor__Call as alloy_sol_types::SolCall>::abi_encode_raw( + inner, + out, + ) + } + Self::create(inner) => { + ::abi_encode_raw(inner, out) + } + Self::findLatestGames(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameAtIndex(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameCount(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameImpls(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::games(inner) => { + ::abi_encode_raw(inner, out) + } + Self::getGameUUID(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initBonds(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::proxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::renounceOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setImplementation_0(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setImplementation_1(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setInitBond(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::version(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`IDisputeGameFactory`](self) custom errors. + #[derive(Clone)] + pub enum IDisputeGameFactoryErrors { + #[allow(missing_docs)] + GameAlreadyExists(GameAlreadyExists), + #[allow(missing_docs)] + IncorrectBondAmount(IncorrectBondAmount), + #[allow(missing_docs)] + NoImplementation(NoImplementation), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdmin(ProxyAdminOwnedBase_NotProxyAdmin), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOwner(ProxyAdminOwnedBase_NotProxyAdminOwner), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotResolvedDelegateProxy( + ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_ProxyAdminNotFound(ProxyAdminOwnedBase_ProxyAdminNotFound), + #[allow(missing_docs)] + ReinitializableBase_ZeroInitVersion(ReinitializableBase_ZeroInitVersion), + } + impl IDisputeGameFactoryErrors { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [1u8, 79u8, 111u8, 229u8], + [3u8, 28u8, 109u8, 228u8], + [7u8, 92u8, 67u8, 20u8], + [51u8, 33u8, 68u8, 219u8], + [84u8, 228u8, 51u8, 205u8], + [127u8, 18u8, 198u8, 75u8], + [134u8, 32u8, 170u8, 25u8], + [155u8, 1u8, 175u8, 237u8], + [196u8, 5u8, 10u8, 38u8], + [232u8, 24u8, 220u8, 195u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(GameAlreadyExists), + ::core::stringify!(NoImplementation), + ::core::stringify!(ProxyAdminOwnedBase_NotSharedProxyAdminOwner), + ::core::stringify!(ProxyAdminOwnedBase_ProxyAdminNotFound), + ::core::stringify!(ProxyAdminOwnedBase_NotResolvedDelegateProxy), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOwner), + ::core::stringify!(IncorrectBondAmount), + ::core::stringify!(ReinitializableBase_ZeroInitVersion), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdmin), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IDisputeGameFactoryErrors { + const NAME: &'static str = "IDisputeGameFactoryErrors"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 10usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::GameAlreadyExists(_) => { + ::SELECTOR + } + Self::IncorrectBondAmount(_) => { + ::SELECTOR + } + Self::NoImplementation(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(_) => { + ::SELECTOR + } + Self::ReinitializableBase_ZeroInitVersion(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn GameAlreadyExists( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryErrors::GameAlreadyExists) + } + GameAlreadyExists + }, + { + fn NoImplementation( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryErrors::NoImplementation) + } + NoImplementation + }, + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn IncorrectBondAmount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IDisputeGameFactoryErrors::IncorrectBondAmount) + } + IncorrectBondAmount + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IDisputeGameFactoryErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn GameAlreadyExists( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryErrors::GameAlreadyExists) + } + GameAlreadyExists + }, + { + fn NoImplementation( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryErrors::NoImplementation) + } + NoImplementation + }, + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn IncorrectBondAmount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IDisputeGameFactoryErrors::IncorrectBondAmount) + } + IncorrectBondAmount + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IDisputeGameFactoryErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IDisputeGameFactoryErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::GameAlreadyExists(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::IncorrectBondAmount(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::NoImplementation(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::GameAlreadyExists(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::IncorrectBondAmount(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::NoImplementation(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`IDisputeGameFactory`](self) events. + #[derive(Clone)] + pub enum IDisputeGameFactoryEvents { + #[allow(missing_docs)] + DisputeGameCreated(DisputeGameCreated), + #[allow(missing_docs)] + ImplementationArgsSet(ImplementationArgsSet), + #[allow(missing_docs)] + ImplementationSet(ImplementationSet), + #[allow(missing_docs)] + InitBondUpdated(InitBondUpdated), + #[allow(missing_docs)] + Initialized(Initialized), + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + } + impl IDisputeGameFactoryEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 91u8, 86u8, 94u8, 254u8, 130u8, 65u8, 29u8, 169u8, 136u8, 20u8, 243u8, + 86u8, 208u8, 231u8, 188u8, 184u8, 240u8, 33u8, 155u8, 141u8, 151u8, 3u8, + 7u8, 197u8, 175u8, 180u8, 166u8, 144u8, 58u8, 139u8, 46u8, 53u8, + ], + [ + 116u8, 214u8, 102u8, 92u8, 75u8, 38u8, 213u8, 89u8, 106u8, 90u8, 161u8, + 61u8, 48u8, 20u8, 224u8, 192u8, 106u8, 244u8, 211u8, 34u8, 7u8, 90u8, + 121u8, 127u8, 135u8, 176u8, 60u8, 212u8, 197u8, 188u8, 145u8, 202u8, + ], + [ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ], + [ + 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, + 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, + 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + ], + [ + 164u8, 127u8, 205u8, 240u8, 117u8, 214u8, 128u8, 211u8, 129u8, 123u8, + 252u8, 167u8, 151u8, 59u8, 55u8, 62u8, 26u8, 95u8, 108u8, 252u8, 59u8, + 68u8, 71u8, 72u8, 41u8, 156u8, 194u8, 184u8, 61u8, 131u8, 72u8, 249u8, + ], + [ + 255u8, 81u8, 61u8, 128u8, 226u8, 199u8, 250u8, 72u8, 118u8, 8u8, 247u8, + 10u8, 97u8, 141u8, 251u8, 192u8, 207u8, 65u8, 86u8, 153u8, 220u8, 105u8, + 88u8, 140u8, 116u8, 126u8, 140u8, 113u8, 86u8, 108u8, 136u8, 222u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(DisputeGameCreated), + ::core::stringify!(InitBondUpdated), + ::core::stringify!(Initialized), + ::core::stringify!(OwnershipTransferred), + ::core::stringify!(ImplementationArgsSet), + ::core::stringify!(ImplementationSet), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IDisputeGameFactoryEvents { + const NAME: &'static str = "IDisputeGameFactoryEvents"; + const COUNT: usize = 6usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::DisputeGameCreated) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ImplementationArgsSet) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ImplementationSet) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::InitBondUpdated) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::Initialized) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for IDisputeGameFactoryEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::DisputeGameCreated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::ImplementationArgsSet(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::ImplementationSet(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::InitBondUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::DisputeGameCreated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::ImplementationArgsSet(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::ImplementationSet(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::InitBondUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IDisputeGameFactory`](self) contract instance. + +See the [wrapper's documentation](`IDisputeGameFactoryInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> IDisputeGameFactoryInstance { + IDisputeGameFactoryInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IDisputeGameFactoryInstance::::deploy(__provider) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(__provider: P) -> alloy_contract::RawCallBuilder { + IDisputeGameFactoryInstance::::deploy_builder(__provider) + } + /**A [`IDisputeGameFactory`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IDisputeGameFactory`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct IDisputeGameFactoryInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IDisputeGameFactoryInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IDisputeGameFactoryInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IDisputeGameFactoryInstance { + /**Creates a new wrapper around an on-chain [`IDisputeGameFactory`](self) contract instance. + +See the [wrapper's documentation](`IDisputeGameFactoryInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + ::core::clone::Clone::clone(&BYTECODE), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl IDisputeGameFactoryInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IDisputeGameFactoryInstance { + IDisputeGameFactoryInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IDisputeGameFactoryInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`__constructor__`] function. + pub fn __constructor__( + &self, + ) -> alloy_contract::SolCallBuilder<&P, __constructor__Call, N> { + self.call_builder(&__constructor__Call) + } + ///Creates a new call builder for the [`create`] function. + pub fn create( + &self, + _gameType: ::RustType, + _rootClaim: ::RustType, + _extraData: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, createCall, N> { + self.call_builder( + &createCall { + _gameType, + _rootClaim, + _extraData, + }, + ) + } + ///Creates a new call builder for the [`findLatestGames`] function. + pub fn findLatestGames( + &self, + _gameType: ::RustType, + _start: alloy::sol_types::private::primitives::aliases::U256, + _n: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, findLatestGamesCall, N> { + self.call_builder( + &findLatestGamesCall { + _gameType, + _start, + _n, + }, + ) + } + ///Creates a new call builder for the [`gameArgs`] function. + pub fn gameArgs( + &self, + _0: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, gameArgsCall, N> { + self.call_builder(&gameArgsCall(_0)) + } + ///Creates a new call builder for the [`gameAtIndex`] function. + pub fn gameAtIndex( + &self, + _index: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, gameAtIndexCall, N> { + self.call_builder(&gameAtIndexCall { _index }) + } + ///Creates a new call builder for the [`gameCount`] function. + pub fn gameCount(&self) -> alloy_contract::SolCallBuilder<&P, gameCountCall, N> { + self.call_builder(&gameCountCall) + } + ///Creates a new call builder for the [`gameImpls`] function. + pub fn gameImpls( + &self, + _0: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, gameImplsCall, N> { + self.call_builder(&gameImplsCall(_0)) + } + ///Creates a new call builder for the [`games`] function. + pub fn games( + &self, + _gameType: ::RustType, + _rootClaim: ::RustType, + _extraData: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, gamesCall, N> { + self.call_builder( + &gamesCall { + _gameType, + _rootClaim, + _extraData, + }, + ) + } + ///Creates a new call builder for the [`getGameUUID`] function. + pub fn getGameUUID( + &self, + _gameType: ::RustType, + _rootClaim: ::RustType, + _extraData: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, getGameUUIDCall, N> { + self.call_builder( + &getGameUUIDCall { + _gameType, + _rootClaim, + _extraData, + }, + ) + } + ///Creates a new call builder for the [`initBonds`] function. + pub fn initBonds( + &self, + _0: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, initBondsCall, N> { + self.call_builder(&initBondsCall(_0)) + } + ///Creates a new call builder for the [`initVersion`] function. + pub fn initVersion( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initVersionCall, N> { + self.call_builder(&initVersionCall) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + _owner: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder(&initializeCall { _owner }) + } + ///Creates a new call builder for the [`owner`] function. + pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> { + self.call_builder(&ownerCall) + } + ///Creates a new call builder for the [`proxyAdmin`] function. + pub fn proxyAdmin( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminCall, N> { + self.call_builder(&proxyAdminCall) + } + ///Creates a new call builder for the [`proxyAdminOwner`] function. + pub fn proxyAdminOwner( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminOwnerCall, N> { + self.call_builder(&proxyAdminOwnerCall) + } + ///Creates a new call builder for the [`renounceOwnership`] function. + pub fn renounceOwnership( + &self, + ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> { + self.call_builder(&renounceOwnershipCall) + } + ///Creates a new call builder for the [`setImplementation_0`] function. + pub fn setImplementation_0( + &self, + _gameType: ::RustType, + _impl: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, setImplementation_0Call, N> { + self.call_builder( + &setImplementation_0Call { + _gameType, + _impl, + }, + ) + } + ///Creates a new call builder for the [`setImplementation_1`] function. + pub fn setImplementation_1( + &self, + _gameType: ::RustType, + _impl: alloy::sol_types::private::Address, + _args: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, setImplementation_1Call, N> { + self.call_builder( + &setImplementation_1Call { + _gameType, + _impl, + _args, + }, + ) + } + ///Creates a new call builder for the [`setInitBond`] function. + pub fn setInitBond( + &self, + _gameType: ::RustType, + _initBond: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, setInitBondCall, N> { + self.call_builder( + &setInitBondCall { + _gameType, + _initBond, + }, + ) + } + ///Creates a new call builder for the [`transferOwnership`] function. + pub fn transferOwnership( + &self, + newOwner: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> { + self.call_builder(&transferOwnershipCall { newOwner }) + } + ///Creates a new call builder for the [`version`] function. + pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> { + self.call_builder(&versionCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IDisputeGameFactoryInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`DisputeGameCreated`] event. + pub fn DisputeGameCreated_filter( + &self, + ) -> alloy_contract::Event<&P, DisputeGameCreated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`ImplementationArgsSet`] event. + pub fn ImplementationArgsSet_filter( + &self, + ) -> alloy_contract::Event<&P, ImplementationArgsSet, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`ImplementationSet`] event. + pub fn ImplementationSet_filter( + &self, + ) -> alloy_contract::Event<&P, ImplementationSet, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`InitBondUpdated`] event. + pub fn InitBondUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, InitBondUpdated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Initialized`] event. + pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/i_fault_dispute_game.rs b/bindings/src/codegen/i_fault_dispute_game.rs new file mode 100644 index 000000000..ed83057ce --- /dev/null +++ b/bindings/src/codegen/i_fault_dispute_game.rs @@ -0,0 +1,19246 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library Types { + struct OutputRootProof { bytes32 version; bytes32 stateRoot; bytes32 messagePasserStorageRoot; bytes32 latestBlockhash; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod Types { + use super::*; + use alloy::sol_types as alloy_sol_types; + /**```solidity +struct OutputRootProof { bytes32 version; bytes32 stateRoot; bytes32 messagePasserStorageRoot; bytes32 latestBlockhash; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct OutputRootProof { + #[allow(missing_docs)] + pub version: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub stateRoot: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub messagePasserStorageRoot: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub latestBlockhash: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: OutputRootProof) -> Self { + ( + value.version, + value.stateRoot, + value.messagePasserStorageRoot, + value.latestBlockhash, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for OutputRootProof { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + version: tuple.0, + stateRoot: tuple.1, + messagePasserStorageRoot: tuple.2, + latestBlockhash: tuple.3, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for OutputRootProof { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for OutputRootProof { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + as alloy_sol_types::SolType>::tokenize(&self.stateRoot), + as alloy_sol_types::SolType>::tokenize( + &self.messagePasserStorageRoot, + ), + as alloy_sol_types::SolType>::tokenize(&self.latestBlockhash), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for OutputRootProof { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for OutputRootProof { + const NAME: &'static str = "OutputRootProof"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "OutputRootProof(bytes32 version,bytes32 stateRoot,bytes32 messagePasserStorageRoot,bytes32 latestBlockhash)", + ) + } + #[inline] + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { + alloy_sol_types::private::Vec::new() + } + #[inline] + fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.version) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.stateRoot) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.messagePasserStorageRoot, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.latestBlockhash, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for OutputRootProof { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.version, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.stateRoot, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.messagePasserStorageRoot, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.latestBlockhash, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.version, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.stateRoot, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.messagePasserStorageRoot, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.latestBlockhash, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`Types`](self) contract instance. + +See the [wrapper's documentation](`TypesInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, __provider: P) -> TypesInstance { + TypesInstance::::new(address, __provider) + } + /**A [`Types`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`Types`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct TypesInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for TypesInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("TypesInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > TypesInstance { + /**Creates a new wrapper around an on-chain [`Types`](self) contract instance. + +See the [wrapper's documentation](`TypesInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl TypesInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> TypesInstance { + TypesInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > TypesInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > TypesInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library Types { + struct OutputRootProof { + bytes32 version; + bytes32 stateRoot; + bytes32 messagePasserStorageRoot; + bytes32 latestBlockhash; + } +} + +interface IFaultDisputeGame { + type BondDistributionMode is uint8; + type GameStatus is uint8; + type Claim is bytes32; + type Clock is uint128; + type Duration is uint64; + type GameType is uint32; + type Hash is bytes32; + type Position is uint128; + type Timestamp is uint64; + struct GameConstructorParams { + GameType gameType; + Claim absolutePrestate; + uint256 maxGameDepth; + uint256 splitDepth; + Duration clockExtension; + Duration maxClockDuration; + address vm; + address weth; + address anchorStateRegistry; + uint256 l2ChainId; + } + + error AlreadyInitialized(); + error AnchorRootNotFound(); + error BadExtraData(); + error BlockNumberMatches(); + error BondTransferFailed(); + error CannotDefendRootClaim(); + error ClaimAboveSplit(); + error ClaimAlreadyExists(); + error ClaimAlreadyResolved(); + error ClockNotExpired(); + error ClockTimeExceeded(); + error ContentLengthMismatch(); + error DuplicateStep(); + error EmptyItem(); + error GameDepthExceeded(); + error GameNotFinalized(); + error GameNotInProgress(); + error GameNotResolved(); + error GamePaused(); + error IncorrectBondAmount(); + error InvalidBondDistributionMode(); + error InvalidChallengePeriod(); + error InvalidClockExtension(); + error InvalidDataRemainder(); + error InvalidDisputedClaimIndex(); + error InvalidHeader(); + error InvalidHeaderRLP(); + error InvalidLocalIdent(); + error InvalidOutputRootProof(); + error InvalidParent(); + error InvalidPrestate(); + error InvalidSplitDepth(); + error L2BlockNumberChallenged(); + error MaxDepthTooLarge(); + error NoCreditToClaim(); + error OutOfOrderResolution(); + error ReservedGameType(); + error UnexpectedList(); + error UnexpectedRootClaim(Claim rootClaim); + error UnexpectedString(); + error ValidStep(); + + event GameClosed(BondDistributionMode bondDistributionMode); + event Move(uint256 indexed parentIndex, Claim indexed claim, address indexed claimant); + event Resolved(GameStatus indexed status); + + function __constructor__(GameConstructorParams memory _params) external; + function absolutePrestate() external view returns (Claim absolutePrestate_); + function addLocalData(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset) external; + function anchorStateRegistry() external view returns (address registry_); + function attack(Claim _disputed, uint256 _parentIndex, Claim _claim) external payable; + function bondDistributionMode() external view returns (BondDistributionMode); + function challengeRootL2Block(Types.OutputRootProof memory _outputRootProof, bytes memory _headerRLP) external; + function claimCredit(address _recipient) external; + function claimData(uint256) external view returns (uint32 parentIndex, address counteredBy, address claimant, uint128 bond, Claim claim, Position position, Clock clock); + function claimDataLen() external view returns (uint256 len_); + function claims(Hash) external view returns (bool); + function clockExtension() external view returns (Duration clockExtension_); + function closeGame() external; + function createdAt() external view returns (Timestamp); + function credit(address _recipient) external view returns (uint256 credit_); + function defend(Claim _disputed, uint256 _parentIndex, Claim _claim) external payable; + function extraData() external pure returns (bytes memory extraData_); + function gameCreator() external pure returns (address creator_); + function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); + function gameType() external view returns (GameType gameType_); + function getChallengerDuration(uint256 _claimIndex) external view returns (Duration duration_); + function getNumToResolve(uint256 _claimIndex) external view returns (uint256 numRemainingChildren_); + function getRequiredBond(Position _position) external view returns (uint256 requiredBond_); + function hasUnlockedCredit(address) external view returns (bool); + function initialize() external payable; + function l1Head() external pure returns (Hash l1Head_); + function l2BlockNumber() external pure returns (uint256 l2BlockNumber_); + function l2BlockNumberChallenged() external view returns (bool); + function l2BlockNumberChallenger() external view returns (address); + function l2ChainId() external view returns (uint256 l2ChainId_); + function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); + function maxClockDuration() external view returns (Duration maxClockDuration_); + function maxGameDepth() external view returns (uint256 maxGameDepth_); + function move(Claim _disputed, uint256 _challengeIndex, Claim _claim, bool _isAttack) external payable; + function normalModeCredit(address) external view returns (uint256); + function refundModeCredit(address) external view returns (uint256); + function resolutionCheckpoints(uint256) external view returns (bool initialCheckpointComplete, uint32 subgameIndex, Position leftmostPosition, address counteredBy); + function resolve() external returns (GameStatus status_); + function resolveClaim(uint256 _claimIndex, uint256 _numToResolve) external; + function resolvedAt() external view returns (Timestamp); + function resolvedSubgames(uint256) external view returns (bool); + function rootClaim() external pure returns (Claim rootClaim_); + function splitDepth() external view returns (uint256 splitDepth_); + function startingBlockNumber() external view returns (uint256 startingBlockNumber_); + function startingOutputRoot() external view returns (Hash root, uint256 l2SequenceNumber); + function startingRootHash() external view returns (Hash startingRootHash_); + function status() external view returns (GameStatus); + function step(uint256 _claimIndex, bool _isAttack, bytes memory _stateData, bytes memory _proof) external; + function subgames(uint256, uint256) external view returns (uint256); + function version() external pure returns (string memory); + function vm() external view returns (address vm_); + function wasRespectedGameTypeWhenCreated() external view returns (bool); + function weth() external view returns (address weth_); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "__constructor__", + "inputs": [ + { + "name": "_params", + "type": "tuple", + "internalType": "struct IFaultDisputeGame.GameConstructorParams", + "components": [ + { + "name": "gameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "absolutePrestate", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "maxGameDepth", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "splitDepth", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "clockExtension", + "type": "uint64", + "internalType": "Duration" + }, + { + "name": "maxClockDuration", + "type": "uint64", + "internalType": "Duration" + }, + { + "name": "vm", + "type": "address", + "internalType": "contract IBigStepper" + }, + { + "name": "weth", + "type": "address", + "internalType": "contract IDelayedWETH" + }, + { + "name": "anchorStateRegistry", + "type": "address", + "internalType": "contract IAnchorStateRegistry" + }, + { + "name": "l2ChainId", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "absolutePrestate", + "inputs": [], + "outputs": [ + { + "name": "absolutePrestate_", + "type": "bytes32", + "internalType": "Claim" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "addLocalData", + "inputs": [ + { + "name": "_ident", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_execLeafIdx", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_partOffset", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "anchorStateRegistry", + "inputs": [], + "outputs": [ + { + "name": "registry_", + "type": "address", + "internalType": "contract IAnchorStateRegistry" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "attack", + "inputs": [ + { + "name": "_disputed", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_parentIndex", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_claim", + "type": "bytes32", + "internalType": "Claim" + } + ], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "bondDistributionMode", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum BondDistributionMode" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "challengeRootL2Block", + "inputs": [ + { + "name": "_outputRootProof", + "type": "tuple", + "internalType": "struct Types.OutputRootProof", + "components": [ + { + "name": "version", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "stateRoot", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "messagePasserStorageRoot", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "latestBlockhash", + "type": "bytes32", + "internalType": "bytes32" + } + ] + }, + { + "name": "_headerRLP", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "claimCredit", + "inputs": [ + { + "name": "_recipient", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "claimData", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "parentIndex", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "counteredBy", + "type": "address", + "internalType": "address" + }, + { + "name": "claimant", + "type": "address", + "internalType": "address" + }, + { + "name": "bond", + "type": "uint128", + "internalType": "uint128" + }, + { + "name": "claim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "position", + "type": "uint128", + "internalType": "Position" + }, + { + "name": "clock", + "type": "uint128", + "internalType": "Clock" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "claimDataLen", + "inputs": [], + "outputs": [ + { + "name": "len_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "claims", + "inputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "Hash" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "clockExtension", + "inputs": [], + "outputs": [ + { + "name": "clockExtension_", + "type": "uint64", + "internalType": "Duration" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "closeGame", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "createdAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "credit", + "inputs": [ + { + "name": "_recipient", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "credit_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "defend", + "inputs": [ + { + "name": "_disputed", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_parentIndex", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_claim", + "type": "bytes32", + "internalType": "Claim" + } + ], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "extraData", + "inputs": [], + "outputs": [ + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameCreator", + "inputs": [], + "outputs": [ + { + "name": "creator_", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameData", + "inputs": [], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "rootClaim_", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameType", + "inputs": [], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getChallengerDuration", + "inputs": [ + { + "name": "_claimIndex", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "duration_", + "type": "uint64", + "internalType": "Duration" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getNumToResolve", + "inputs": [ + { + "name": "_claimIndex", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "numRemainingChildren_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getRequiredBond", + "inputs": [ + { + "name": "_position", + "type": "uint128", + "internalType": "Position" + } + ], + "outputs": [ + { + "name": "requiredBond_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "hasUnlockedCredit", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "l1Head", + "inputs": [], + "outputs": [ + { + "name": "l1Head_", + "type": "bytes32", + "internalType": "Hash" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "l2BlockNumber", + "inputs": [], + "outputs": [ + { + "name": "l2BlockNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "l2BlockNumberChallenged", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "l2BlockNumberChallenger", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "l2ChainId", + "inputs": [], + "outputs": [ + { + "name": "l2ChainId_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "l2SequenceNumber", + "inputs": [], + "outputs": [ + { + "name": "l2SequenceNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "maxClockDuration", + "inputs": [], + "outputs": [ + { + "name": "maxClockDuration_", + "type": "uint64", + "internalType": "Duration" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "maxGameDepth", + "inputs": [], + "outputs": [ + { + "name": "maxGameDepth_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "move", + "inputs": [ + { + "name": "_disputed", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_challengeIndex", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_claim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "_isAttack", + "type": "bool", + "internalType": "bool" + } + ], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "normalModeCredit", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "refundModeCredit", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "resolutionCheckpoints", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "initialCheckpointComplete", + "type": "bool", + "internalType": "bool" + }, + { + "name": "subgameIndex", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "leftmostPosition", + "type": "uint128", + "internalType": "Position" + }, + { + "name": "counteredBy", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "resolve", + "inputs": [], + "outputs": [ + { + "name": "status_", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "resolveClaim", + "inputs": [ + { + "name": "_claimIndex", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_numToResolve", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "resolvedAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "resolvedSubgames", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "rootClaim", + "inputs": [], + "outputs": [ + { + "name": "rootClaim_", + "type": "bytes32", + "internalType": "Claim" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "splitDepth", + "inputs": [], + "outputs": [ + { + "name": "splitDepth_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "startingBlockNumber", + "inputs": [], + "outputs": [ + { + "name": "startingBlockNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "startingOutputRoot", + "inputs": [], + "outputs": [ + { + "name": "root", + "type": "bytes32", + "internalType": "Hash" + }, + { + "name": "l2SequenceNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "startingRootHash", + "inputs": [], + "outputs": [ + { + "name": "startingRootHash_", + "type": "bytes32", + "internalType": "Hash" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "status", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "step", + "inputs": [ + { + "name": "_claimIndex", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_isAttack", + "type": "bool", + "internalType": "bool" + }, + { + "name": "_stateData", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "_proof", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "subgames", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "vm", + "inputs": [], + "outputs": [ + { + "name": "vm_", + "type": "address", + "internalType": "contract IBigStepper" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "wasRespectedGameTypeWhenCreated", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "weth", + "inputs": [], + "outputs": [ + { + "name": "weth_", + "type": "address", + "internalType": "contract IDelayedWETH" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "GameClosed", + "inputs": [ + { + "name": "bondDistributionMode", + "type": "uint8", + "indexed": false, + "internalType": "enum BondDistributionMode" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Move", + "inputs": [ + { + "name": "parentIndex", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "claim", + "type": "bytes32", + "indexed": true, + "internalType": "Claim" + }, + { + "name": "claimant", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Resolved", + "inputs": [ + { + "name": "status", + "type": "uint8", + "indexed": true, + "internalType": "enum GameStatus" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "AlreadyInitialized", + "inputs": [] + }, + { + "type": "error", + "name": "AnchorRootNotFound", + "inputs": [] + }, + { + "type": "error", + "name": "BadExtraData", + "inputs": [] + }, + { + "type": "error", + "name": "BlockNumberMatches", + "inputs": [] + }, + { + "type": "error", + "name": "BondTransferFailed", + "inputs": [] + }, + { + "type": "error", + "name": "CannotDefendRootClaim", + "inputs": [] + }, + { + "type": "error", + "name": "ClaimAboveSplit", + "inputs": [] + }, + { + "type": "error", + "name": "ClaimAlreadyExists", + "inputs": [] + }, + { + "type": "error", + "name": "ClaimAlreadyResolved", + "inputs": [] + }, + { + "type": "error", + "name": "ClockNotExpired", + "inputs": [] + }, + { + "type": "error", + "name": "ClockTimeExceeded", + "inputs": [] + }, + { + "type": "error", + "name": "ContentLengthMismatch", + "inputs": [] + }, + { + "type": "error", + "name": "DuplicateStep", + "inputs": [] + }, + { + "type": "error", + "name": "EmptyItem", + "inputs": [] + }, + { + "type": "error", + "name": "GameDepthExceeded", + "inputs": [] + }, + { + "type": "error", + "name": "GameNotFinalized", + "inputs": [] + }, + { + "type": "error", + "name": "GameNotInProgress", + "inputs": [] + }, + { + "type": "error", + "name": "GameNotResolved", + "inputs": [] + }, + { + "type": "error", + "name": "GamePaused", + "inputs": [] + }, + { + "type": "error", + "name": "IncorrectBondAmount", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidBondDistributionMode", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidChallengePeriod", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidClockExtension", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidDataRemainder", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidDisputedClaimIndex", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidHeader", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidHeaderRLP", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidLocalIdent", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidOutputRootProof", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidParent", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidPrestate", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidSplitDepth", + "inputs": [] + }, + { + "type": "error", + "name": "L2BlockNumberChallenged", + "inputs": [] + }, + { + "type": "error", + "name": "MaxDepthTooLarge", + "inputs": [] + }, + { + "type": "error", + "name": "NoCreditToClaim", + "inputs": [] + }, + { + "type": "error", + "name": "OutOfOrderResolution", + "inputs": [] + }, + { + "type": "error", + "name": "ReservedGameType", + "inputs": [] + }, + { + "type": "error", + "name": "UnexpectedList", + "inputs": [] + }, + { + "type": "error", + "name": "UnexpectedRootClaim", + "inputs": [ + { + "name": "rootClaim", + "type": "bytes32", + "internalType": "Claim" + } + ] + }, + { + "type": "error", + "name": "UnexpectedString", + "inputs": [] + }, + { + "type": "error", + "name": "ValidStep", + "inputs": [] + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod IFaultDisputeGame { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BondDistributionMode(u8); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u8 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<8>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl BondDistributionMode { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u8) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u8 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for BondDistributionMode { + fn from(value: u8) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u8 { + fn from(value: BondDistributionMode) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for BondDistributionMode { + type RustType = u8; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for BondDistributionMode { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameStatus(u8); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u8 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<8>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameStatus { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u8) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u8 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameStatus { + fn from(value: u8) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u8 { + fn from(value: GameStatus) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameStatus { + type RustType = u8; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameStatus { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Claim(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Claim { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Claim { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Claim) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Claim { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Claim { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Clock(u128); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u128 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<128>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Clock { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u128) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u128 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Clock { + fn from(value: u128) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u128 { + fn from(value: Clock) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Clock { + type RustType = u128; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Clock { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Duration(u64); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u64 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<64>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Duration { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u64) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u64 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Duration { + fn from(value: u64) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u64 { + fn from(value: Duration) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Duration { + type RustType = u64; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Duration { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Hash(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Hash { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Hash { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Hash) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Hash { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Hash { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Position(u128); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u128 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<128>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Position { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u128) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u128 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Position { + fn from(value: u128) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u128 { + fn from(value: Position) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Position { + type RustType = u128; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Position { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Timestamp(u64); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u64 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<64>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Timestamp { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u64) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u64 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Timestamp { + fn from(value: u64) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u64 { + fn from(value: Timestamp) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Timestamp { + type RustType = u64; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Timestamp { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**```solidity +struct GameConstructorParams { GameType gameType; Claim absolutePrestate; uint256 maxGameDepth; uint256 splitDepth; Duration clockExtension; Duration maxClockDuration; address vm; address weth; address anchorStateRegistry; uint256 l2ChainId; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameConstructorParams { + #[allow(missing_docs)] + pub gameType: ::RustType, + #[allow(missing_docs)] + pub absolutePrestate: ::RustType, + #[allow(missing_docs)] + pub maxGameDepth: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub splitDepth: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub clockExtension: ::RustType, + #[allow(missing_docs)] + pub maxClockDuration: ::RustType, + #[allow(missing_docs)] + pub vm: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub weth: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub anchorStateRegistry: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub l2ChainId: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + Duration, + Duration, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + ::RustType, + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameConstructorParams) -> Self { + ( + value.gameType, + value.absolutePrestate, + value.maxGameDepth, + value.splitDepth, + value.clockExtension, + value.maxClockDuration, + value.vm, + value.weth, + value.anchorStateRegistry, + value.l2ChainId, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameConstructorParams { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + gameType: tuple.0, + absolutePrestate: tuple.1, + maxGameDepth: tuple.2, + splitDepth: tuple.3, + clockExtension: tuple.4, + maxClockDuration: tuple.5, + vm: tuple.6, + weth: tuple.7, + anchorStateRegistry: tuple.8, + l2ChainId: tuple.9, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for GameConstructorParams { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for GameConstructorParams { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize(&self.gameType), + ::tokenize( + &self.absolutePrestate, + ), + as alloy_sol_types::SolType>::tokenize(&self.maxGameDepth), + as alloy_sol_types::SolType>::tokenize(&self.splitDepth), + ::tokenize( + &self.clockExtension, + ), + ::tokenize( + &self.maxClockDuration, + ), + ::tokenize( + &self.vm, + ), + ::tokenize( + &self.weth, + ), + ::tokenize( + &self.anchorStateRegistry, + ), + as alloy_sol_types::SolType>::tokenize(&self.l2ChainId), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameConstructorParams { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for GameConstructorParams { + const NAME: &'static str = "GameConstructorParams"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "GameConstructorParams(uint32 gameType,bytes32 absolutePrestate,uint256 maxGameDepth,uint256 splitDepth,uint64 clockExtension,uint64 maxClockDuration,address vm,address weth,address anchorStateRegistry,uint256 l2ChainId)", + ) + } + #[inline] + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { + alloy_sol_types::private::Vec::new() + } + #[inline] + fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.gameType, + ) + .0, + ::eip712_data_word( + &self.absolutePrestate, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.maxGameDepth) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.splitDepth) + .0, + ::eip712_data_word( + &self.clockExtension, + ) + .0, + ::eip712_data_word( + &self.maxClockDuration, + ) + .0, + ::eip712_data_word( + &self.vm, + ) + .0, + ::eip712_data_word( + &self.weth, + ) + .0, + ::eip712_data_word( + &self.anchorStateRegistry, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.l2ChainId) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameConstructorParams { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.gameType, + ) + + ::topic_preimage_length( + &rust.absolutePrestate, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.maxGameDepth, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.splitDepth, + ) + + ::topic_preimage_length( + &rust.clockExtension, + ) + + ::topic_preimage_length( + &rust.maxClockDuration, + ) + + ::topic_preimage_length( + &rust.vm, + ) + + ::topic_preimage_length( + &rust.weth, + ) + + ::topic_preimage_length( + &rust.anchorStateRegistry, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.l2ChainId, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.gameType, + out, + ); + ::encode_topic_preimage( + &rust.absolutePrestate, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.maxGameDepth, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.splitDepth, + out, + ); + ::encode_topic_preimage( + &rust.clockExtension, + out, + ); + ::encode_topic_preimage( + &rust.maxClockDuration, + out, + ); + ::encode_topic_preimage( + &rust.vm, + out, + ); + ::encode_topic_preimage( + &rust.weth, + out, + ); + ::encode_topic_preimage( + &rust.anchorStateRegistry, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.l2ChainId, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + /**Custom error with signature `AlreadyInitialized()` and selector `0x0dc149f0`. +```solidity +error AlreadyInitialized(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct AlreadyInitialized; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: AlreadyInitialized) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for AlreadyInitialized { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for AlreadyInitialized { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "AlreadyInitialized()"; + const SELECTOR: [u8; 4] = [13u8, 193u8, 73u8, 240u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `AnchorRootNotFound()` and selector `0x6a6bc3b2`. +```solidity +error AnchorRootNotFound(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct AnchorRootNotFound; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: AnchorRootNotFound) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for AnchorRootNotFound { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for AnchorRootNotFound { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "AnchorRootNotFound()"; + const SELECTOR: [u8; 4] = [106u8, 107u8, 195u8, 178u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `BadExtraData()` and selector `0x9824bdab`. +```solidity +error BadExtraData(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BadExtraData; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: BadExtraData) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for BadExtraData { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for BadExtraData { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "BadExtraData()"; + const SELECTOR: [u8; 4] = [152u8, 36u8, 189u8, 171u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `BlockNumberMatches()` and selector `0xb8ed8830`. +```solidity +error BlockNumberMatches(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BlockNumberMatches; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: BlockNumberMatches) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for BlockNumberMatches { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for BlockNumberMatches { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "BlockNumberMatches()"; + const SELECTOR: [u8; 4] = [184u8, 237u8, 136u8, 48u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `BondTransferFailed()` and selector `0x83e6cc6b`. +```solidity +error BondTransferFailed(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BondTransferFailed; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: BondTransferFailed) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for BondTransferFailed { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for BondTransferFailed { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "BondTransferFailed()"; + const SELECTOR: [u8; 4] = [131u8, 230u8, 204u8, 107u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `CannotDefendRootClaim()` and selector `0xa42637bc`. +```solidity +error CannotDefendRootClaim(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct CannotDefendRootClaim; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: CannotDefendRootClaim) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for CannotDefendRootClaim { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for CannotDefendRootClaim { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "CannotDefendRootClaim()"; + const SELECTOR: [u8; 4] = [164u8, 38u8, 55u8, 188u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ClaimAboveSplit()` and selector `0xb34b5c22`. +```solidity +error ClaimAboveSplit(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ClaimAboveSplit; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ClaimAboveSplit) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ClaimAboveSplit { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ClaimAboveSplit { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ClaimAboveSplit()"; + const SELECTOR: [u8; 4] = [179u8, 75u8, 92u8, 34u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ClaimAlreadyExists()` and selector `0x80497e3b`. +```solidity +error ClaimAlreadyExists(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ClaimAlreadyExists; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ClaimAlreadyExists) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ClaimAlreadyExists { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ClaimAlreadyExists { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ClaimAlreadyExists()"; + const SELECTOR: [u8; 4] = [128u8, 73u8, 126u8, 59u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ClaimAlreadyResolved()` and selector `0xf1a94581`. +```solidity +error ClaimAlreadyResolved(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ClaimAlreadyResolved; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ClaimAlreadyResolved) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ClaimAlreadyResolved { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ClaimAlreadyResolved { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ClaimAlreadyResolved()"; + const SELECTOR: [u8; 4] = [241u8, 169u8, 69u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ClockNotExpired()` and selector `0xf2440b53`. +```solidity +error ClockNotExpired(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ClockNotExpired; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ClockNotExpired) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ClockNotExpired { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ClockNotExpired { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ClockNotExpired()"; + const SELECTOR: [u8; 4] = [242u8, 68u8, 11u8, 83u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ClockTimeExceeded()` and selector `0x3381d114`. +```solidity +error ClockTimeExceeded(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ClockTimeExceeded; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ClockTimeExceeded) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ClockTimeExceeded { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ClockTimeExceeded { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ClockTimeExceeded()"; + const SELECTOR: [u8; 4] = [51u8, 129u8, 209u8, 20u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ContentLengthMismatch()` and selector `0x66c94485`. +```solidity +error ContentLengthMismatch(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ContentLengthMismatch; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ContentLengthMismatch) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ContentLengthMismatch { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ContentLengthMismatch { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ContentLengthMismatch()"; + const SELECTOR: [u8; 4] = [102u8, 201u8, 68u8, 133u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `DuplicateStep()` and selector `0x9071e6af`. +```solidity +error DuplicateStep(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct DuplicateStep; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: DuplicateStep) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for DuplicateStep { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for DuplicateStep { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "DuplicateStep()"; + const SELECTOR: [u8; 4] = [144u8, 113u8, 230u8, 175u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `EmptyItem()` and selector `0x5ab458fb`. +```solidity +error EmptyItem(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct EmptyItem; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: EmptyItem) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for EmptyItem { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for EmptyItem { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "EmptyItem()"; + const SELECTOR: [u8; 4] = [90u8, 180u8, 88u8, 251u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `GameDepthExceeded()` and selector `0x56f57b2b`. +```solidity +error GameDepthExceeded(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameDepthExceeded; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameDepthExceeded) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameDepthExceeded { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameDepthExceeded { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameDepthExceeded()"; + const SELECTOR: [u8; 4] = [86u8, 245u8, 123u8, 43u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `GameNotFinalized()` and selector `0x4851bd9b`. +```solidity +error GameNotFinalized(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameNotFinalized; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameNotFinalized) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameNotFinalized { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameNotFinalized { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameNotFinalized()"; + const SELECTOR: [u8; 4] = [72u8, 81u8, 189u8, 155u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `GameNotInProgress()` and selector `0x67fe1950`. +```solidity +error GameNotInProgress(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameNotInProgress; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameNotInProgress) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameNotInProgress { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameNotInProgress { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameNotInProgress()"; + const SELECTOR: [u8; 4] = [103u8, 254u8, 25u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `GameNotResolved()` and selector `0xc105260a`. +```solidity +error GameNotResolved(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameNotResolved; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameNotResolved) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameNotResolved { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameNotResolved { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameNotResolved()"; + const SELECTOR: [u8; 4] = [193u8, 5u8, 38u8, 10u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `GamePaused()` and selector `0x379a7ed9`. +```solidity +error GamePaused(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GamePaused; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GamePaused) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GamePaused { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GamePaused { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GamePaused()"; + const SELECTOR: [u8; 4] = [55u8, 154u8, 126u8, 217u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `IncorrectBondAmount()` and selector `0x8620aa19`. +```solidity +error IncorrectBondAmount(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IncorrectBondAmount; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IncorrectBondAmount) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IncorrectBondAmount { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for IncorrectBondAmount { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IncorrectBondAmount()"; + const SELECTOR: [u8; 4] = [134u8, 32u8, 170u8, 25u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidBondDistributionMode()` and selector `0x078a3df4`. +```solidity +error InvalidBondDistributionMode(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidBondDistributionMode; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: InvalidBondDistributionMode) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for InvalidBondDistributionMode { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidBondDistributionMode { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidBondDistributionMode()"; + const SELECTOR: [u8; 4] = [7u8, 138u8, 61u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidChallengePeriod()` and selector `0xb4e12433`. +```solidity +error InvalidChallengePeriod(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidChallengePeriod; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidChallengePeriod) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidChallengePeriod { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidChallengePeriod { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidChallengePeriod()"; + const SELECTOR: [u8; 4] = [180u8, 225u8, 36u8, 51u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidClockExtension()` and selector `0x8d77ecac`. +```solidity +error InvalidClockExtension(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidClockExtension; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidClockExtension) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidClockExtension { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidClockExtension { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidClockExtension()"; + const SELECTOR: [u8; 4] = [141u8, 119u8, 236u8, 172u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidDataRemainder()` and selector `0x5c5537b8`. +```solidity +error InvalidDataRemainder(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidDataRemainder; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidDataRemainder) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidDataRemainder { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidDataRemainder { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidDataRemainder()"; + const SELECTOR: [u8; 4] = [92u8, 85u8, 55u8, 184u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidDisputedClaimIndex()` and selector `0x30140332`. +```solidity +error InvalidDisputedClaimIndex(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidDisputedClaimIndex; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: InvalidDisputedClaimIndex) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for InvalidDisputedClaimIndex { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidDisputedClaimIndex { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidDisputedClaimIndex()"; + const SELECTOR: [u8; 4] = [48u8, 20u8, 3u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidHeader()` and selector `0xbabb01dd`. +```solidity +error InvalidHeader(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidHeader; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidHeader) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidHeader { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidHeader { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidHeader()"; + const SELECTOR: [u8; 4] = [186u8, 187u8, 1u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidHeaderRLP()` and selector `0xd81d583b`. +```solidity +error InvalidHeaderRLP(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidHeaderRLP; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidHeaderRLP) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidHeaderRLP { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidHeaderRLP { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidHeaderRLP()"; + const SELECTOR: [u8; 4] = [216u8, 29u8, 88u8, 59u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidLocalIdent()` and selector `0xff137e65`. +```solidity +error InvalidLocalIdent(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidLocalIdent; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidLocalIdent) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidLocalIdent { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidLocalIdent { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidLocalIdent()"; + const SELECTOR: [u8; 4] = [255u8, 19u8, 126u8, 101u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidOutputRootProof()` and selector `0x9cc00b5b`. +```solidity +error InvalidOutputRootProof(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidOutputRootProof; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidOutputRootProof) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidOutputRootProof { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidOutputRootProof { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidOutputRootProof()"; + const SELECTOR: [u8; 4] = [156u8, 192u8, 11u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidParent()` and selector `0x5f53dd98`. +```solidity +error InvalidParent(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidParent; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidParent) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidParent { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidParent { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidParent()"; + const SELECTOR: [u8; 4] = [95u8, 83u8, 221u8, 152u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidPrestate()` and selector `0x696550ff`. +```solidity +error InvalidPrestate(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidPrestate; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidPrestate) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidPrestate { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidPrestate { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidPrestate()"; + const SELECTOR: [u8; 4] = [105u8, 101u8, 80u8, 255u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidSplitDepth()` and selector `0xe62ccf39`. +```solidity +error InvalidSplitDepth(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidSplitDepth; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidSplitDepth) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidSplitDepth { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidSplitDepth { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidSplitDepth()"; + const SELECTOR: [u8; 4] = [230u8, 44u8, 207u8, 57u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `L2BlockNumberChallenged()` and selector `0x0ea2e752`. +```solidity +error L2BlockNumberChallenged(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct L2BlockNumberChallenged; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: L2BlockNumberChallenged) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for L2BlockNumberChallenged { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for L2BlockNumberChallenged { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "L2BlockNumberChallenged()"; + const SELECTOR: [u8; 4] = [14u8, 162u8, 231u8, 82u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `MaxDepthTooLarge()` and selector `0x77dfe332`. +```solidity +error MaxDepthTooLarge(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct MaxDepthTooLarge; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: MaxDepthTooLarge) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for MaxDepthTooLarge { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for MaxDepthTooLarge { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "MaxDepthTooLarge()"; + const SELECTOR: [u8; 4] = [119u8, 223u8, 227u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `NoCreditToClaim()` and selector `0x17bfe5f7`. +```solidity +error NoCreditToClaim(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct NoCreditToClaim; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: NoCreditToClaim) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for NoCreditToClaim { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for NoCreditToClaim { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "NoCreditToClaim()"; + const SELECTOR: [u8; 4] = [23u8, 191u8, 229u8, 247u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `OutOfOrderResolution()` and selector `0x9a076646`. +```solidity +error OutOfOrderResolution(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct OutOfOrderResolution; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: OutOfOrderResolution) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for OutOfOrderResolution { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for OutOfOrderResolution { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "OutOfOrderResolution()"; + const SELECTOR: [u8; 4] = [154u8, 7u8, 102u8, 70u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ReservedGameType()` and selector `0x39f68b38`. +```solidity +error ReservedGameType(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ReservedGameType; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ReservedGameType) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ReservedGameType { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ReservedGameType { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ReservedGameType()"; + const SELECTOR: [u8; 4] = [57u8, 246u8, 139u8, 56u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `UnexpectedList()` and selector `0x1ff9b2e4`. +```solidity +error UnexpectedList(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct UnexpectedList; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: UnexpectedList) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for UnexpectedList { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for UnexpectedList { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "UnexpectedList()"; + const SELECTOR: [u8; 4] = [31u8, 249u8, 178u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `UnexpectedRootClaim(bytes32)` and selector `0xf40239db`. +```solidity +error UnexpectedRootClaim(Claim rootClaim); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct UnexpectedRootClaim { + #[allow(missing_docs)] + pub rootClaim: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Claim,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (::RustType,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: UnexpectedRootClaim) -> Self { + (value.rootClaim,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for UnexpectedRootClaim { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { rootClaim: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for UnexpectedRootClaim { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "UnexpectedRootClaim(bytes32)"; + const SELECTOR: [u8; 4] = [244u8, 2u8, 57u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.rootClaim),) + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `UnexpectedString()` and selector `0x4b9c6abe`. +```solidity +error UnexpectedString(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct UnexpectedString; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: UnexpectedString) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for UnexpectedString { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for UnexpectedString { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "UnexpectedString()"; + const SELECTOR: [u8; 4] = [75u8, 156u8, 106u8, 190u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ValidStep()` and selector `0xfb4e40dd`. +```solidity +error ValidStep(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ValidStep; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ValidStep) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ValidStep { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ValidStep { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ValidStep()"; + const SELECTOR: [u8; 4] = [251u8, 78u8, 64u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Event with signature `GameClosed(uint8)` and selector `0x9908eaac0645df9d0704d06adc9e07337c951de2f06b5f2836151d48d5e4722f`. +```solidity +event GameClosed(BondDistributionMode bondDistributionMode); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct GameClosed { + #[allow(missing_docs)] + pub bondDistributionMode: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for GameClosed { + type DataTuple<'a> = (BondDistributionMode,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "GameClosed(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 153u8, 8u8, 234u8, 172u8, 6u8, 69u8, 223u8, 157u8, 7u8, 4u8, 208u8, + 106u8, 220u8, 158u8, 7u8, 51u8, 124u8, 149u8, 29u8, 226u8, 240u8, 107u8, + 95u8, 40u8, 54u8, 21u8, 29u8, 72u8, 213u8, 228u8, 114u8, 47u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + bondDistributionMode: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.bondDistributionMode, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for GameClosed { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&GameClosed> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &GameClosed) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Move(uint256,bytes32,address)` and selector `0x9b3245740ec3b155098a55be84957a4da13eaf7f14a8bc6f53126c0b9350f2be`. +```solidity +event Move(uint256 indexed parentIndex, Claim indexed claim, address indexed claimant); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Move { + #[allow(missing_docs)] + pub parentIndex: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub claim: ::RustType, + #[allow(missing_docs)] + pub claimant: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Move { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + Claim, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "Move(uint256,bytes32,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 155u8, 50u8, 69u8, 116u8, 14u8, 195u8, 177u8, 85u8, 9u8, 138u8, 85u8, + 190u8, 132u8, 149u8, 122u8, 77u8, 161u8, 62u8, 175u8, 127u8, 20u8, 168u8, + 188u8, 111u8, 83u8, 18u8, 108u8, 11u8, 147u8, 80u8, 242u8, 190u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + parentIndex: topics.1, + claim: topics.2, + claimant: topics.3, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.parentIndex.clone(), + self.claim.clone(), + self.claimant.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.parentIndex); + out[2usize] = ::encode_topic( + &self.claim, + ); + out[3usize] = ::encode_topic( + &self.claimant, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Move { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Move> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Move) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Resolved(uint8)` and selector `0x5e186f09b9c93491f14e277eea7faa5de6a2d4bda75a79af7a3684fbfb42da60`. +```solidity +event Resolved(GameStatus indexed status); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Resolved { + #[allow(missing_docs)] + pub status: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Resolved { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>, GameStatus); + const SIGNATURE: &'static str = "Resolved(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { status: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.status.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.status, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Resolved { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Resolved> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Resolved) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Function with signature `__constructor__((uint32,bytes32,uint256,uint256,uint64,uint64,address,address,address,uint256))` and selector `0x5599c646`. +```solidity +function __constructor__(GameConstructorParams memory _params) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct __constructor__Call { + #[allow(missing_docs)] + pub _params: ::RustType, + } + ///Container type for the return parameters of the [`__constructor__((uint32,bytes32,uint256,uint256,uint64,uint64,address,address,address,uint256))`](__constructor__Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct __constructor__Return {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameConstructorParams,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From<__constructor__Call> for UnderlyingRustTuple<'_> { + fn from(value: __constructor__Call) -> Self { + (value._params,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for __constructor__Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _params: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From<__constructor__Return> + for UnderlyingRustTuple<'_> { + fn from(value: __constructor__Return) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for __constructor__Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl __constructor__Return { + fn _tokenize( + &self, + ) -> <__constructor__Call as alloy_sol_types::SolCall>::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for __constructor__Call { + type Parameters<'a> = (GameConstructorParams,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = __constructor__Return; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "__constructor__((uint32,bytes32,uint256,uint256,uint64,uint64,address,address,address,uint256))"; + const SELECTOR: [u8; 4] = [85u8, 153u8, 198u8, 70u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._params, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + __constructor__Return::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `absolutePrestate()` and selector `0x8d450a95`. +```solidity +function absolutePrestate() external view returns (Claim absolutePrestate_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct absolutePrestateCall; + ///Container type for the return parameters of the [`absolutePrestate()`](absolutePrestateCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct absolutePrestateReturn { + #[allow(missing_docs)] + pub absolutePrestate_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: absolutePrestateCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for absolutePrestateCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Claim,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: absolutePrestateReturn) -> Self { + (value.absolutePrestate_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for absolutePrestateReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { absolutePrestate_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for absolutePrestateCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Claim,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "absolutePrestate()"; + const SELECTOR: [u8; 4] = [141u8, 69u8, 10u8, 149u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: absolutePrestateReturn = r.into(); + r.absolutePrestate_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: absolutePrestateReturn = r.into(); + r.absolutePrestate_ + }) + } + } + }; + /**Function with signature `addLocalData(uint256,uint256,uint256)` and selector `0xf8f43ff6`. +```solidity +function addLocalData(uint256 _ident, uint256 _execLeafIdx, uint256 _partOffset) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct addLocalDataCall { + #[allow(missing_docs)] + pub _ident: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _execLeafIdx: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _partOffset: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`addLocalData(uint256,uint256,uint256)`](addLocalDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct addLocalDataReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: addLocalDataCall) -> Self { + (value._ident, value._execLeafIdx, value._partOffset) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for addLocalDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _ident: tuple.0, + _execLeafIdx: tuple.1, + _partOffset: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: addLocalDataReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for addLocalDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl addLocalDataReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for addLocalDataCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = addLocalDataReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "addLocalData(uint256,uint256,uint256)"; + const SELECTOR: [u8; 4] = [248u8, 244u8, 63u8, 246u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._ident), + as alloy_sol_types::SolType>::tokenize(&self._execLeafIdx), + as alloy_sol_types::SolType>::tokenize(&self._partOffset), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + addLocalDataReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `anchorStateRegistry()` and selector `0x5c0cba33`. +```solidity +function anchorStateRegistry() external view returns (address registry_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorStateRegistryCall; + ///Container type for the return parameters of the [`anchorStateRegistry()`](anchorStateRegistryCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorStateRegistryReturn { + #[allow(missing_docs)] + pub registry_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: anchorStateRegistryCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for anchorStateRegistryCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: anchorStateRegistryReturn) -> Self { + (value.registry_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for anchorStateRegistryReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { registry_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for anchorStateRegistryCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "anchorStateRegistry()"; + const SELECTOR: [u8; 4] = [92u8, 12u8, 186u8, 51u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: anchorStateRegistryReturn = r.into(); + r.registry_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: anchorStateRegistryReturn = r.into(); + r.registry_ + }) + } + } + }; + /**Function with signature `attack(bytes32,uint256,bytes32)` and selector `0x472777c6`. +```solidity +function attack(Claim _disputed, uint256 _parentIndex, Claim _claim) external payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct attackCall { + #[allow(missing_docs)] + pub _disputed: ::RustType, + #[allow(missing_docs)] + pub _parentIndex: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _claim: ::RustType, + } + ///Container type for the return parameters of the [`attack(bytes32,uint256,bytes32)`](attackCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct attackReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + Claim, + alloy::sol_types::sol_data::Uint<256>, + Claim, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: attackCall) -> Self { + (value._disputed, value._parentIndex, value._claim) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for attackCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _disputed: tuple.0, + _parentIndex: tuple.1, + _claim: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: attackReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for attackReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl attackReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for attackCall { + type Parameters<'a> = (Claim, alloy::sol_types::sol_data::Uint<256>, Claim); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = attackReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "attack(bytes32,uint256,bytes32)"; + const SELECTOR: [u8; 4] = [71u8, 39u8, 119u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._disputed), + as alloy_sol_types::SolType>::tokenize(&self._parentIndex), + ::tokenize(&self._claim), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + attackReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `bondDistributionMode()` and selector `0x378dd48c`. +```solidity +function bondDistributionMode() external view returns (BondDistributionMode); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct bondDistributionModeCall; + ///Container type for the return parameters of the [`bondDistributionMode()`](bondDistributionModeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct bondDistributionModeReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: bondDistributionModeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for bondDistributionModeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (BondDistributionMode,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: bondDistributionModeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for bondDistributionModeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for bondDistributionModeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (BondDistributionMode,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "bondDistributionMode()"; + const SELECTOR: [u8; 4] = [55u8, 141u8, 212u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: bondDistributionModeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: bondDistributionModeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `challengeRootL2Block((bytes32,bytes32,bytes32,bytes32),bytes)` and selector `0x01935130`. +```solidity +function challengeRootL2Block(Types.OutputRootProof memory _outputRootProof, bytes memory _headerRLP) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengeRootL2BlockCall { + #[allow(missing_docs)] + pub _outputRootProof: ::RustType, + #[allow(missing_docs)] + pub _headerRLP: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`challengeRootL2Block((bytes32,bytes32,bytes32,bytes32),bytes)`](challengeRootL2BlockCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengeRootL2BlockReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + Types::OutputRootProof, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: challengeRootL2BlockCall) -> Self { + (value._outputRootProof, value._headerRLP) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for challengeRootL2BlockCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _outputRootProof: tuple.0, + _headerRLP: tuple.1, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: challengeRootL2BlockReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for challengeRootL2BlockReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl challengeRootL2BlockReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for challengeRootL2BlockCall { + type Parameters<'a> = ( + Types::OutputRootProof, + alloy::sol_types::sol_data::Bytes, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = challengeRootL2BlockReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "challengeRootL2Block((bytes32,bytes32,bytes32,bytes32),bytes)"; + const SELECTOR: [u8; 4] = [1u8, 147u8, 81u8, 48u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._outputRootProof, + ), + ::tokenize( + &self._headerRLP, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + challengeRootL2BlockReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `claimCredit(address)` and selector `0x60e27464`. +```solidity +function claimCredit(address _recipient) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimCreditCall { + #[allow(missing_docs)] + pub _recipient: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`claimCredit(address)`](claimCreditCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimCreditReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimCreditCall) -> Self { + (value._recipient,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimCreditCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _recipient: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimCreditReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimCreditReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl claimCreditReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for claimCreditCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = claimCreditReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "claimCredit(address)"; + const SELECTOR: [u8; 4] = [96u8, 226u8, 116u8, 100u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._recipient, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + claimCreditReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `claimData(uint256)` and selector `0xc6f0308c`. +```solidity +function claimData(uint256) external view returns (uint32 parentIndex, address counteredBy, address claimant, uint128 bond, Claim claim, Position position, Clock clock); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimDataCall(pub alloy::sol_types::private::primitives::aliases::U256); + ///Container type for the return parameters of the [`claimData(uint256)`](claimDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimDataReturn { + #[allow(missing_docs)] + pub parentIndex: u32, + #[allow(missing_docs)] + pub counteredBy: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub claimant: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub bond: u128, + #[allow(missing_docs)] + pub claim: ::RustType, + #[allow(missing_docs)] + pub position: ::RustType, + #[allow(missing_docs)] + pub clock: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimDataCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<128>, + Claim, + Position, + Clock, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + u32, + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + u128, + ::RustType, + ::RustType, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimDataReturn) -> Self { + ( + value.parentIndex, + value.counteredBy, + value.claimant, + value.bond, + value.claim, + value.position, + value.clock, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + parentIndex: tuple.0, + counteredBy: tuple.1, + claimant: tuple.2, + bond: tuple.3, + claim: tuple.4, + position: tuple.5, + clock: tuple.6, + } + } + } + } + impl claimDataReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.parentIndex), + ::tokenize( + &self.counteredBy, + ), + ::tokenize( + &self.claimant, + ), + as alloy_sol_types::SolType>::tokenize(&self.bond), + ::tokenize(&self.claim), + ::tokenize(&self.position), + ::tokenize(&self.clock), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for claimDataCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = claimDataReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<128>, + Claim, + Position, + Clock, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "claimData(uint256)"; + const SELECTOR: [u8; 4] = [198u8, 240u8, 48u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + claimDataReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `claimDataLen()` and selector `0x8980e0cc`. +```solidity +function claimDataLen() external view returns (uint256 len_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimDataLenCall; + ///Container type for the return parameters of the [`claimDataLen()`](claimDataLenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimDataLenReturn { + #[allow(missing_docs)] + pub len_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimDataLenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimDataLenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimDataLenReturn) -> Self { + (value.len_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimDataLenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { len_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for claimDataLenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "claimDataLen()"; + const SELECTOR: [u8; 4] = [137u8, 128u8, 224u8, 204u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: claimDataLenReturn = r.into(); + r.len_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: claimDataLenReturn = r.into(); + r.len_ + }) + } + } + }; + /**Function with signature `claims(bytes32)` and selector `0xeff0f592`. +```solidity +function claims(Hash) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimsCall(pub ::RustType); + ///Container type for the return parameters of the [`claims(bytes32)`](claimsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimsReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for claimsCall { + type Parameters<'a> = (Hash,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "claims(bytes32)"; + const SELECTOR: [u8; 4] = [239u8, 240u8, 245u8, 146u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.0),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: claimsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: claimsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `clockExtension()` and selector `0x6b6716c0`. +```solidity +function clockExtension() external view returns (Duration clockExtension_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct clockExtensionCall; + ///Container type for the return parameters of the [`clockExtension()`](clockExtensionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct clockExtensionReturn { + #[allow(missing_docs)] + pub clockExtension_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: clockExtensionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for clockExtensionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Duration,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: clockExtensionReturn) -> Self { + (value.clockExtension_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for clockExtensionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { clockExtension_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for clockExtensionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Duration,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "clockExtension()"; + const SELECTOR: [u8; 4] = [107u8, 103u8, 22u8, 192u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: clockExtensionReturn = r.into(); + r.clockExtension_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: clockExtensionReturn = r.into(); + r.clockExtension_ + }) + } + } + }; + /**Function with signature `closeGame()` and selector `0x786b844b`. +```solidity +function closeGame() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct closeGameCall; + ///Container type for the return parameters of the [`closeGame()`](closeGameCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct closeGameReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: closeGameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for closeGameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: closeGameReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for closeGameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl closeGameReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for closeGameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = closeGameReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "closeGame()"; + const SELECTOR: [u8; 4] = [120u8, 107u8, 132u8, 75u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + closeGameReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `createdAt()` and selector `0xcf09e0d0`. +```solidity +function createdAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtCall; + ///Container type for the return parameters of the [`createdAt()`](createdAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createdAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "createdAt()"; + const SELECTOR: [u8; 4] = [207u8, 9u8, 224u8, 208u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `credit(address)` and selector `0xd5d44d80`. +```solidity +function credit(address _recipient) external view returns (uint256 credit_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct creditCall { + #[allow(missing_docs)] + pub _recipient: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`credit(address)`](creditCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct creditReturn { + #[allow(missing_docs)] + pub credit_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: creditCall) -> Self { + (value._recipient,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for creditCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _recipient: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: creditReturn) -> Self { + (value.credit_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for creditReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { credit_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for creditCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "credit(address)"; + const SELECTOR: [u8; 4] = [213u8, 212u8, 77u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._recipient, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: creditReturn = r.into(); + r.credit_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: creditReturn = r.into(); + r.credit_ + }) + } + } + }; + /**Function with signature `defend(bytes32,uint256,bytes32)` and selector `0x7b0f0adc`. +```solidity +function defend(Claim _disputed, uint256 _parentIndex, Claim _claim) external payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct defendCall { + #[allow(missing_docs)] + pub _disputed: ::RustType, + #[allow(missing_docs)] + pub _parentIndex: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _claim: ::RustType, + } + ///Container type for the return parameters of the [`defend(bytes32,uint256,bytes32)`](defendCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct defendReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + Claim, + alloy::sol_types::sol_data::Uint<256>, + Claim, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: defendCall) -> Self { + (value._disputed, value._parentIndex, value._claim) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for defendCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _disputed: tuple.0, + _parentIndex: tuple.1, + _claim: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: defendReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for defendReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl defendReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for defendCall { + type Parameters<'a> = (Claim, alloy::sol_types::sol_data::Uint<256>, Claim); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = defendReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "defend(bytes32,uint256,bytes32)"; + const SELECTOR: [u8; 4] = [123u8, 15u8, 10u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._disputed), + as alloy_sol_types::SolType>::tokenize(&self._parentIndex), + ::tokenize(&self._claim), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + defendReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `extraData()` and selector `0x609d3334`. +```solidity +function extraData() external pure returns (bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataCall; + ///Container type for the return parameters of the [`extraData()`](extraDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataReturn { + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataReturn) -> Self { + (value.extraData_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { extraData_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for extraDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Bytes; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "extraData()"; + const SELECTOR: [u8; 4] = [96u8, 157u8, 51u8, 52u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + } + }; + /**Function with signature `gameCreator()` and selector `0x37b1b229`. +```solidity +function gameCreator() external pure returns (address creator_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorCall; + ///Container type for the return parameters of the [`gameCreator()`](gameCreatorCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorReturn { + #[allow(missing_docs)] + pub creator_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorReturn) -> Self { + (value.creator_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { creator_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameCreatorCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameCreator()"; + const SELECTOR: [u8; 4] = [55u8, 177u8, 178u8, 41u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r.creator_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r.creator_ + }) + } + } + }; + /**Function with signature `gameData()` and selector `0xfa24f743`. +```solidity +function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataCall; + ///Container type for the return parameters of the [`gameData()`](gameDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + #[allow(missing_docs)] + pub rootClaim_: ::RustType, + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataReturn) -> Self { + (value.gameType_, value.rootClaim_, value.extraData_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + gameType_: tuple.0, + rootClaim_: tuple.1, + extraData_: tuple.2, + } + } + } + } + impl gameDataReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.gameType_), + ::tokenize(&self.rootClaim_), + ::tokenize( + &self.extraData_, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = gameDataReturn; + type ReturnTuple<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameData()"; + const SELECTOR: [u8; 4] = [250u8, 36u8, 247u8, 67u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + gameDataReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `gameType()` and selector `0xbbdc02db`. +```solidity +function gameType() external view returns (GameType gameType_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeCall; + ///Container type for the return parameters of the [`gameType()`](gameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeReturn) -> Self { + (value.gameType_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { gameType_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameTypeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameType,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameType()"; + const SELECTOR: [u8; 4] = [187u8, 220u8, 2u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r.gameType_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r.gameType_ + }) + } + } + }; + /**Function with signature `getChallengerDuration(uint256)` and selector `0xbd8da956`. +```solidity +function getChallengerDuration(uint256 _claimIndex) external view returns (Duration duration_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getChallengerDurationCall { + #[allow(missing_docs)] + pub _claimIndex: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`getChallengerDuration(uint256)`](getChallengerDurationCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getChallengerDurationReturn { + #[allow(missing_docs)] + pub duration_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getChallengerDurationCall) -> Self { + (value._claimIndex,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getChallengerDurationCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _claimIndex: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Duration,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getChallengerDurationReturn) -> Self { + (value.duration_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getChallengerDurationReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { duration_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getChallengerDurationCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Duration,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getChallengerDuration(uint256)"; + const SELECTOR: [u8; 4] = [189u8, 141u8, 169u8, 86u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._claimIndex), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getChallengerDurationReturn = r.into(); + r.duration_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getChallengerDurationReturn = r.into(); + r.duration_ + }) + } + } + }; + /**Function with signature `getNumToResolve(uint256)` and selector `0x5a5fa2d9`. +```solidity +function getNumToResolve(uint256 _claimIndex) external view returns (uint256 numRemainingChildren_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getNumToResolveCall { + #[allow(missing_docs)] + pub _claimIndex: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`getNumToResolve(uint256)`](getNumToResolveCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getNumToResolveReturn { + #[allow(missing_docs)] + pub numRemainingChildren_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getNumToResolveCall) -> Self { + (value._claimIndex,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getNumToResolveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _claimIndex: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getNumToResolveReturn) -> Self { + (value.numRemainingChildren_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getNumToResolveReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + numRemainingChildren_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getNumToResolveCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getNumToResolve(uint256)"; + const SELECTOR: [u8; 4] = [90u8, 95u8, 162u8, 217u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._claimIndex), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getNumToResolveReturn = r.into(); + r.numRemainingChildren_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getNumToResolveReturn = r.into(); + r.numRemainingChildren_ + }) + } + } + }; + /**Function with signature `getRequiredBond(uint128)` and selector `0xc395e1ca`. +```solidity +function getRequiredBond(Position _position) external view returns (uint256 requiredBond_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getRequiredBondCall { + #[allow(missing_docs)] + pub _position: ::RustType, + } + ///Container type for the return parameters of the [`getRequiredBond(uint128)`](getRequiredBondCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getRequiredBondReturn { + #[allow(missing_docs)] + pub requiredBond_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Position,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getRequiredBondCall) -> Self { + (value._position,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getRequiredBondCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _position: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getRequiredBondReturn) -> Self { + (value.requiredBond_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getRequiredBondReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { requiredBond_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getRequiredBondCall { + type Parameters<'a> = (Position,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getRequiredBond(uint128)"; + const SELECTOR: [u8; 4] = [195u8, 149u8, 225u8, 202u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self._position),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getRequiredBondReturn = r.into(); + r.requiredBond_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getRequiredBondReturn = r.into(); + r.requiredBond_ + }) + } + } + }; + /**Function with signature `hasUnlockedCredit(address)` and selector `0x222abf45`. +```solidity +function hasUnlockedCredit(address) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct hasUnlockedCreditCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`hasUnlockedCredit(address)`](hasUnlockedCreditCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct hasUnlockedCreditReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: hasUnlockedCreditCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for hasUnlockedCreditCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: hasUnlockedCreditReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for hasUnlockedCreditReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for hasUnlockedCreditCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "hasUnlockedCredit(address)"; + const SELECTOR: [u8; 4] = [34u8, 42u8, 191u8, 69u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: hasUnlockedCreditReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: hasUnlockedCreditReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initialize()` and selector `0x8129fc1c`. +```solidity +function initialize() external payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall; + ///Container type for the return parameters of the [`initialize()`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize()"; + const SELECTOR: [u8; 4] = [129u8, 41u8, 252u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `l1Head()` and selector `0x6361506d`. +```solidity +function l1Head() external pure returns (Hash l1Head_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadCall; + ///Container type for the return parameters of the [`l1Head()`](l1HeadCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadReturn { + #[allow(missing_docs)] + pub l1Head_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadReturn) -> Self { + (value.l1Head_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l1Head_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l1HeadCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Hash,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l1Head()"; + const SELECTOR: [u8; 4] = [99u8, 97u8, 80u8, 109u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r.l1Head_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r.l1Head_ + }) + } + } + }; + /**Function with signature `l2BlockNumber()` and selector `0x8b85902b`. +```solidity +function l2BlockNumber() external pure returns (uint256 l2BlockNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockNumberCall; + ///Container type for the return parameters of the [`l2BlockNumber()`](l2BlockNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockNumberReturn { + #[allow(missing_docs)] + pub l2BlockNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l2BlockNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l2BlockNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l2BlockNumberReturn) -> Self { + (value.l2BlockNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l2BlockNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l2BlockNumber_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2BlockNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2BlockNumber()"; + const SELECTOR: [u8; 4] = [139u8, 133u8, 144u8, 43u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2BlockNumberReturn = r.into(); + r.l2BlockNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2BlockNumberReturn = r.into(); + r.l2BlockNumber_ + }) + } + } + }; + /**Function with signature `l2BlockNumberChallenged()` and selector `0x3e3ac912`. +```solidity +function l2BlockNumberChallenged() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockNumberChallengedCall; + ///Container type for the return parameters of the [`l2BlockNumberChallenged()`](l2BlockNumberChallengedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockNumberChallengedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2BlockNumberChallengedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2BlockNumberChallengedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2BlockNumberChallengedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2BlockNumberChallengedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2BlockNumberChallengedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2BlockNumberChallenged()"; + const SELECTOR: [u8; 4] = [62u8, 58u8, 201u8, 18u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2BlockNumberChallengedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2BlockNumberChallengedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `l2BlockNumberChallenger()` and selector `0x30dbe570`. +```solidity +function l2BlockNumberChallenger() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockNumberChallengerCall; + ///Container type for the return parameters of the [`l2BlockNumberChallenger()`](l2BlockNumberChallengerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockNumberChallengerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2BlockNumberChallengerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2BlockNumberChallengerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2BlockNumberChallengerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2BlockNumberChallengerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2BlockNumberChallengerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2BlockNumberChallenger()"; + const SELECTOR: [u8; 4] = [48u8, 219u8, 229u8, 112u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2BlockNumberChallengerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2BlockNumberChallengerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `l2ChainId()` and selector `0xd6ae3cd5`. +```solidity +function l2ChainId() external view returns (uint256 l2ChainId_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2ChainIdCall; + ///Container type for the return parameters of the [`l2ChainId()`](l2ChainIdCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2ChainIdReturn { + #[allow(missing_docs)] + pub l2ChainId_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l2ChainIdCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l2ChainIdCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l2ChainIdReturn) -> Self { + (value.l2ChainId_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l2ChainIdReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l2ChainId_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2ChainIdCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2ChainId()"; + const SELECTOR: [u8; 4] = [214u8, 174u8, 60u8, 213u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2ChainIdReturn = r.into(); + r.l2ChainId_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2ChainIdReturn = r.into(); + r.l2ChainId_ + }) + } + } + }; + /**Function with signature `l2SequenceNumber()` and selector `0x99735e32`. +```solidity +function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberCall; + ///Container type for the return parameters of the [`l2SequenceNumber()`](l2SequenceNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberReturn { + #[allow(missing_docs)] + pub l2SequenceNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberReturn) -> Self { + (value.l2SequenceNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l2SequenceNumber_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2SequenceNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2SequenceNumber()"; + const SELECTOR: [u8; 4] = [153u8, 115u8, 94u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + } + }; + /**Function with signature `maxClockDuration()` and selector `0xdabd396d`. +```solidity +function maxClockDuration() external view returns (Duration maxClockDuration_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct maxClockDurationCall; + ///Container type for the return parameters of the [`maxClockDuration()`](maxClockDurationCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct maxClockDurationReturn { + #[allow(missing_docs)] + pub maxClockDuration_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: maxClockDurationCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for maxClockDurationCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Duration,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: maxClockDurationReturn) -> Self { + (value.maxClockDuration_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for maxClockDurationReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { maxClockDuration_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for maxClockDurationCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Duration,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "maxClockDuration()"; + const SELECTOR: [u8; 4] = [218u8, 189u8, 57u8, 109u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: maxClockDurationReturn = r.into(); + r.maxClockDuration_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: maxClockDurationReturn = r.into(); + r.maxClockDuration_ + }) + } + } + }; + /**Function with signature `maxGameDepth()` and selector `0xfa315aa9`. +```solidity +function maxGameDepth() external view returns (uint256 maxGameDepth_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct maxGameDepthCall; + ///Container type for the return parameters of the [`maxGameDepth()`](maxGameDepthCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct maxGameDepthReturn { + #[allow(missing_docs)] + pub maxGameDepth_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: maxGameDepthCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for maxGameDepthCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: maxGameDepthReturn) -> Self { + (value.maxGameDepth_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for maxGameDepthReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { maxGameDepth_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for maxGameDepthCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "maxGameDepth()"; + const SELECTOR: [u8; 4] = [250u8, 49u8, 90u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: maxGameDepthReturn = r.into(); + r.maxGameDepth_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: maxGameDepthReturn = r.into(); + r.maxGameDepth_ + }) + } + } + }; + /**Function with signature `move(bytes32,uint256,bytes32,bool)` and selector `0x6f034409`. +```solidity +function r#move(Claim _disputed, uint256 _challengeIndex, Claim _claim, bool _isAttack) external payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct moveCall { + #[allow(missing_docs)] + pub _disputed: ::RustType, + #[allow(missing_docs)] + pub _challengeIndex: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _claim: ::RustType, + #[allow(missing_docs)] + pub _isAttack: bool, + } + ///Container type for the return parameters of the [`move(bytes32,uint256,bytes32,bool)`](moveCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct moveReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + Claim, + alloy::sol_types::sol_data::Uint<256>, + Claim, + alloy::sol_types::sol_data::Bool, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + bool, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: moveCall) -> Self { + ( + value._disputed, + value._challengeIndex, + value._claim, + value._isAttack, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for moveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _disputed: tuple.0, + _challengeIndex: tuple.1, + _claim: tuple.2, + _isAttack: tuple.3, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: moveReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for moveReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl moveReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for moveCall { + type Parameters<'a> = ( + Claim, + alloy::sol_types::sol_data::Uint<256>, + Claim, + alloy::sol_types::sol_data::Bool, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = moveReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "move(bytes32,uint256,bytes32,bool)"; + const SELECTOR: [u8; 4] = [111u8, 3u8, 68u8, 9u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self._disputed), + as alloy_sol_types::SolType>::tokenize(&self._challengeIndex), + ::tokenize(&self._claim), + ::tokenize( + &self._isAttack, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + moveReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `normalModeCredit(address)` and selector `0x529d6a8c`. +```solidity +function normalModeCredit(address) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct normalModeCreditCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`normalModeCredit(address)`](normalModeCreditCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct normalModeCreditReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: normalModeCreditCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for normalModeCreditCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: normalModeCreditReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for normalModeCreditReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for normalModeCreditCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "normalModeCredit(address)"; + const SELECTOR: [u8; 4] = [82u8, 157u8, 106u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: normalModeCreditReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: normalModeCreditReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `refundModeCredit(address)` and selector `0xc0d8bb74`. +```solidity +function refundModeCredit(address) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct refundModeCreditCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`refundModeCredit(address)`](refundModeCreditCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct refundModeCreditReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: refundModeCreditCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for refundModeCreditCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: refundModeCreditReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for refundModeCreditReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for refundModeCreditCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "refundModeCredit(address)"; + const SELECTOR: [u8; 4] = [192u8, 216u8, 187u8, 116u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: refundModeCreditReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: refundModeCreditReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `resolutionCheckpoints(uint256)` and selector `0xa445ece6`. +```solidity +function resolutionCheckpoints(uint256) external view returns (bool initialCheckpointComplete, uint32 subgameIndex, Position leftmostPosition, address counteredBy); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolutionCheckpointsCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + ///Container type for the return parameters of the [`resolutionCheckpoints(uint256)`](resolutionCheckpointsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolutionCheckpointsReturn { + #[allow(missing_docs)] + pub initialCheckpointComplete: bool, + #[allow(missing_docs)] + pub subgameIndex: u32, + #[allow(missing_docs)] + pub leftmostPosition: ::RustType, + #[allow(missing_docs)] + pub counteredBy: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: resolutionCheckpointsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for resolutionCheckpointsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Uint<32>, + Position, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + bool, + u32, + ::RustType, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: resolutionCheckpointsReturn) -> Self { + ( + value.initialCheckpointComplete, + value.subgameIndex, + value.leftmostPosition, + value.counteredBy, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for resolutionCheckpointsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + initialCheckpointComplete: tuple.0, + subgameIndex: tuple.1, + leftmostPosition: tuple.2, + counteredBy: tuple.3, + } + } + } + } + impl resolutionCheckpointsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + ::tokenize( + &self.initialCheckpointComplete, + ), + as alloy_sol_types::SolType>::tokenize(&self.subgameIndex), + ::tokenize( + &self.leftmostPosition, + ), + ::tokenize( + &self.counteredBy, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolutionCheckpointsCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = resolutionCheckpointsReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Uint<32>, + Position, + alloy::sol_types::sol_data::Address, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolutionCheckpoints(uint256)"; + const SELECTOR: [u8; 4] = [164u8, 69u8, 236u8, 230u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + resolutionCheckpointsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `resolve()` and selector `0x2810e1d6`. +```solidity +function resolve() external returns (GameStatus status_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveCall; + ///Container type for the return parameters of the [`resolve()`](resolveCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveReturn { + #[allow(missing_docs)] + pub status_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveReturn) -> Self { + (value.status_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { status_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolveCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolve()"; + const SELECTOR: [u8; 4] = [40u8, 16u8, 225u8, 214u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolveReturn = r.into(); + r.status_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolveReturn = r.into(); + r.status_ + }) + } + } + }; + /**Function with signature `resolveClaim(uint256,uint256)` and selector `0x03c2924d`. +```solidity +function resolveClaim(uint256 _claimIndex, uint256 _numToResolve) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveClaimCall { + #[allow(missing_docs)] + pub _claimIndex: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _numToResolve: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`resolveClaim(uint256,uint256)`](resolveClaimCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveClaimReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveClaimCall) -> Self { + (value._claimIndex, value._numToResolve) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveClaimCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _claimIndex: tuple.0, + _numToResolve: tuple.1, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveClaimReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveClaimReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl resolveClaimReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolveClaimCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = resolveClaimReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolveClaim(uint256,uint256)"; + const SELECTOR: [u8; 4] = [3u8, 194u8, 146u8, 77u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._claimIndex), + as alloy_sol_types::SolType>::tokenize(&self._numToResolve), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + resolveClaimReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `resolvedAt()` and selector `0x19effeb4`. +```solidity +function resolvedAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtCall; + ///Container type for the return parameters of the [`resolvedAt()`](resolvedAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolvedAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolvedAt()"; + const SELECTOR: [u8; 4] = [25u8, 239u8, 254u8, 180u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `resolvedSubgames(uint256)` and selector `0xfe2bbeb2`. +```solidity +function resolvedSubgames(uint256) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedSubgamesCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + ///Container type for the return parameters of the [`resolvedSubgames(uint256)`](resolvedSubgamesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedSubgamesReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: resolvedSubgamesCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for resolvedSubgamesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: resolvedSubgamesReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for resolvedSubgamesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolvedSubgamesCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolvedSubgames(uint256)"; + const SELECTOR: [u8; 4] = [254u8, 43u8, 190u8, 178u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolvedSubgamesReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolvedSubgamesReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `rootClaim()` and selector `0xbcef3b55`. +```solidity +function rootClaim() external pure returns (Claim rootClaim_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimCall; + ///Container type for the return parameters of the [`rootClaim()`](rootClaimCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimReturn { + #[allow(missing_docs)] + pub rootClaim_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Claim,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimReturn) -> Self { + (value.rootClaim_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { rootClaim_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for rootClaimCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Claim,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "rootClaim()"; + const SELECTOR: [u8; 4] = [188u8, 239u8, 59u8, 85u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r.rootClaim_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r.rootClaim_ + }) + } + } + }; + /**Function with signature `splitDepth()` and selector `0xec5e6308`. +```solidity +function splitDepth() external view returns (uint256 splitDepth_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct splitDepthCall; + ///Container type for the return parameters of the [`splitDepth()`](splitDepthCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct splitDepthReturn { + #[allow(missing_docs)] + pub splitDepth_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: splitDepthCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for splitDepthCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: splitDepthReturn) -> Self { + (value.splitDepth_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for splitDepthReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { splitDepth_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for splitDepthCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "splitDepth()"; + const SELECTOR: [u8; 4] = [236u8, 94u8, 99u8, 8u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: splitDepthReturn = r.into(); + r.splitDepth_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: splitDepthReturn = r.into(); + r.splitDepth_ + }) + } + } + }; + /**Function with signature `startingBlockNumber()` and selector `0x70872aa5`. +```solidity +function startingBlockNumber() external view returns (uint256 startingBlockNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingBlockNumberCall; + ///Container type for the return parameters of the [`startingBlockNumber()`](startingBlockNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingBlockNumberReturn { + #[allow(missing_docs)] + pub startingBlockNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingBlockNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingBlockNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingBlockNumberReturn) -> Self { + (value.startingBlockNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingBlockNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + startingBlockNumber_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for startingBlockNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "startingBlockNumber()"; + const SELECTOR: [u8; 4] = [112u8, 135u8, 42u8, 165u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: startingBlockNumberReturn = r.into(); + r.startingBlockNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: startingBlockNumberReturn = r.into(); + r.startingBlockNumber_ + }) + } + } + }; + /**Function with signature `startingOutputRoot()` and selector `0x57da950e`. +```solidity +function startingOutputRoot() external view returns (Hash root, uint256 l2SequenceNumber); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingOutputRootCall; + ///Container type for the return parameters of the [`startingOutputRoot()`](startingOutputRootCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingOutputRootReturn { + #[allow(missing_docs)] + pub root: ::RustType, + #[allow(missing_docs)] + pub l2SequenceNumber: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingOutputRootCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingOutputRootCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingOutputRootReturn) -> Self { + (value.root, value.l2SequenceNumber) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingOutputRootReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + root: tuple.0, + l2SequenceNumber: tuple.1, + } + } + } + } + impl startingOutputRootReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.root), + as alloy_sol_types::SolType>::tokenize(&self.l2SequenceNumber), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for startingOutputRootCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = startingOutputRootReturn; + type ReturnTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "startingOutputRoot()"; + const SELECTOR: [u8; 4] = [87u8, 218u8, 149u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + startingOutputRootReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `startingRootHash()` and selector `0x25fc2ace`. +```solidity +function startingRootHash() external view returns (Hash startingRootHash_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingRootHashCall; + ///Container type for the return parameters of the [`startingRootHash()`](startingRootHashCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingRootHashReturn { + #[allow(missing_docs)] + pub startingRootHash_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingRootHashCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingRootHashCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingRootHashReturn) -> Self { + (value.startingRootHash_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingRootHashReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { startingRootHash_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for startingRootHashCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Hash,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "startingRootHash()"; + const SELECTOR: [u8; 4] = [37u8, 252u8, 42u8, 206u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: startingRootHashReturn = r.into(); + r.startingRootHash_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: startingRootHashReturn = r.into(); + r.startingRootHash_ + }) + } + } + }; + /**Function with signature `status()` and selector `0x200d2ed2`. +```solidity +function status() external view returns (GameStatus); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusCall; + ///Container type for the return parameters of the [`status()`](statusCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for statusCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "status()"; + const SELECTOR: [u8; 4] = [32u8, 13u8, 46u8, 210u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `step(uint256,bool,bytes,bytes)` and selector `0xd8cc1a3c`. +```solidity +function step(uint256 _claimIndex, bool _isAttack, bytes memory _stateData, bytes memory _proof) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct stepCall { + #[allow(missing_docs)] + pub _claimIndex: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _isAttack: bool, + #[allow(missing_docs)] + pub _stateData: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub _proof: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`step(uint256,bool,bytes,bytes)`](stepCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct stepReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + bool, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: stepCall) -> Self { + (value._claimIndex, value._isAttack, value._stateData, value._proof) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for stepCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _claimIndex: tuple.0, + _isAttack: tuple.1, + _stateData: tuple.2, + _proof: tuple.3, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: stepReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for stepReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl stepReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for stepCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Bytes, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = stepReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "step(uint256,bool,bytes,bytes)"; + const SELECTOR: [u8; 4] = [216u8, 204u8, 26u8, 60u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._claimIndex), + ::tokenize( + &self._isAttack, + ), + ::tokenize( + &self._stateData, + ), + ::tokenize( + &self._proof, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + stepReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `subgames(uint256,uint256)` and selector `0x2ad69aeb`. +```solidity +function subgames(uint256, uint256) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct subgamesCall { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _1: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`subgames(uint256,uint256)`](subgamesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct subgamesReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: subgamesCall) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for subgamesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: subgamesReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for subgamesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for subgamesCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "subgames(uint256,uint256)"; + const SELECTOR: [u8; 4] = [42u8, 214u8, 154u8, 235u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: subgamesReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: subgamesReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `version()` and selector `0x54fd4d50`. +```solidity +function version() external pure returns (string memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionCall; + ///Container type for the return parameters of the [`version()`](versionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for versionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "version()"; + const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `vm()` and selector `0x3a768463`. +```solidity +function vm() external view returns (address vm_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct vmCall; + ///Container type for the return parameters of the [`vm()`](vmCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct vmReturn { + #[allow(missing_docs)] + pub vm_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: vmCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for vmCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: vmReturn) -> Self { + (value.vm_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for vmReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { vm_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for vmCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "vm()"; + const SELECTOR: [u8; 4] = [58u8, 118u8, 132u8, 99u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: vmReturn = r.into(); + r.vm_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: vmReturn = r.into(); + r.vm_ + }) + } + } + }; + /**Function with signature `wasRespectedGameTypeWhenCreated()` and selector `0x250e69bd`. +```solidity +function wasRespectedGameTypeWhenCreated() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedCall; + ///Container type for the return parameters of the [`wasRespectedGameTypeWhenCreated()`](wasRespectedGameTypeWhenCreatedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for wasRespectedGameTypeWhenCreatedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "wasRespectedGameTypeWhenCreated()"; + const SELECTOR: [u8; 4] = [37u8, 14u8, 105u8, 189u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `weth()` and selector `0x3fc8cef3`. +```solidity +function weth() external view returns (address weth_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wethCall; + ///Container type for the return parameters of the [`weth()`](wethCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wethReturn { + #[allow(missing_docs)] + pub weth_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: wethCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for wethCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: wethReturn) -> Self { + (value.weth_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for wethReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { weth_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for wethCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "weth()"; + const SELECTOR: [u8; 4] = [63u8, 200u8, 206u8, 243u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: wethReturn = r.into(); + r.weth_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: wethReturn = r.into(); + r.weth_ + }) + } + } + }; + ///Container for all the [`IFaultDisputeGame`](self) function calls. + #[derive(Clone)] + pub enum IFaultDisputeGameCalls { + #[allow(missing_docs)] + __constructor__(__constructor__Call), + #[allow(missing_docs)] + absolutePrestate(absolutePrestateCall), + #[allow(missing_docs)] + addLocalData(addLocalDataCall), + #[allow(missing_docs)] + anchorStateRegistry(anchorStateRegistryCall), + #[allow(missing_docs)] + attack(attackCall), + #[allow(missing_docs)] + bondDistributionMode(bondDistributionModeCall), + #[allow(missing_docs)] + challengeRootL2Block(challengeRootL2BlockCall), + #[allow(missing_docs)] + claimCredit(claimCreditCall), + #[allow(missing_docs)] + claimData(claimDataCall), + #[allow(missing_docs)] + claimDataLen(claimDataLenCall), + #[allow(missing_docs)] + claims(claimsCall), + #[allow(missing_docs)] + clockExtension(clockExtensionCall), + #[allow(missing_docs)] + closeGame(closeGameCall), + #[allow(missing_docs)] + createdAt(createdAtCall), + #[allow(missing_docs)] + credit(creditCall), + #[allow(missing_docs)] + defend(defendCall), + #[allow(missing_docs)] + extraData(extraDataCall), + #[allow(missing_docs)] + gameCreator(gameCreatorCall), + #[allow(missing_docs)] + gameData(gameDataCall), + #[allow(missing_docs)] + gameType(gameTypeCall), + #[allow(missing_docs)] + getChallengerDuration(getChallengerDurationCall), + #[allow(missing_docs)] + getNumToResolve(getNumToResolveCall), + #[allow(missing_docs)] + getRequiredBond(getRequiredBondCall), + #[allow(missing_docs)] + hasUnlockedCredit(hasUnlockedCreditCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + l1Head(l1HeadCall), + #[allow(missing_docs)] + l2BlockNumber(l2BlockNumberCall), + #[allow(missing_docs)] + l2BlockNumberChallenged(l2BlockNumberChallengedCall), + #[allow(missing_docs)] + l2BlockNumberChallenger(l2BlockNumberChallengerCall), + #[allow(missing_docs)] + l2ChainId(l2ChainIdCall), + #[allow(missing_docs)] + l2SequenceNumber(l2SequenceNumberCall), + #[allow(missing_docs)] + maxClockDuration(maxClockDurationCall), + #[allow(missing_docs)] + maxGameDepth(maxGameDepthCall), + #[allow(missing_docs)] + r#move(moveCall), + #[allow(missing_docs)] + normalModeCredit(normalModeCreditCall), + #[allow(missing_docs)] + refundModeCredit(refundModeCreditCall), + #[allow(missing_docs)] + resolutionCheckpoints(resolutionCheckpointsCall), + #[allow(missing_docs)] + resolve(resolveCall), + #[allow(missing_docs)] + resolveClaim(resolveClaimCall), + #[allow(missing_docs)] + resolvedAt(resolvedAtCall), + #[allow(missing_docs)] + resolvedSubgames(resolvedSubgamesCall), + #[allow(missing_docs)] + rootClaim(rootClaimCall), + #[allow(missing_docs)] + splitDepth(splitDepthCall), + #[allow(missing_docs)] + startingBlockNumber(startingBlockNumberCall), + #[allow(missing_docs)] + startingOutputRoot(startingOutputRootCall), + #[allow(missing_docs)] + startingRootHash(startingRootHashCall), + #[allow(missing_docs)] + status(statusCall), + #[allow(missing_docs)] + step(stepCall), + #[allow(missing_docs)] + subgames(subgamesCall), + #[allow(missing_docs)] + version(versionCall), + #[allow(missing_docs)] + vm(vmCall), + #[allow(missing_docs)] + wasRespectedGameTypeWhenCreated(wasRespectedGameTypeWhenCreatedCall), + #[allow(missing_docs)] + weth(wethCall), + } + impl IFaultDisputeGameCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [1u8, 147u8, 81u8, 48u8], + [3u8, 194u8, 146u8, 77u8], + [25u8, 239u8, 254u8, 180u8], + [32u8, 13u8, 46u8, 210u8], + [34u8, 42u8, 191u8, 69u8], + [37u8, 14u8, 105u8, 189u8], + [37u8, 252u8, 42u8, 206u8], + [40u8, 16u8, 225u8, 214u8], + [42u8, 214u8, 154u8, 235u8], + [48u8, 219u8, 229u8, 112u8], + [55u8, 141u8, 212u8, 140u8], + [55u8, 177u8, 178u8, 41u8], + [58u8, 118u8, 132u8, 99u8], + [62u8, 58u8, 201u8, 18u8], + [63u8, 200u8, 206u8, 243u8], + [71u8, 39u8, 119u8, 198u8], + [82u8, 157u8, 106u8, 140u8], + [84u8, 253u8, 77u8, 80u8], + [85u8, 153u8, 198u8, 70u8], + [87u8, 218u8, 149u8, 14u8], + [90u8, 95u8, 162u8, 217u8], + [92u8, 12u8, 186u8, 51u8], + [96u8, 157u8, 51u8, 52u8], + [96u8, 226u8, 116u8, 100u8], + [99u8, 97u8, 80u8, 109u8], + [107u8, 103u8, 22u8, 192u8], + [111u8, 3u8, 68u8, 9u8], + [112u8, 135u8, 42u8, 165u8], + [120u8, 107u8, 132u8, 75u8], + [123u8, 15u8, 10u8, 220u8], + [129u8, 41u8, 252u8, 28u8], + [137u8, 128u8, 224u8, 204u8], + [139u8, 133u8, 144u8, 43u8], + [141u8, 69u8, 10u8, 149u8], + [153u8, 115u8, 94u8, 50u8], + [164u8, 69u8, 236u8, 230u8], + [187u8, 220u8, 2u8, 219u8], + [188u8, 239u8, 59u8, 85u8], + [189u8, 141u8, 169u8, 86u8], + [192u8, 216u8, 187u8, 116u8], + [195u8, 149u8, 225u8, 202u8], + [198u8, 240u8, 48u8, 140u8], + [207u8, 9u8, 224u8, 208u8], + [213u8, 212u8, 77u8, 128u8], + [214u8, 174u8, 60u8, 213u8], + [216u8, 204u8, 26u8, 60u8], + [218u8, 189u8, 57u8, 109u8], + [236u8, 94u8, 99u8, 8u8], + [239u8, 240u8, 245u8, 146u8], + [248u8, 244u8, 63u8, 246u8], + [250u8, 36u8, 247u8, 67u8], + [250u8, 49u8, 90u8, 169u8], + [254u8, 43u8, 190u8, 178u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(challengeRootL2Block), + ::core::stringify!(resolveClaim), + ::core::stringify!(resolvedAt), + ::core::stringify!(status), + ::core::stringify!(hasUnlockedCredit), + ::core::stringify!(wasRespectedGameTypeWhenCreated), + ::core::stringify!(startingRootHash), + ::core::stringify!(resolve), + ::core::stringify!(subgames), + ::core::stringify!(l2BlockNumberChallenger), + ::core::stringify!(bondDistributionMode), + ::core::stringify!(gameCreator), + ::core::stringify!(vm), + ::core::stringify!(l2BlockNumberChallenged), + ::core::stringify!(weth), + ::core::stringify!(attack), + ::core::stringify!(normalModeCredit), + ::core::stringify!(version), + ::core::stringify!(__constructor__), + ::core::stringify!(startingOutputRoot), + ::core::stringify!(getNumToResolve), + ::core::stringify!(anchorStateRegistry), + ::core::stringify!(extraData), + ::core::stringify!(claimCredit), + ::core::stringify!(l1Head), + ::core::stringify!(clockExtension), + ::core::stringify!(r#move), + ::core::stringify!(startingBlockNumber), + ::core::stringify!(closeGame), + ::core::stringify!(defend), + ::core::stringify!(initialize), + ::core::stringify!(claimDataLen), + ::core::stringify!(l2BlockNumber), + ::core::stringify!(absolutePrestate), + ::core::stringify!(l2SequenceNumber), + ::core::stringify!(resolutionCheckpoints), + ::core::stringify!(gameType), + ::core::stringify!(rootClaim), + ::core::stringify!(getChallengerDuration), + ::core::stringify!(refundModeCredit), + ::core::stringify!(getRequiredBond), + ::core::stringify!(claimData), + ::core::stringify!(createdAt), + ::core::stringify!(credit), + ::core::stringify!(l2ChainId), + ::core::stringify!(step), + ::core::stringify!(maxClockDuration), + ::core::stringify!(splitDepth), + ::core::stringify!(claims), + ::core::stringify!(addLocalData), + ::core::stringify!(gameData), + ::core::stringify!(maxGameDepth), + ::core::stringify!(resolvedSubgames), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + <__constructor__Call as alloy_sol_types::SolCall>::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IFaultDisputeGameCalls { + const NAME: &'static str = "IFaultDisputeGameCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 53usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::__constructor__(_) => { + <__constructor__Call as alloy_sol_types::SolCall>::SELECTOR + } + Self::absolutePrestate(_) => { + ::SELECTOR + } + Self::addLocalData(_) => { + ::SELECTOR + } + Self::anchorStateRegistry(_) => { + ::SELECTOR + } + Self::attack(_) => ::SELECTOR, + Self::bondDistributionMode(_) => { + ::SELECTOR + } + Self::challengeRootL2Block(_) => { + ::SELECTOR + } + Self::claimCredit(_) => { + ::SELECTOR + } + Self::claimData(_) => { + ::SELECTOR + } + Self::claimDataLen(_) => { + ::SELECTOR + } + Self::claims(_) => ::SELECTOR, + Self::clockExtension(_) => { + ::SELECTOR + } + Self::closeGame(_) => { + ::SELECTOR + } + Self::createdAt(_) => { + ::SELECTOR + } + Self::credit(_) => ::SELECTOR, + Self::defend(_) => ::SELECTOR, + Self::extraData(_) => { + ::SELECTOR + } + Self::gameCreator(_) => { + ::SELECTOR + } + Self::gameData(_) => ::SELECTOR, + Self::gameType(_) => ::SELECTOR, + Self::getChallengerDuration(_) => { + ::SELECTOR + } + Self::getNumToResolve(_) => { + ::SELECTOR + } + Self::getRequiredBond(_) => { + ::SELECTOR + } + Self::hasUnlockedCredit(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } + Self::l1Head(_) => ::SELECTOR, + Self::l2BlockNumber(_) => { + ::SELECTOR + } + Self::l2BlockNumberChallenged(_) => { + ::SELECTOR + } + Self::l2BlockNumberChallenger(_) => { + ::SELECTOR + } + Self::l2ChainId(_) => { + ::SELECTOR + } + Self::l2SequenceNumber(_) => { + ::SELECTOR + } + Self::maxClockDuration(_) => { + ::SELECTOR + } + Self::maxGameDepth(_) => { + ::SELECTOR + } + Self::r#move(_) => ::SELECTOR, + Self::normalModeCredit(_) => { + ::SELECTOR + } + Self::refundModeCredit(_) => { + ::SELECTOR + } + Self::resolutionCheckpoints(_) => { + ::SELECTOR + } + Self::resolve(_) => ::SELECTOR, + Self::resolveClaim(_) => { + ::SELECTOR + } + Self::resolvedAt(_) => { + ::SELECTOR + } + Self::resolvedSubgames(_) => { + ::SELECTOR + } + Self::rootClaim(_) => { + ::SELECTOR + } + Self::splitDepth(_) => { + ::SELECTOR + } + Self::startingBlockNumber(_) => { + ::SELECTOR + } + Self::startingOutputRoot(_) => { + ::SELECTOR + } + Self::startingRootHash(_) => { + ::SELECTOR + } + Self::status(_) => ::SELECTOR, + Self::step(_) => ::SELECTOR, + Self::subgames(_) => ::SELECTOR, + Self::version(_) => ::SELECTOR, + Self::vm(_) => ::SELECTOR, + Self::wasRespectedGameTypeWhenCreated(_) => { + ::SELECTOR + } + Self::weth(_) => ::SELECTOR, + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn challengeRootL2Block( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::challengeRootL2Block) + } + challengeRootL2Block + }, + { + fn resolveClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::resolveClaim) + } + resolveClaim + }, + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::status) + } + status + }, + { + fn hasUnlockedCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::hasUnlockedCredit) + } + hasUnlockedCredit + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::wasRespectedGameTypeWhenCreated) + } + wasRespectedGameTypeWhenCreated + }, + { + fn startingRootHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::startingRootHash) + } + startingRootHash + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::resolve) + } + resolve + }, + { + fn subgames( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::subgames) + } + subgames + }, + { + fn l2BlockNumberChallenger( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::l2BlockNumberChallenger) + } + l2BlockNumberChallenger + }, + { + fn bondDistributionMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::bondDistributionMode) + } + bondDistributionMode + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn vm( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::vm) + } + vm + }, + { + fn l2BlockNumberChallenged( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::l2BlockNumberChallenged) + } + l2BlockNumberChallenged + }, + { + fn weth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::weth) + } + weth + }, + { + fn attack( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::attack) + } + attack + }, + { + fn normalModeCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::normalModeCredit) + } + normalModeCredit + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::version) + } + version + }, + { + fn __constructor__( + data: &[u8], + ) -> alloy_sol_types::Result { + <__constructor__Call as alloy_sol_types::SolCall>::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::__constructor__) + } + __constructor__ + }, + { + fn startingOutputRoot( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::startingOutputRoot) + } + startingOutputRoot + }, + { + fn getNumToResolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::getNumToResolve) + } + getNumToResolve + }, + { + fn anchorStateRegistry( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::anchorStateRegistry) + } + anchorStateRegistry + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::extraData) + } + extraData + }, + { + fn claimCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::claimCredit) + } + claimCredit + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn clockExtension( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::clockExtension) + } + clockExtension + }, + { + fn r#move( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::r#move) + } + r#move + }, + { + fn startingBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::startingBlockNumber) + } + startingBlockNumber + }, + { + fn closeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::closeGame) + } + closeGame + }, + { + fn defend( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::defend) + } + defend + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::initialize) + } + initialize + }, + { + fn claimDataLen( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::claimDataLen) + } + claimDataLen + }, + { + fn l2BlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::l2BlockNumber) + } + l2BlockNumber + }, + { + fn absolutePrestate( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::absolutePrestate) + } + absolutePrestate + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn resolutionCheckpoints( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::resolutionCheckpoints) + } + resolutionCheckpoints + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::gameType) + } + gameType + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn getChallengerDuration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::getChallengerDuration) + } + getChallengerDuration + }, + { + fn refundModeCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::refundModeCredit) + } + refundModeCredit + }, + { + fn getRequiredBond( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::getRequiredBond) + } + getRequiredBond + }, + { + fn claimData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::claimData) + } + claimData + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn credit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::credit) + } + credit + }, + { + fn l2ChainId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::l2ChainId) + } + l2ChainId + }, + { + fn step( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::step) + } + step + }, + { + fn maxClockDuration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::maxClockDuration) + } + maxClockDuration + }, + { + fn splitDepth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::splitDepth) + } + splitDepth + }, + { + fn claims( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::claims) + } + claims + }, + { + fn addLocalData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::addLocalData) + } + addLocalData + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameCalls::gameData) + } + gameData + }, + { + fn maxGameDepth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::maxGameDepth) + } + maxGameDepth + }, + { + fn resolvedSubgames( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameCalls::resolvedSubgames) + } + resolvedSubgames + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn challengeRootL2Block( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::challengeRootL2Block) + } + challengeRootL2Block + }, + { + fn resolveClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::resolveClaim) + } + resolveClaim + }, + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::status) + } + status + }, + { + fn hasUnlockedCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::hasUnlockedCredit) + } + hasUnlockedCredit + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::wasRespectedGameTypeWhenCreated) + } + wasRespectedGameTypeWhenCreated + }, + { + fn startingRootHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::startingRootHash) + } + startingRootHash + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::resolve) + } + resolve + }, + { + fn subgames( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::subgames) + } + subgames + }, + { + fn l2BlockNumberChallenger( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::l2BlockNumberChallenger) + } + l2BlockNumberChallenger + }, + { + fn bondDistributionMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::bondDistributionMode) + } + bondDistributionMode + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn vm( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::vm) + } + vm + }, + { + fn l2BlockNumberChallenged( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::l2BlockNumberChallenged) + } + l2BlockNumberChallenged + }, + { + fn weth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::weth) + } + weth + }, + { + fn attack( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::attack) + } + attack + }, + { + fn normalModeCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::normalModeCredit) + } + normalModeCredit + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::version) + } + version + }, + { + fn __constructor__( + data: &[u8], + ) -> alloy_sol_types::Result { + <__constructor__Call as alloy_sol_types::SolCall>::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::__constructor__) + } + __constructor__ + }, + { + fn startingOutputRoot( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::startingOutputRoot) + } + startingOutputRoot + }, + { + fn getNumToResolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::getNumToResolve) + } + getNumToResolve + }, + { + fn anchorStateRegistry( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::anchorStateRegistry) + } + anchorStateRegistry + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::extraData) + } + extraData + }, + { + fn claimCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::claimCredit) + } + claimCredit + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn clockExtension( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::clockExtension) + } + clockExtension + }, + { + fn r#move( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::r#move) + } + r#move + }, + { + fn startingBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::startingBlockNumber) + } + startingBlockNumber + }, + { + fn closeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::closeGame) + } + closeGame + }, + { + fn defend( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::defend) + } + defend + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::initialize) + } + initialize + }, + { + fn claimDataLen( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::claimDataLen) + } + claimDataLen + }, + { + fn l2BlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::l2BlockNumber) + } + l2BlockNumber + }, + { + fn absolutePrestate( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::absolutePrestate) + } + absolutePrestate + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn resolutionCheckpoints( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::resolutionCheckpoints) + } + resolutionCheckpoints + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::gameType) + } + gameType + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn getChallengerDuration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::getChallengerDuration) + } + getChallengerDuration + }, + { + fn refundModeCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::refundModeCredit) + } + refundModeCredit + }, + { + fn getRequiredBond( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::getRequiredBond) + } + getRequiredBond + }, + { + fn claimData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::claimData) + } + claimData + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn credit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::credit) + } + credit + }, + { + fn l2ChainId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::l2ChainId) + } + l2ChainId + }, + { + fn step( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::step) + } + step + }, + { + fn maxClockDuration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::maxClockDuration) + } + maxClockDuration + }, + { + fn splitDepth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::splitDepth) + } + splitDepth + }, + { + fn claims( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::claims) + } + claims + }, + { + fn addLocalData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::addLocalData) + } + addLocalData + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::gameData) + } + gameData + }, + { + fn maxGameDepth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::maxGameDepth) + } + maxGameDepth + }, + { + fn resolvedSubgames( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameCalls::resolvedSubgames) + } + resolvedSubgames + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::__constructor__(inner) => { + <__constructor__Call as alloy_sol_types::SolCall>::abi_encoded_size( + inner, + ) + } + Self::absolutePrestate(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::addLocalData(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::anchorStateRegistry(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::attack(inner) => { + ::abi_encoded_size(inner) + } + Self::bondDistributionMode(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::challengeRootL2Block(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::claimCredit(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::claimData(inner) => { + ::abi_encoded_size(inner) + } + Self::claimDataLen(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::claims(inner) => { + ::abi_encoded_size(inner) + } + Self::clockExtension(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::closeGame(inner) => { + ::abi_encoded_size(inner) + } + Self::createdAt(inner) => { + ::abi_encoded_size(inner) + } + Self::credit(inner) => { + ::abi_encoded_size(inner) + } + Self::defend(inner) => { + ::abi_encoded_size(inner) + } + Self::extraData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameCreator(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::gameData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameType(inner) => { + ::abi_encoded_size(inner) + } + Self::getChallengerDuration(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getNumToResolve(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getRequiredBond(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::hasUnlockedCredit(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::l1Head(inner) => { + ::abi_encoded_size(inner) + } + Self::l2BlockNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::l2BlockNumberChallenged(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::l2BlockNumberChallenger(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::l2ChainId(inner) => { + ::abi_encoded_size(inner) + } + Self::l2SequenceNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::maxClockDuration(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::maxGameDepth(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::r#move(inner) => { + ::abi_encoded_size(inner) + } + Self::normalModeCredit(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::refundModeCredit(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::resolutionCheckpoints(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::resolve(inner) => { + ::abi_encoded_size(inner) + } + Self::resolveClaim(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::resolvedAt(inner) => { + ::abi_encoded_size(inner) + } + Self::resolvedSubgames(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::rootClaim(inner) => { + ::abi_encoded_size(inner) + } + Self::splitDepth(inner) => { + ::abi_encoded_size(inner) + } + Self::startingBlockNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::startingOutputRoot(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::startingRootHash(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::status(inner) => { + ::abi_encoded_size(inner) + } + Self::step(inner) => { + ::abi_encoded_size(inner) + } + Self::subgames(inner) => { + ::abi_encoded_size(inner) + } + Self::version(inner) => { + ::abi_encoded_size(inner) + } + Self::vm(inner) => { + ::abi_encoded_size(inner) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::weth(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::__constructor__(inner) => { + <__constructor__Call as alloy_sol_types::SolCall>::abi_encode_raw( + inner, + out, + ) + } + Self::absolutePrestate(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::addLocalData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::anchorStateRegistry(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::attack(inner) => { + ::abi_encode_raw(inner, out) + } + Self::bondDistributionMode(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::challengeRootL2Block(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::claimCredit(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::claimData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::claimDataLen(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::claims(inner) => { + ::abi_encode_raw(inner, out) + } + Self::clockExtension(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::closeGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::createdAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::credit(inner) => { + ::abi_encode_raw(inner, out) + } + Self::defend(inner) => { + ::abi_encode_raw(inner, out) + } + Self::extraData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameCreator(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getChallengerDuration(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getNumToResolve(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getRequiredBond(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::hasUnlockedCredit(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l1Head(inner) => { + ::abi_encode_raw(inner, out) + } + Self::l2BlockNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l2BlockNumberChallenged(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l2BlockNumberChallenger(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l2ChainId(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l2SequenceNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::maxClockDuration(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::maxGameDepth(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::r#move(inner) => { + ::abi_encode_raw(inner, out) + } + Self::normalModeCredit(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::refundModeCredit(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::resolutionCheckpoints(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::resolve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::resolveClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::resolvedAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::resolvedSubgames(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::rootClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::splitDepth(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::startingBlockNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::startingOutputRoot(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::startingRootHash(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::status(inner) => { + ::abi_encode_raw(inner, out) + } + Self::step(inner) => { + ::abi_encode_raw(inner, out) + } + Self::subgames(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::version(inner) => { + ::abi_encode_raw(inner, out) + } + Self::vm(inner) => { + ::abi_encode_raw(inner, out) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::weth(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`IFaultDisputeGame`](self) custom errors. + #[derive(Clone)] + pub enum IFaultDisputeGameErrors { + #[allow(missing_docs)] + AlreadyInitialized(AlreadyInitialized), + #[allow(missing_docs)] + AnchorRootNotFound(AnchorRootNotFound), + #[allow(missing_docs)] + BadExtraData(BadExtraData), + #[allow(missing_docs)] + BlockNumberMatches(BlockNumberMatches), + #[allow(missing_docs)] + BondTransferFailed(BondTransferFailed), + #[allow(missing_docs)] + CannotDefendRootClaim(CannotDefendRootClaim), + #[allow(missing_docs)] + ClaimAboveSplit(ClaimAboveSplit), + #[allow(missing_docs)] + ClaimAlreadyExists(ClaimAlreadyExists), + #[allow(missing_docs)] + ClaimAlreadyResolved(ClaimAlreadyResolved), + #[allow(missing_docs)] + ClockNotExpired(ClockNotExpired), + #[allow(missing_docs)] + ClockTimeExceeded(ClockTimeExceeded), + #[allow(missing_docs)] + ContentLengthMismatch(ContentLengthMismatch), + #[allow(missing_docs)] + DuplicateStep(DuplicateStep), + #[allow(missing_docs)] + EmptyItem(EmptyItem), + #[allow(missing_docs)] + GameDepthExceeded(GameDepthExceeded), + #[allow(missing_docs)] + GameNotFinalized(GameNotFinalized), + #[allow(missing_docs)] + GameNotInProgress(GameNotInProgress), + #[allow(missing_docs)] + GameNotResolved(GameNotResolved), + #[allow(missing_docs)] + GamePaused(GamePaused), + #[allow(missing_docs)] + IncorrectBondAmount(IncorrectBondAmount), + #[allow(missing_docs)] + InvalidBondDistributionMode(InvalidBondDistributionMode), + #[allow(missing_docs)] + InvalidChallengePeriod(InvalidChallengePeriod), + #[allow(missing_docs)] + InvalidClockExtension(InvalidClockExtension), + #[allow(missing_docs)] + InvalidDataRemainder(InvalidDataRemainder), + #[allow(missing_docs)] + InvalidDisputedClaimIndex(InvalidDisputedClaimIndex), + #[allow(missing_docs)] + InvalidHeader(InvalidHeader), + #[allow(missing_docs)] + InvalidHeaderRLP(InvalidHeaderRLP), + #[allow(missing_docs)] + InvalidLocalIdent(InvalidLocalIdent), + #[allow(missing_docs)] + InvalidOutputRootProof(InvalidOutputRootProof), + #[allow(missing_docs)] + InvalidParent(InvalidParent), + #[allow(missing_docs)] + InvalidPrestate(InvalidPrestate), + #[allow(missing_docs)] + InvalidSplitDepth(InvalidSplitDepth), + #[allow(missing_docs)] + L2BlockNumberChallenged(L2BlockNumberChallenged), + #[allow(missing_docs)] + MaxDepthTooLarge(MaxDepthTooLarge), + #[allow(missing_docs)] + NoCreditToClaim(NoCreditToClaim), + #[allow(missing_docs)] + OutOfOrderResolution(OutOfOrderResolution), + #[allow(missing_docs)] + ReservedGameType(ReservedGameType), + #[allow(missing_docs)] + UnexpectedList(UnexpectedList), + #[allow(missing_docs)] + UnexpectedRootClaim(UnexpectedRootClaim), + #[allow(missing_docs)] + UnexpectedString(UnexpectedString), + #[allow(missing_docs)] + ValidStep(ValidStep), + } + impl IFaultDisputeGameErrors { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [7u8, 138u8, 61u8, 244u8], + [13u8, 193u8, 73u8, 240u8], + [14u8, 162u8, 231u8, 82u8], + [23u8, 191u8, 229u8, 247u8], + [31u8, 249u8, 178u8, 228u8], + [48u8, 20u8, 3u8, 50u8], + [51u8, 129u8, 209u8, 20u8], + [55u8, 154u8, 126u8, 217u8], + [57u8, 246u8, 139u8, 56u8], + [72u8, 81u8, 189u8, 155u8], + [75u8, 156u8, 106u8, 190u8], + [86u8, 245u8, 123u8, 43u8], + [90u8, 180u8, 88u8, 251u8], + [92u8, 85u8, 55u8, 184u8], + [95u8, 83u8, 221u8, 152u8], + [102u8, 201u8, 68u8, 133u8], + [103u8, 254u8, 25u8, 80u8], + [105u8, 101u8, 80u8, 255u8], + [106u8, 107u8, 195u8, 178u8], + [119u8, 223u8, 227u8, 50u8], + [128u8, 73u8, 126u8, 59u8], + [131u8, 230u8, 204u8, 107u8], + [134u8, 32u8, 170u8, 25u8], + [141u8, 119u8, 236u8, 172u8], + [144u8, 113u8, 230u8, 175u8], + [152u8, 36u8, 189u8, 171u8], + [154u8, 7u8, 102u8, 70u8], + [156u8, 192u8, 11u8, 91u8], + [164u8, 38u8, 55u8, 188u8], + [179u8, 75u8, 92u8, 34u8], + [180u8, 225u8, 36u8, 51u8], + [184u8, 237u8, 136u8, 48u8], + [186u8, 187u8, 1u8, 221u8], + [193u8, 5u8, 38u8, 10u8], + [216u8, 29u8, 88u8, 59u8], + [230u8, 44u8, 207u8, 57u8], + [241u8, 169u8, 69u8, 129u8], + [242u8, 68u8, 11u8, 83u8], + [244u8, 2u8, 57u8, 219u8], + [251u8, 78u8, 64u8, 221u8], + [255u8, 19u8, 126u8, 101u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(InvalidBondDistributionMode), + ::core::stringify!(AlreadyInitialized), + ::core::stringify!(L2BlockNumberChallenged), + ::core::stringify!(NoCreditToClaim), + ::core::stringify!(UnexpectedList), + ::core::stringify!(InvalidDisputedClaimIndex), + ::core::stringify!(ClockTimeExceeded), + ::core::stringify!(GamePaused), + ::core::stringify!(ReservedGameType), + ::core::stringify!(GameNotFinalized), + ::core::stringify!(UnexpectedString), + ::core::stringify!(GameDepthExceeded), + ::core::stringify!(EmptyItem), + ::core::stringify!(InvalidDataRemainder), + ::core::stringify!(InvalidParent), + ::core::stringify!(ContentLengthMismatch), + ::core::stringify!(GameNotInProgress), + ::core::stringify!(InvalidPrestate), + ::core::stringify!(AnchorRootNotFound), + ::core::stringify!(MaxDepthTooLarge), + ::core::stringify!(ClaimAlreadyExists), + ::core::stringify!(BondTransferFailed), + ::core::stringify!(IncorrectBondAmount), + ::core::stringify!(InvalidClockExtension), + ::core::stringify!(DuplicateStep), + ::core::stringify!(BadExtraData), + ::core::stringify!(OutOfOrderResolution), + ::core::stringify!(InvalidOutputRootProof), + ::core::stringify!(CannotDefendRootClaim), + ::core::stringify!(ClaimAboveSplit), + ::core::stringify!(InvalidChallengePeriod), + ::core::stringify!(BlockNumberMatches), + ::core::stringify!(InvalidHeader), + ::core::stringify!(GameNotResolved), + ::core::stringify!(InvalidHeaderRLP), + ::core::stringify!(InvalidSplitDepth), + ::core::stringify!(ClaimAlreadyResolved), + ::core::stringify!(ClockNotExpired), + ::core::stringify!(UnexpectedRootClaim), + ::core::stringify!(ValidStep), + ::core::stringify!(InvalidLocalIdent), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IFaultDisputeGameErrors { + const NAME: &'static str = "IFaultDisputeGameErrors"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 41usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::AlreadyInitialized(_) => { + ::SELECTOR + } + Self::AnchorRootNotFound(_) => { + ::SELECTOR + } + Self::BadExtraData(_) => { + ::SELECTOR + } + Self::BlockNumberMatches(_) => { + ::SELECTOR + } + Self::BondTransferFailed(_) => { + ::SELECTOR + } + Self::CannotDefendRootClaim(_) => { + ::SELECTOR + } + Self::ClaimAboveSplit(_) => { + ::SELECTOR + } + Self::ClaimAlreadyExists(_) => { + ::SELECTOR + } + Self::ClaimAlreadyResolved(_) => { + ::SELECTOR + } + Self::ClockNotExpired(_) => { + ::SELECTOR + } + Self::ClockTimeExceeded(_) => { + ::SELECTOR + } + Self::ContentLengthMismatch(_) => { + ::SELECTOR + } + Self::DuplicateStep(_) => { + ::SELECTOR + } + Self::EmptyItem(_) => ::SELECTOR, + Self::GameDepthExceeded(_) => { + ::SELECTOR + } + Self::GameNotFinalized(_) => { + ::SELECTOR + } + Self::GameNotInProgress(_) => { + ::SELECTOR + } + Self::GameNotResolved(_) => { + ::SELECTOR + } + Self::GamePaused(_) => { + ::SELECTOR + } + Self::IncorrectBondAmount(_) => { + ::SELECTOR + } + Self::InvalidBondDistributionMode(_) => { + ::SELECTOR + } + Self::InvalidChallengePeriod(_) => { + ::SELECTOR + } + Self::InvalidClockExtension(_) => { + ::SELECTOR + } + Self::InvalidDataRemainder(_) => { + ::SELECTOR + } + Self::InvalidDisputedClaimIndex(_) => { + ::SELECTOR + } + Self::InvalidHeader(_) => { + ::SELECTOR + } + Self::InvalidHeaderRLP(_) => { + ::SELECTOR + } + Self::InvalidLocalIdent(_) => { + ::SELECTOR + } + Self::InvalidOutputRootProof(_) => { + ::SELECTOR + } + Self::InvalidParent(_) => { + ::SELECTOR + } + Self::InvalidPrestate(_) => { + ::SELECTOR + } + Self::InvalidSplitDepth(_) => { + ::SELECTOR + } + Self::L2BlockNumberChallenged(_) => { + ::SELECTOR + } + Self::MaxDepthTooLarge(_) => { + ::SELECTOR + } + Self::NoCreditToClaim(_) => { + ::SELECTOR + } + Self::OutOfOrderResolution(_) => { + ::SELECTOR + } + Self::ReservedGameType(_) => { + ::SELECTOR + } + Self::UnexpectedList(_) => { + ::SELECTOR + } + Self::UnexpectedRootClaim(_) => { + ::SELECTOR + } + Self::UnexpectedString(_) => { + ::SELECTOR + } + Self::ValidStep(_) => ::SELECTOR, + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn InvalidBondDistributionMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidBondDistributionMode) + } + InvalidBondDistributionMode + }, + { + fn AlreadyInitialized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::AlreadyInitialized) + } + AlreadyInitialized + }, + { + fn L2BlockNumberChallenged( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::L2BlockNumberChallenged) + } + L2BlockNumberChallenged + }, + { + fn NoCreditToClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::NoCreditToClaim) + } + NoCreditToClaim + }, + { + fn UnexpectedList( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::UnexpectedList) + } + UnexpectedList + }, + { + fn InvalidDisputedClaimIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidDisputedClaimIndex) + } + InvalidDisputedClaimIndex + }, + { + fn ClockTimeExceeded( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::ClockTimeExceeded) + } + ClockTimeExceeded + }, + { + fn GamePaused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameErrors::GamePaused) + } + GamePaused + }, + { + fn ReservedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::ReservedGameType) + } + ReservedGameType + }, + { + fn GameNotFinalized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::GameNotFinalized) + } + GameNotFinalized + }, + { + fn UnexpectedString( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::UnexpectedString) + } + UnexpectedString + }, + { + fn GameDepthExceeded( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::GameDepthExceeded) + } + GameDepthExceeded + }, + { + fn EmptyItem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameErrors::EmptyItem) + } + EmptyItem + }, + { + fn InvalidDataRemainder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidDataRemainder) + } + InvalidDataRemainder + }, + { + fn InvalidParent( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidParent) + } + InvalidParent + }, + { + fn ContentLengthMismatch( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::ContentLengthMismatch) + } + ContentLengthMismatch + }, + { + fn GameNotInProgress( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::GameNotInProgress) + } + GameNotInProgress + }, + { + fn InvalidPrestate( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidPrestate) + } + InvalidPrestate + }, + { + fn AnchorRootNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::AnchorRootNotFound) + } + AnchorRootNotFound + }, + { + fn MaxDepthTooLarge( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::MaxDepthTooLarge) + } + MaxDepthTooLarge + }, + { + fn ClaimAlreadyExists( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::ClaimAlreadyExists) + } + ClaimAlreadyExists + }, + { + fn BondTransferFailed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::BondTransferFailed) + } + BondTransferFailed + }, + { + fn IncorrectBondAmount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::IncorrectBondAmount) + } + IncorrectBondAmount + }, + { + fn InvalidClockExtension( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidClockExtension) + } + InvalidClockExtension + }, + { + fn DuplicateStep( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::DuplicateStep) + } + DuplicateStep + }, + { + fn BadExtraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameErrors::BadExtraData) + } + BadExtraData + }, + { + fn OutOfOrderResolution( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::OutOfOrderResolution) + } + OutOfOrderResolution + }, + { + fn InvalidOutputRootProof( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidOutputRootProof) + } + InvalidOutputRootProof + }, + { + fn CannotDefendRootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::CannotDefendRootClaim) + } + CannotDefendRootClaim + }, + { + fn ClaimAboveSplit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::ClaimAboveSplit) + } + ClaimAboveSplit + }, + { + fn InvalidChallengePeriod( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidChallengePeriod) + } + InvalidChallengePeriod + }, + { + fn BlockNumberMatches( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::BlockNumberMatches) + } + BlockNumberMatches + }, + { + fn InvalidHeader( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidHeader) + } + InvalidHeader + }, + { + fn GameNotResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::GameNotResolved) + } + GameNotResolved + }, + { + fn InvalidHeaderRLP( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidHeaderRLP) + } + InvalidHeaderRLP + }, + { + fn InvalidSplitDepth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidSplitDepth) + } + InvalidSplitDepth + }, + { + fn ClaimAlreadyResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::ClaimAlreadyResolved) + } + ClaimAlreadyResolved + }, + { + fn ClockNotExpired( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::ClockNotExpired) + } + ClockNotExpired + }, + { + fn UnexpectedRootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::UnexpectedRootClaim) + } + UnexpectedRootClaim + }, + { + fn ValidStep( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IFaultDisputeGameErrors::ValidStep) + } + ValidStep + }, + { + fn InvalidLocalIdent( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IFaultDisputeGameErrors::InvalidLocalIdent) + } + InvalidLocalIdent + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn InvalidBondDistributionMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidBondDistributionMode) + } + InvalidBondDistributionMode + }, + { + fn AlreadyInitialized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::AlreadyInitialized) + } + AlreadyInitialized + }, + { + fn L2BlockNumberChallenged( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::L2BlockNumberChallenged) + } + L2BlockNumberChallenged + }, + { + fn NoCreditToClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::NoCreditToClaim) + } + NoCreditToClaim + }, + { + fn UnexpectedList( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::UnexpectedList) + } + UnexpectedList + }, + { + fn InvalidDisputedClaimIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidDisputedClaimIndex) + } + InvalidDisputedClaimIndex + }, + { + fn ClockTimeExceeded( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::ClockTimeExceeded) + } + ClockTimeExceeded + }, + { + fn GamePaused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::GamePaused) + } + GamePaused + }, + { + fn ReservedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::ReservedGameType) + } + ReservedGameType + }, + { + fn GameNotFinalized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::GameNotFinalized) + } + GameNotFinalized + }, + { + fn UnexpectedString( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::UnexpectedString) + } + UnexpectedString + }, + { + fn GameDepthExceeded( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::GameDepthExceeded) + } + GameDepthExceeded + }, + { + fn EmptyItem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::EmptyItem) + } + EmptyItem + }, + { + fn InvalidDataRemainder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidDataRemainder) + } + InvalidDataRemainder + }, + { + fn InvalidParent( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidParent) + } + InvalidParent + }, + { + fn ContentLengthMismatch( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::ContentLengthMismatch) + } + ContentLengthMismatch + }, + { + fn GameNotInProgress( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::GameNotInProgress) + } + GameNotInProgress + }, + { + fn InvalidPrestate( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidPrestate) + } + InvalidPrestate + }, + { + fn AnchorRootNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::AnchorRootNotFound) + } + AnchorRootNotFound + }, + { + fn MaxDepthTooLarge( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::MaxDepthTooLarge) + } + MaxDepthTooLarge + }, + { + fn ClaimAlreadyExists( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::ClaimAlreadyExists) + } + ClaimAlreadyExists + }, + { + fn BondTransferFailed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::BondTransferFailed) + } + BondTransferFailed + }, + { + fn IncorrectBondAmount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::IncorrectBondAmount) + } + IncorrectBondAmount + }, + { + fn InvalidClockExtension( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidClockExtension) + } + InvalidClockExtension + }, + { + fn DuplicateStep( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::DuplicateStep) + } + DuplicateStep + }, + { + fn BadExtraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::BadExtraData) + } + BadExtraData + }, + { + fn OutOfOrderResolution( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::OutOfOrderResolution) + } + OutOfOrderResolution + }, + { + fn InvalidOutputRootProof( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidOutputRootProof) + } + InvalidOutputRootProof + }, + { + fn CannotDefendRootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::CannotDefendRootClaim) + } + CannotDefendRootClaim + }, + { + fn ClaimAboveSplit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::ClaimAboveSplit) + } + ClaimAboveSplit + }, + { + fn InvalidChallengePeriod( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidChallengePeriod) + } + InvalidChallengePeriod + }, + { + fn BlockNumberMatches( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::BlockNumberMatches) + } + BlockNumberMatches + }, + { + fn InvalidHeader( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidHeader) + } + InvalidHeader + }, + { + fn GameNotResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::GameNotResolved) + } + GameNotResolved + }, + { + fn InvalidHeaderRLP( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidHeaderRLP) + } + InvalidHeaderRLP + }, + { + fn InvalidSplitDepth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidSplitDepth) + } + InvalidSplitDepth + }, + { + fn ClaimAlreadyResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::ClaimAlreadyResolved) + } + ClaimAlreadyResolved + }, + { + fn ClockNotExpired( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::ClockNotExpired) + } + ClockNotExpired + }, + { + fn UnexpectedRootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::UnexpectedRootClaim) + } + UnexpectedRootClaim + }, + { + fn ValidStep( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::ValidStep) + } + ValidStep + }, + { + fn InvalidLocalIdent( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IFaultDisputeGameErrors::InvalidLocalIdent) + } + InvalidLocalIdent + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::AlreadyInitialized(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::AnchorRootNotFound(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::BadExtraData(inner) => { + ::abi_encoded_size(inner) + } + Self::BlockNumberMatches(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::BondTransferFailed(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::CannotDefendRootClaim(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ClaimAboveSplit(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ClaimAlreadyExists(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ClaimAlreadyResolved(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ClockNotExpired(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ClockTimeExceeded(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ContentLengthMismatch(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::DuplicateStep(inner) => { + ::abi_encoded_size(inner) + } + Self::EmptyItem(inner) => { + ::abi_encoded_size(inner) + } + Self::GameDepthExceeded(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::GameNotFinalized(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::GameNotInProgress(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::GameNotResolved(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::GamePaused(inner) => { + ::abi_encoded_size(inner) + } + Self::IncorrectBondAmount(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidBondDistributionMode(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidChallengePeriod(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidClockExtension(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidDataRemainder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidDisputedClaimIndex(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidHeader(inner) => { + ::abi_encoded_size(inner) + } + Self::InvalidHeaderRLP(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidLocalIdent(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidOutputRootProof(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidParent(inner) => { + ::abi_encoded_size(inner) + } + Self::InvalidPrestate(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidSplitDepth(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::L2BlockNumberChallenged(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::MaxDepthTooLarge(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::NoCreditToClaim(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::OutOfOrderResolution(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ReservedGameType(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::UnexpectedList(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::UnexpectedRootClaim(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::UnexpectedString(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ValidStep(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::AlreadyInitialized(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::AnchorRootNotFound(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::BadExtraData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::BlockNumberMatches(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::BondTransferFailed(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::CannotDefendRootClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ClaimAboveSplit(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ClaimAlreadyExists(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ClaimAlreadyResolved(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ClockNotExpired(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ClockTimeExceeded(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ContentLengthMismatch(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::DuplicateStep(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::EmptyItem(inner) => { + ::abi_encode_raw(inner, out) + } + Self::GameDepthExceeded(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::GameNotFinalized(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::GameNotInProgress(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::GameNotResolved(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::GamePaused(inner) => { + ::abi_encode_raw(inner, out) + } + Self::IncorrectBondAmount(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidBondDistributionMode(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidChallengePeriod(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidClockExtension(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidDataRemainder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidDisputedClaimIndex(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidHeader(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidHeaderRLP(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidLocalIdent(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidOutputRootProof(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidParent(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidPrestate(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidSplitDepth(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::L2BlockNumberChallenged(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::MaxDepthTooLarge(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::NoCreditToClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::OutOfOrderResolution(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ReservedGameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::UnexpectedList(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::UnexpectedRootClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::UnexpectedString(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ValidStep(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`IFaultDisputeGame`](self) events. + #[derive(Clone)] + pub enum IFaultDisputeGameEvents { + #[allow(missing_docs)] + GameClosed(GameClosed), + #[allow(missing_docs)] + Move(Move), + #[allow(missing_docs)] + Resolved(Resolved), + } + impl IFaultDisputeGameEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ], + [ + 153u8, 8u8, 234u8, 172u8, 6u8, 69u8, 223u8, 157u8, 7u8, 4u8, 208u8, + 106u8, 220u8, 158u8, 7u8, 51u8, 124u8, 149u8, 29u8, 226u8, 240u8, 107u8, + 95u8, 40u8, 54u8, 21u8, 29u8, 72u8, 213u8, 228u8, 114u8, 47u8, + ], + [ + 155u8, 50u8, 69u8, 116u8, 14u8, 195u8, 177u8, 85u8, 9u8, 138u8, 85u8, + 190u8, 132u8, 149u8, 122u8, 77u8, 161u8, 62u8, 175u8, 127u8, 20u8, 168u8, + 188u8, 111u8, 83u8, 18u8, 108u8, 11u8, 147u8, 80u8, 242u8, 190u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(Resolved), + ::core::stringify!(GameClosed), + ::core::stringify!(Move), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IFaultDisputeGameEvents { + const NAME: &'static str = "IFaultDisputeGameEvents"; + const COUNT: usize = 3usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::GameClosed) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Move) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Resolved) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for IFaultDisputeGameEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::GameClosed(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Move(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::GameClosed(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Move(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IFaultDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`IFaultDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> IFaultDisputeGameInstance { + IFaultDisputeGameInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IFaultDisputeGameInstance::::deploy(__provider) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(__provider: P) -> alloy_contract::RawCallBuilder { + IFaultDisputeGameInstance::::deploy_builder(__provider) + } + /**A [`IFaultDisputeGame`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IFaultDisputeGame`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct IFaultDisputeGameInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IFaultDisputeGameInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IFaultDisputeGameInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IFaultDisputeGameInstance { + /**Creates a new wrapper around an on-chain [`IFaultDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`IFaultDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + ::core::clone::Clone::clone(&BYTECODE), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl IFaultDisputeGameInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IFaultDisputeGameInstance { + IFaultDisputeGameInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IFaultDisputeGameInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`__constructor__`] function. + pub fn __constructor__( + &self, + _params: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, __constructor__Call, N> { + self.call_builder(&__constructor__Call { _params }) + } + ///Creates a new call builder for the [`absolutePrestate`] function. + pub fn absolutePrestate( + &self, + ) -> alloy_contract::SolCallBuilder<&P, absolutePrestateCall, N> { + self.call_builder(&absolutePrestateCall) + } + ///Creates a new call builder for the [`addLocalData`] function. + pub fn addLocalData( + &self, + _ident: alloy::sol_types::private::primitives::aliases::U256, + _execLeafIdx: alloy::sol_types::private::primitives::aliases::U256, + _partOffset: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, addLocalDataCall, N> { + self.call_builder( + &addLocalDataCall { + _ident, + _execLeafIdx, + _partOffset, + }, + ) + } + ///Creates a new call builder for the [`anchorStateRegistry`] function. + pub fn anchorStateRegistry( + &self, + ) -> alloy_contract::SolCallBuilder<&P, anchorStateRegistryCall, N> { + self.call_builder(&anchorStateRegistryCall) + } + ///Creates a new call builder for the [`attack`] function. + pub fn attack( + &self, + _disputed: ::RustType, + _parentIndex: alloy::sol_types::private::primitives::aliases::U256, + _claim: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, attackCall, N> { + self.call_builder( + &attackCall { + _disputed, + _parentIndex, + _claim, + }, + ) + } + ///Creates a new call builder for the [`bondDistributionMode`] function. + pub fn bondDistributionMode( + &self, + ) -> alloy_contract::SolCallBuilder<&P, bondDistributionModeCall, N> { + self.call_builder(&bondDistributionModeCall) + } + ///Creates a new call builder for the [`challengeRootL2Block`] function. + pub fn challengeRootL2Block( + &self, + _outputRootProof: ::RustType, + _headerRLP: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, challengeRootL2BlockCall, N> { + self.call_builder( + &challengeRootL2BlockCall { + _outputRootProof, + _headerRLP, + }, + ) + } + ///Creates a new call builder for the [`claimCredit`] function. + pub fn claimCredit( + &self, + _recipient: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, claimCreditCall, N> { + self.call_builder(&claimCreditCall { _recipient }) + } + ///Creates a new call builder for the [`claimData`] function. + pub fn claimData( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, claimDataCall, N> { + self.call_builder(&claimDataCall(_0)) + } + ///Creates a new call builder for the [`claimDataLen`] function. + pub fn claimDataLen( + &self, + ) -> alloy_contract::SolCallBuilder<&P, claimDataLenCall, N> { + self.call_builder(&claimDataLenCall) + } + ///Creates a new call builder for the [`claims`] function. + pub fn claims( + &self, + _0: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, claimsCall, N> { + self.call_builder(&claimsCall(_0)) + } + ///Creates a new call builder for the [`clockExtension`] function. + pub fn clockExtension( + &self, + ) -> alloy_contract::SolCallBuilder<&P, clockExtensionCall, N> { + self.call_builder(&clockExtensionCall) + } + ///Creates a new call builder for the [`closeGame`] function. + pub fn closeGame(&self) -> alloy_contract::SolCallBuilder<&P, closeGameCall, N> { + self.call_builder(&closeGameCall) + } + ///Creates a new call builder for the [`createdAt`] function. + pub fn createdAt(&self) -> alloy_contract::SolCallBuilder<&P, createdAtCall, N> { + self.call_builder(&createdAtCall) + } + ///Creates a new call builder for the [`credit`] function. + pub fn credit( + &self, + _recipient: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, creditCall, N> { + self.call_builder(&creditCall { _recipient }) + } + ///Creates a new call builder for the [`defend`] function. + pub fn defend( + &self, + _disputed: ::RustType, + _parentIndex: alloy::sol_types::private::primitives::aliases::U256, + _claim: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, defendCall, N> { + self.call_builder( + &defendCall { + _disputed, + _parentIndex, + _claim, + }, + ) + } + ///Creates a new call builder for the [`extraData`] function. + pub fn extraData(&self) -> alloy_contract::SolCallBuilder<&P, extraDataCall, N> { + self.call_builder(&extraDataCall) + } + ///Creates a new call builder for the [`gameCreator`] function. + pub fn gameCreator( + &self, + ) -> alloy_contract::SolCallBuilder<&P, gameCreatorCall, N> { + self.call_builder(&gameCreatorCall) + } + ///Creates a new call builder for the [`gameData`] function. + pub fn gameData(&self) -> alloy_contract::SolCallBuilder<&P, gameDataCall, N> { + self.call_builder(&gameDataCall) + } + ///Creates a new call builder for the [`gameType`] function. + pub fn gameType(&self) -> alloy_contract::SolCallBuilder<&P, gameTypeCall, N> { + self.call_builder(&gameTypeCall) + } + ///Creates a new call builder for the [`getChallengerDuration`] function. + pub fn getChallengerDuration( + &self, + _claimIndex: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, getChallengerDurationCall, N> { + self.call_builder( + &getChallengerDurationCall { + _claimIndex, + }, + ) + } + ///Creates a new call builder for the [`getNumToResolve`] function. + pub fn getNumToResolve( + &self, + _claimIndex: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, getNumToResolveCall, N> { + self.call_builder(&getNumToResolveCall { _claimIndex }) + } + ///Creates a new call builder for the [`getRequiredBond`] function. + pub fn getRequiredBond( + &self, + _position: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, getRequiredBondCall, N> { + self.call_builder(&getRequiredBondCall { _position }) + } + ///Creates a new call builder for the [`hasUnlockedCredit`] function. + pub fn hasUnlockedCredit( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, hasUnlockedCreditCall, N> { + self.call_builder(&hasUnlockedCreditCall(_0)) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder(&initializeCall) + } + ///Creates a new call builder for the [`l1Head`] function. + pub fn l1Head(&self) -> alloy_contract::SolCallBuilder<&P, l1HeadCall, N> { + self.call_builder(&l1HeadCall) + } + ///Creates a new call builder for the [`l2BlockNumber`] function. + pub fn l2BlockNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2BlockNumberCall, N> { + self.call_builder(&l2BlockNumberCall) + } + ///Creates a new call builder for the [`l2BlockNumberChallenged`] function. + pub fn l2BlockNumberChallenged( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2BlockNumberChallengedCall, N> { + self.call_builder(&l2BlockNumberChallengedCall) + } + ///Creates a new call builder for the [`l2BlockNumberChallenger`] function. + pub fn l2BlockNumberChallenger( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2BlockNumberChallengerCall, N> { + self.call_builder(&l2BlockNumberChallengerCall) + } + ///Creates a new call builder for the [`l2ChainId`] function. + pub fn l2ChainId(&self) -> alloy_contract::SolCallBuilder<&P, l2ChainIdCall, N> { + self.call_builder(&l2ChainIdCall) + } + ///Creates a new call builder for the [`l2SequenceNumber`] function. + pub fn l2SequenceNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2SequenceNumberCall, N> { + self.call_builder(&l2SequenceNumberCall) + } + ///Creates a new call builder for the [`maxClockDuration`] function. + pub fn maxClockDuration( + &self, + ) -> alloy_contract::SolCallBuilder<&P, maxClockDurationCall, N> { + self.call_builder(&maxClockDurationCall) + } + ///Creates a new call builder for the [`maxGameDepth`] function. + pub fn maxGameDepth( + &self, + ) -> alloy_contract::SolCallBuilder<&P, maxGameDepthCall, N> { + self.call_builder(&maxGameDepthCall) + } + ///Creates a new call builder for the [`r#move`] function. + pub fn r#move( + &self, + _disputed: ::RustType, + _challengeIndex: alloy::sol_types::private::primitives::aliases::U256, + _claim: ::RustType, + _isAttack: bool, + ) -> alloy_contract::SolCallBuilder<&P, moveCall, N> { + self.call_builder( + &moveCall { + _disputed, + _challengeIndex, + _claim, + _isAttack, + }, + ) + } + ///Creates a new call builder for the [`normalModeCredit`] function. + pub fn normalModeCredit( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, normalModeCreditCall, N> { + self.call_builder(&normalModeCreditCall(_0)) + } + ///Creates a new call builder for the [`refundModeCredit`] function. + pub fn refundModeCredit( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, refundModeCreditCall, N> { + self.call_builder(&refundModeCreditCall(_0)) + } + ///Creates a new call builder for the [`resolutionCheckpoints`] function. + pub fn resolutionCheckpoints( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, resolutionCheckpointsCall, N> { + self.call_builder(&resolutionCheckpointsCall(_0)) + } + ///Creates a new call builder for the [`resolve`] function. + pub fn resolve(&self) -> alloy_contract::SolCallBuilder<&P, resolveCall, N> { + self.call_builder(&resolveCall) + } + ///Creates a new call builder for the [`resolveClaim`] function. + pub fn resolveClaim( + &self, + _claimIndex: alloy::sol_types::private::primitives::aliases::U256, + _numToResolve: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, resolveClaimCall, N> { + self.call_builder( + &resolveClaimCall { + _claimIndex, + _numToResolve, + }, + ) + } + ///Creates a new call builder for the [`resolvedAt`] function. + pub fn resolvedAt( + &self, + ) -> alloy_contract::SolCallBuilder<&P, resolvedAtCall, N> { + self.call_builder(&resolvedAtCall) + } + ///Creates a new call builder for the [`resolvedSubgames`] function. + pub fn resolvedSubgames( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, resolvedSubgamesCall, N> { + self.call_builder(&resolvedSubgamesCall(_0)) + } + ///Creates a new call builder for the [`rootClaim`] function. + pub fn rootClaim(&self) -> alloy_contract::SolCallBuilder<&P, rootClaimCall, N> { + self.call_builder(&rootClaimCall) + } + ///Creates a new call builder for the [`splitDepth`] function. + pub fn splitDepth( + &self, + ) -> alloy_contract::SolCallBuilder<&P, splitDepthCall, N> { + self.call_builder(&splitDepthCall) + } + ///Creates a new call builder for the [`startingBlockNumber`] function. + pub fn startingBlockNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, startingBlockNumberCall, N> { + self.call_builder(&startingBlockNumberCall) + } + ///Creates a new call builder for the [`startingOutputRoot`] function. + pub fn startingOutputRoot( + &self, + ) -> alloy_contract::SolCallBuilder<&P, startingOutputRootCall, N> { + self.call_builder(&startingOutputRootCall) + } + ///Creates a new call builder for the [`startingRootHash`] function. + pub fn startingRootHash( + &self, + ) -> alloy_contract::SolCallBuilder<&P, startingRootHashCall, N> { + self.call_builder(&startingRootHashCall) + } + ///Creates a new call builder for the [`status`] function. + pub fn status(&self) -> alloy_contract::SolCallBuilder<&P, statusCall, N> { + self.call_builder(&statusCall) + } + ///Creates a new call builder for the [`step`] function. + pub fn step( + &self, + _claimIndex: alloy::sol_types::private::primitives::aliases::U256, + _isAttack: bool, + _stateData: alloy::sol_types::private::Bytes, + _proof: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, stepCall, N> { + self.call_builder( + &stepCall { + _claimIndex, + _isAttack, + _stateData, + _proof, + }, + ) + } + ///Creates a new call builder for the [`subgames`] function. + pub fn subgames( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + _1: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, subgamesCall, N> { + self.call_builder(&subgamesCall { _0, _1 }) + } + ///Creates a new call builder for the [`version`] function. + pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> { + self.call_builder(&versionCall) + } + ///Creates a new call builder for the [`vm`] function. + pub fn vm(&self) -> alloy_contract::SolCallBuilder<&P, vmCall, N> { + self.call_builder(&vmCall) + } + ///Creates a new call builder for the [`wasRespectedGameTypeWhenCreated`] function. + pub fn wasRespectedGameTypeWhenCreated( + &self, + ) -> alloy_contract::SolCallBuilder<&P, wasRespectedGameTypeWhenCreatedCall, N> { + self.call_builder(&wasRespectedGameTypeWhenCreatedCall) + } + ///Creates a new call builder for the [`weth`] function. + pub fn weth(&self) -> alloy_contract::SolCallBuilder<&P, wethCall, N> { + self.call_builder(&wethCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IFaultDisputeGameInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`GameClosed`] event. + pub fn GameClosed_filter(&self) -> alloy_contract::Event<&P, GameClosed, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Move`] event. + pub fn Move_filter(&self) -> alloy_contract::Event<&P, Move, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Resolved`] event. + pub fn Resolved_filter(&self) -> alloy_contract::Event<&P, Resolved, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/mock_optimism_portal2.rs b/bindings/src/codegen/mock_optimism_portal2.rs new file mode 100644 index 000000000..b9f53f9e7 --- /dev/null +++ b/bindings/src/codegen/mock_optimism_portal2.rs @@ -0,0 +1,1871 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface MockOptimismPortal2 { + type GameType is uint32; + + constructor(GameType _initialRespectedGameType, uint256 _disputeGameFinalityDelaySeconds); + + function blacklistDisputeGame(address _disputeGame) external; + function disputeGameBlacklist(address) external view returns (bool); + function disputeGameFinalityDelaySeconds() external view returns (uint256); + function respectedGameType() external view returns (GameType); + function respectedGameTypeUpdatedAt() external view returns (uint64); + function setRespectedGameType(GameType _gameType) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_initialRespectedGameType", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "_disputeGameFinalityDelaySeconds", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "blacklistDisputeGame", + "inputs": [ + { + "name": "_disputeGame", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "disputeGameBlacklist", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "disputeGameFinalityDelaySeconds", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "respectedGameType", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "respectedGameTypeUpdatedAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "uint64" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setRespectedGameType", + "inputs": [ + { + "name": "_gameType", + "type": "uint32", + "internalType": "GameType" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod MockOptimismPortal2 { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\xA0`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x05\xE48\x03\x80a\x05\xE4\x839\x81\x81\x01`@R\x81\x01\x90a\x002\x91\x90a\x01\x02V[\x81`\x01`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPB`\x01`\x04a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x80`\x80\x81\x81RPPPPa\x01BV[`\0\x80\xFD[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a\0\xA9\x81a\0\x90V[\x81\x14a\0\xB4W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\0\xC6\x81a\0\xA0V[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\0\xDF\x81a\0\xCCV[\x81\x14a\0\xEAW`\0\x80\xFD[PV[`\0\x81Q\x90Pa\0\xFC\x81a\0\xD6V[\x92\x91PPV[`\0\x80`@\x83\x85\x03\x12\x15a\x01\x19Wa\x01\x18a\0\x8BV[[`\0a\x01'\x85\x82\x86\x01a\0\xB7V[\x92PP` a\x018\x85\x82\x86\x01a\0\xEDV[\x91PP\x92P\x92\x90PV[`\x80Qa\x04\x87a\x01]`\09`\0a\x02$\x01Ra\x04\x87`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0bW`\x005`\xE0\x1C\x80c<\x9F9|\x14a\0gW\x80cE\x88M2\x14a\0\x85W\x80cO\xD0CL\x14a\0\xB5W\x80c}k\xE8\xDC\x14a\0\xD3W\x80c\x7F\xC4\x85\x04\x14a\0\xEFW\x80c\x95+'\x97\x14a\x01\x0BW[`\0\x80\xFD[a\0oa\x01)V[`@Qa\0|\x91\x90a\x02\x93V[`@Q\x80\x91\x03\x90\xF3[a\0\x9F`\x04\x806\x03\x81\x01\x90a\0\x9A\x91\x90a\x03#V[a\x01?V[`@Qa\0\xAC\x91\x90a\x03kV[`@Q\x80\x91\x03\x90\xF3[a\0\xBDa\x01_V[`@Qa\0\xCA\x91\x90a\x03\xA9V[`@Q\x80\x91\x03\x90\xF3[a\0\xED`\x04\x806\x03\x81\x01\x90a\0\xE8\x91\x90a\x03#V[a\x01yV[\0[a\x01\t`\x04\x806\x03\x81\x01\x90a\x01\x04\x91\x90a\x03\xF0V[a\x01\xD3V[\0[a\x01\x13a\x02 V[`@Qa\x01 \x91\x90a\x046V[`@Q\x80\x91\x03\x90\xF3[`\x01`\0\x90T\x90a\x01\0\n\x90\x04c\xFF\xFF\xFF\xFF\x16\x81V[`\0` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\x01`\x04\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x01`\0\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPPV[\x80`\x01`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPB`\x01`\x04a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0a\x02}a\x02xa\x02s\x84a\x02HV[a\x02XV[a\x02HV[\x90P\x91\x90PV[a\x02\x8D\x81a\x02bV[\x82RPPV[`\0` \x82\x01\x90Pa\x02\xA8`\0\x83\x01\x84a\x02\x84V[\x92\x91PPV[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x02\xDE\x82a\x02\xB3V[\x90P\x91\x90PV[`\0a\x02\xF0\x82a\x02\xD3V[\x90P\x91\x90PV[a\x03\0\x81a\x02\xE5V[\x81\x14a\x03\x0BW`\0\x80\xFD[PV[`\0\x815\x90Pa\x03\x1D\x81a\x02\xF7V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x039Wa\x038a\x02\xAEV[[`\0a\x03G\x84\x82\x85\x01a\x03\x0EV[\x91PP\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\x03e\x81a\x03PV[\x82RPPV[`\0` \x82\x01\x90Pa\x03\x80`\0\x83\x01\x84a\x03\\V[\x92\x91PPV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a\x03\xA3\x81a\x03\x86V[\x82RPPV[`\0` \x82\x01\x90Pa\x03\xBE`\0\x83\x01\x84a\x03\x9AV[\x92\x91PPV[a\x03\xCD\x81a\x02HV[\x81\x14a\x03\xD8W`\0\x80\xFD[PV[`\0\x815\x90Pa\x03\xEA\x81a\x03\xC4V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x04\x06Wa\x04\x05a\x02\xAEV[[`\0a\x04\x14\x84\x82\x85\x01a\x03\xDBV[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\x040\x81a\x04\x1DV[\x82RPPV[`\0` \x82\x01\x90Pa\x04K`\0\x83\x01\x84a\x04'V[\x92\x91PPV\xFE\xA2dipfsX\"\x12 3\xD7\xA3S\xC2\x89O\x1E\xA6\xF5ssQl6\x93\x98)sinL\xC1\xFC\x068\x97#\x19O\xE51dsolcC\0\x08\x0F\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0bW`\x005`\xE0\x1C\x80c<\x9F9|\x14a\0gW\x80cE\x88M2\x14a\0\x85W\x80cO\xD0CL\x14a\0\xB5W\x80c}k\xE8\xDC\x14a\0\xD3W\x80c\x7F\xC4\x85\x04\x14a\0\xEFW\x80c\x95+'\x97\x14a\x01\x0BW[`\0\x80\xFD[a\0oa\x01)V[`@Qa\0|\x91\x90a\x02\x93V[`@Q\x80\x91\x03\x90\xF3[a\0\x9F`\x04\x806\x03\x81\x01\x90a\0\x9A\x91\x90a\x03#V[a\x01?V[`@Qa\0\xAC\x91\x90a\x03kV[`@Q\x80\x91\x03\x90\xF3[a\0\xBDa\x01_V[`@Qa\0\xCA\x91\x90a\x03\xA9V[`@Q\x80\x91\x03\x90\xF3[a\0\xED`\x04\x806\x03\x81\x01\x90a\0\xE8\x91\x90a\x03#V[a\x01yV[\0[a\x01\t`\x04\x806\x03\x81\x01\x90a\x01\x04\x91\x90a\x03\xF0V[a\x01\xD3V[\0[a\x01\x13a\x02 V[`@Qa\x01 \x91\x90a\x046V[`@Q\x80\x91\x03\x90\xF3[`\x01`\0\x90T\x90a\x01\0\n\x90\x04c\xFF\xFF\xFF\xFF\x16\x81V[`\0` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\x01`\x04\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x01`\0\x80\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPPV[\x80`\x01`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPB`\x01`\x04a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0a\x02}a\x02xa\x02s\x84a\x02HV[a\x02XV[a\x02HV[\x90P\x91\x90PV[a\x02\x8D\x81a\x02bV[\x82RPPV[`\0` \x82\x01\x90Pa\x02\xA8`\0\x83\x01\x84a\x02\x84V[\x92\x91PPV[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x02\xDE\x82a\x02\xB3V[\x90P\x91\x90PV[`\0a\x02\xF0\x82a\x02\xD3V[\x90P\x91\x90PV[a\x03\0\x81a\x02\xE5V[\x81\x14a\x03\x0BW`\0\x80\xFD[PV[`\0\x815\x90Pa\x03\x1D\x81a\x02\xF7V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x039Wa\x038a\x02\xAEV[[`\0a\x03G\x84\x82\x85\x01a\x03\x0EV[\x91PP\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\x03e\x81a\x03PV[\x82RPPV[`\0` \x82\x01\x90Pa\x03\x80`\0\x83\x01\x84a\x03\\V[\x92\x91PPV[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a\x03\xA3\x81a\x03\x86V[\x82RPPV[`\0` \x82\x01\x90Pa\x03\xBE`\0\x83\x01\x84a\x03\x9AV[\x92\x91PPV[a\x03\xCD\x81a\x02HV[\x81\x14a\x03\xD8W`\0\x80\xFD[PV[`\0\x815\x90Pa\x03\xEA\x81a\x03\xC4V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x04\x06Wa\x04\x05a\x02\xAEV[[`\0a\x04\x14\x84\x82\x85\x01a\x03\xDBV[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\x040\x81a\x04\x1DV[\x82RPPV[`\0` \x82\x01\x90Pa\x04K`\0\x83\x01\x84a\x04'V[\x92\x91PPV\xFE\xA2dipfsX\"\x12 3\xD7\xA3S\xC2\x89O\x1E\xA6\xF5ssQl6\x93\x98)sinL\xC1\xFC\x068\x97#\x19O\xE51dsolcC\0\x08\x0F\x003", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**Constructor`. +```solidity +constructor(GameType _initialRespectedGameType, uint256 _disputeGameFinalityDelaySeconds); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _initialRespectedGameType: ::RustType, + #[allow(missing_docs)] + pub _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + ( + value._initialRespectedGameType, + value._disputeGameFinalityDelaySeconds, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _initialRespectedGameType: tuple.0, + _disputeGameFinalityDelaySeconds: tuple.1, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (GameType, alloy::sol_types::sol_data::Uint<256>); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._initialRespectedGameType, + ), + as alloy_sol_types::SolType>::tokenize( + &self._disputeGameFinalityDelaySeconds, + ), + ) + } + } + }; + /**Function with signature `blacklistDisputeGame(address)` and selector `0x7d6be8dc`. +```solidity +function blacklistDisputeGame(address _disputeGame) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct blacklistDisputeGameCall { + #[allow(missing_docs)] + pub _disputeGame: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`blacklistDisputeGame(address)`](blacklistDisputeGameCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct blacklistDisputeGameReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: blacklistDisputeGameCall) -> Self { + (value._disputeGame,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for blacklistDisputeGameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _disputeGame: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: blacklistDisputeGameReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for blacklistDisputeGameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl blacklistDisputeGameReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for blacklistDisputeGameCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = blacklistDisputeGameReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "blacklistDisputeGame(address)"; + const SELECTOR: [u8; 4] = [125u8, 107u8, 232u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._disputeGame, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + blacklistDisputeGameReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `disputeGameBlacklist(address)` and selector `0x45884d32`. +```solidity +function disputeGameBlacklist(address) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameBlacklistCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`disputeGameBlacklist(address)`](disputeGameBlacklistCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameBlacklistReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameBlacklistCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameBlacklistCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameBlacklistReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameBlacklistReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameBlacklistCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameBlacklist(address)"; + const SELECTOR: [u8; 4] = [69u8, 136u8, 77u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameBlacklistReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameBlacklistReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `disputeGameFinalityDelaySeconds()` and selector `0x952b2797`. +```solidity +function disputeGameFinalityDelaySeconds() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFinalityDelaySecondsCall; + ///Container type for the return parameters of the [`disputeGameFinalityDelaySeconds()`](disputeGameFinalityDelaySecondsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFinalityDelaySecondsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFinalityDelaySecondsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFinalityDelaySecondsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFinalityDelaySecondsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFinalityDelaySecondsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameFinalityDelaySecondsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameFinalityDelaySeconds()"; + const SELECTOR: [u8; 4] = [149u8, 43u8, 39u8, 151u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameFinalityDelaySecondsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameFinalityDelaySecondsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `respectedGameType()` and selector `0x3c9f397c`. +```solidity +function respectedGameType() external view returns (GameType); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct respectedGameTypeCall; + ///Container type for the return parameters of the [`respectedGameType()`](respectedGameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct respectedGameTypeReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: respectedGameTypeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for respectedGameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: respectedGameTypeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for respectedGameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for respectedGameTypeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameType,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "respectedGameType()"; + const SELECTOR: [u8; 4] = [60u8, 159u8, 57u8, 124u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: respectedGameTypeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: respectedGameTypeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `respectedGameTypeUpdatedAt()` and selector `0x4fd0434c`. +```solidity +function respectedGameTypeUpdatedAt() external view returns (uint64); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct respectedGameTypeUpdatedAtCall; + ///Container type for the return parameters of the [`respectedGameTypeUpdatedAt()`](respectedGameTypeUpdatedAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct respectedGameTypeUpdatedAtReturn { + #[allow(missing_docs)] + pub _0: u64, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: respectedGameTypeUpdatedAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for respectedGameTypeUpdatedAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u64,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: respectedGameTypeUpdatedAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for respectedGameTypeUpdatedAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for respectedGameTypeUpdatedAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u64; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "respectedGameTypeUpdatedAt()"; + const SELECTOR: [u8; 4] = [79u8, 208u8, 67u8, 76u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: respectedGameTypeUpdatedAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: respectedGameTypeUpdatedAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `setRespectedGameType(uint32)` and selector `0x7fc48504`. +```solidity +function setRespectedGameType(GameType _gameType) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setRespectedGameTypeCall { + #[allow(missing_docs)] + pub _gameType: ::RustType, + } + ///Container type for the return parameters of the [`setRespectedGameType(uint32)`](setRespectedGameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setRespectedGameTypeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setRespectedGameTypeCall) -> Self { + (value._gameType,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setRespectedGameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _gameType: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setRespectedGameTypeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setRespectedGameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setRespectedGameTypeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setRespectedGameTypeCall { + type Parameters<'a> = (GameType,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setRespectedGameTypeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setRespectedGameType(uint32)"; + const SELECTOR: [u8; 4] = [127u8, 196u8, 133u8, 4u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self._gameType),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setRespectedGameTypeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`MockOptimismPortal2`](self) function calls. + #[derive(Clone)] + pub enum MockOptimismPortal2Calls { + #[allow(missing_docs)] + blacklistDisputeGame(blacklistDisputeGameCall), + #[allow(missing_docs)] + disputeGameBlacklist(disputeGameBlacklistCall), + #[allow(missing_docs)] + disputeGameFinalityDelaySeconds(disputeGameFinalityDelaySecondsCall), + #[allow(missing_docs)] + respectedGameType(respectedGameTypeCall), + #[allow(missing_docs)] + respectedGameTypeUpdatedAt(respectedGameTypeUpdatedAtCall), + #[allow(missing_docs)] + setRespectedGameType(setRespectedGameTypeCall), + } + impl MockOptimismPortal2Calls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [60u8, 159u8, 57u8, 124u8], + [69u8, 136u8, 77u8, 50u8], + [79u8, 208u8, 67u8, 76u8], + [125u8, 107u8, 232u8, 220u8], + [127u8, 196u8, 133u8, 4u8], + [149u8, 43u8, 39u8, 151u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(respectedGameType), + ::core::stringify!(disputeGameBlacklist), + ::core::stringify!(respectedGameTypeUpdatedAt), + ::core::stringify!(blacklistDisputeGame), + ::core::stringify!(setRespectedGameType), + ::core::stringify!(disputeGameFinalityDelaySeconds), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for MockOptimismPortal2Calls { + const NAME: &'static str = "MockOptimismPortal2Calls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 6usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::blacklistDisputeGame(_) => { + ::SELECTOR + } + Self::disputeGameBlacklist(_) => { + ::SELECTOR + } + Self::disputeGameFinalityDelaySeconds(_) => { + ::SELECTOR + } + Self::respectedGameType(_) => { + ::SELECTOR + } + Self::respectedGameTypeUpdatedAt(_) => { + ::SELECTOR + } + Self::setRespectedGameType(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn respectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockOptimismPortal2Calls::respectedGameType) + } + respectedGameType + }, + { + fn disputeGameBlacklist( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockOptimismPortal2Calls::disputeGameBlacklist) + } + disputeGameBlacklist + }, + { + fn respectedGameTypeUpdatedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockOptimismPortal2Calls::respectedGameTypeUpdatedAt) + } + respectedGameTypeUpdatedAt + }, + { + fn blacklistDisputeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockOptimismPortal2Calls::blacklistDisputeGame) + } + blacklistDisputeGame + }, + { + fn setRespectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockOptimismPortal2Calls::setRespectedGameType) + } + setRespectedGameType + }, + { + fn disputeGameFinalityDelaySeconds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + MockOptimismPortal2Calls::disputeGameFinalityDelaySeconds, + ) + } + disputeGameFinalityDelaySeconds + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn respectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockOptimismPortal2Calls::respectedGameType) + } + respectedGameType + }, + { + fn disputeGameBlacklist( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockOptimismPortal2Calls::disputeGameBlacklist) + } + disputeGameBlacklist + }, + { + fn respectedGameTypeUpdatedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockOptimismPortal2Calls::respectedGameTypeUpdatedAt) + } + respectedGameTypeUpdatedAt + }, + { + fn blacklistDisputeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockOptimismPortal2Calls::blacklistDisputeGame) + } + blacklistDisputeGame + }, + { + fn setRespectedGameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockOptimismPortal2Calls::setRespectedGameType) + } + setRespectedGameType + }, + { + fn disputeGameFinalityDelaySeconds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + MockOptimismPortal2Calls::disputeGameFinalityDelaySeconds, + ) + } + disputeGameFinalityDelaySeconds + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::blacklistDisputeGame(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disputeGameBlacklist(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disputeGameFinalityDelaySeconds(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::respectedGameType(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::respectedGameTypeUpdatedAt(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setRespectedGameType(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::blacklistDisputeGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disputeGameBlacklist(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disputeGameFinalityDelaySeconds(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::respectedGameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::respectedGameTypeUpdatedAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setRespectedGameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`MockOptimismPortal2`](self) contract instance. + +See the [wrapper's documentation](`MockOptimismPortal2Instance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> MockOptimismPortal2Instance { + MockOptimismPortal2Instance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _initialRespectedGameType: ::RustType, + _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + MockOptimismPortal2Instance::< + P, + N, + >::deploy( + __provider, + _initialRespectedGameType, + _disputeGameFinalityDelaySeconds, + ) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _initialRespectedGameType: ::RustType, + _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::RawCallBuilder { + MockOptimismPortal2Instance::< + P, + N, + >::deploy_builder( + __provider, + _initialRespectedGameType, + _disputeGameFinalityDelaySeconds, + ) + } + /**A [`MockOptimismPortal2`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`MockOptimismPortal2`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct MockOptimismPortal2Instance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for MockOptimismPortal2Instance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("MockOptimismPortal2Instance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > MockOptimismPortal2Instance { + /**Creates a new wrapper around an on-chain [`MockOptimismPortal2`](self) contract instance. + +See the [wrapper's documentation](`MockOptimismPortal2Instance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + _initialRespectedGameType: ::RustType, + _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + __provider, + _initialRespectedGameType, + _disputeGameFinalityDelaySeconds, + ); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder( + __provider: P, + _initialRespectedGameType: ::RustType, + _disputeGameFinalityDelaySeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _initialRespectedGameType, + _disputeGameFinalityDelaySeconds, + }, + )[..], + ] + .concat() + .into(), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl MockOptimismPortal2Instance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> MockOptimismPortal2Instance { + MockOptimismPortal2Instance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > MockOptimismPortal2Instance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`blacklistDisputeGame`] function. + pub fn blacklistDisputeGame( + &self, + _disputeGame: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, blacklistDisputeGameCall, N> { + self.call_builder( + &blacklistDisputeGameCall { + _disputeGame, + }, + ) + } + ///Creates a new call builder for the [`disputeGameBlacklist`] function. + pub fn disputeGameBlacklist( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameBlacklistCall, N> { + self.call_builder(&disputeGameBlacklistCall(_0)) + } + ///Creates a new call builder for the [`disputeGameFinalityDelaySeconds`] function. + pub fn disputeGameFinalityDelaySeconds( + &self, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameFinalityDelaySecondsCall, N> { + self.call_builder(&disputeGameFinalityDelaySecondsCall) + } + ///Creates a new call builder for the [`respectedGameType`] function. + pub fn respectedGameType( + &self, + ) -> alloy_contract::SolCallBuilder<&P, respectedGameTypeCall, N> { + self.call_builder(&respectedGameTypeCall) + } + ///Creates a new call builder for the [`respectedGameTypeUpdatedAt`] function. + pub fn respectedGameTypeUpdatedAt( + &self, + ) -> alloy_contract::SolCallBuilder<&P, respectedGameTypeUpdatedAtCall, N> { + self.call_builder(&respectedGameTypeUpdatedAtCall) + } + ///Creates a new call builder for the [`setRespectedGameType`] function. + pub fn setRespectedGameType( + &self, + _gameType: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, setRespectedGameTypeCall, N> { + self.call_builder( + &setRespectedGameTypeCall { + _gameType, + }, + ) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > MockOptimismPortal2Instance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/bindings/src/codegen/mock_permissioned_dispute_game.rs b/bindings/src/codegen/mock_permissioned_dispute_game.rs new file mode 100644 index 000000000..31e943053 --- /dev/null +++ b/bindings/src/codegen/mock_permissioned_dispute_game.rs @@ -0,0 +1,4325 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface MockPermissionedDisputeGame { + type GameStatus is uint8; + type Claim is bytes32; + type GameType is uint32; + type Hash is bytes32; + type Timestamp is uint64; + + event Resolved(GameStatus indexed status); + + constructor(address _disputeGameFactory); + + function claimData() external view returns (uint32 parentIndex, Claim claim); + function createdAt() external view returns (Timestamp); + function extraData() external pure returns (bytes memory extraData_); + function gameCreator() external pure returns (address creator_); + function gameData() external pure returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); + function gameType() external pure returns (GameType gameType_); + function initialize() external payable; + function l1Head() external pure returns (Hash l1Head_); + function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); + function parentIndex() external pure returns (uint32 parentIndex_); + function resolve() external returns (GameStatus status_); + function resolvedAt() external view returns (Timestamp); + function rootClaim() external pure returns (Claim rootClaim_); + function status() external view returns (GameStatus); + function wasRespectedGameTypeWhenCreated() external pure returns (bool); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_disputeGameFactory", + "type": "address", + "internalType": "contract IDisputeGameFactory" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "claimData", + "inputs": [], + "outputs": [ + { + "name": "parentIndex", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "claim", + "type": "bytes32", + "internalType": "Claim" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "createdAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "extraData", + "inputs": [], + "outputs": [ + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameCreator", + "inputs": [], + "outputs": [ + { + "name": "creator_", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameData", + "inputs": [], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "rootClaim_", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameType", + "inputs": [], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "l1Head", + "inputs": [], + "outputs": [ + { + "name": "l1Head_", + "type": "bytes32", + "internalType": "Hash" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "l2SequenceNumber", + "inputs": [], + "outputs": [ + { + "name": "l2SequenceNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "parentIndex", + "inputs": [], + "outputs": [ + { + "name": "parentIndex_", + "type": "uint32", + "internalType": "uint32" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "resolve", + "inputs": [], + "outputs": [ + { + "name": "status_", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "resolvedAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "rootClaim", + "inputs": [], + "outputs": [ + { + "name": "rootClaim_", + "type": "bytes32", + "internalType": "Claim" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "status", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "wasRespectedGameTypeWhenCreated", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "pure" + }, + { + "type": "event", + "name": "Resolved", + "inputs": [ + { + "name": "status", + "type": "uint8", + "indexed": true, + "internalType": "enum GameStatus" + } + ], + "anonymous": false + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod MockPermissionedDisputeGame { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\xA0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0\x11)8\x03\x80b\0\x11)\x839\x81\x81\x01`@R\x81\x01\x90b\0\x007\x91\x90b\0\0\xF0V[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x80\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPPPb\0\x01\"V[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0b\0\0\xA4\x82b\0\0wV[\x90P\x91\x90PV[`\0b\0\0\xB8\x82b\0\0\x97V[\x90P\x91\x90PV[b\0\0\xCA\x81b\0\0\xABV[\x81\x14b\0\0\xD6W`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\0\xEA\x81b\0\0\xBFV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15b\0\x01\tWb\0\x01\x08b\0\0rV[[`\0b\0\x01\x19\x84\x82\x85\x01b\0\0\xD9V[\x91PP\x92\x91PPV[`\x80Qa\x0F\xEBb\0\x01>`\09`\0a\x05\x8A\x01Ra\x0F\xEB`\0\xF3\xFE`\x80`@R`\x046\x10a\0\xE8W`\x005`\xE0\x1C\x80ccaPm\x11a\0\x8AW\x80c\xBB\xDC\x02\xDB\x11a\0YW\x80c\xBB\xDC\x02\xDB\x14a\x02\xA6W\x80c\xBC\xEF;U\x14a\x02\xD1W\x80c\xCF\t\xE0\xD0\x14a\x02\xFCW\x80c\xFA$\xF7C\x14a\x03'Wa\0\xE8V[\x80ccaPm\x14a\x02\x1BW\x80cyHi\n\x14a\x02FW\x80c\x81)\xFC\x1C\x14a\x02qW\x80c\x99s^2\x14a\x02{Wa\0\xE8V[\x80c(\x10\xE1\xD6\x11a\0\xC6W\x80c(\x10\xE1\xD6\x14a\x01nW\x80c7\xB1\xB2)\x14a\x01\x99W\x80c>\xC4\xD4\xD6\x14a\x01\xC4W\x80c`\x9D34\x14a\x01\xF0Wa\0\xE8V[\x80c\x19\xEF\xFE\xB4\x14a\0\xEDW\x80c \r.\xD2\x14a\x01\x18W\x80c%\x0Ei\xBD\x14a\x01CW[`\0\x80\xFD[4\x80\x15a\0\xF9W`\0\x80\xFD[Pa\x01\x02a\x03TV[`@Qa\x01\x0F\x91\x90a\tUV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01$W`\0\x80\xFD[Pa\x01-a\x03qV[`@Qa\x01:\x91\x90a\t\xE7V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01OW`\0\x80\xFD[Pa\x01Xa\x03\x87V[`@Qa\x01e\x91\x90a\n\x1DV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01zW`\0\x80\xFD[Pa\x01\x83a\x03\x90V[`@Qa\x01\x90\x91\x90a\t\xE7V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xA5W`\0\x80\xFD[Pa\x01\xAEa\x04IV[`@Qa\x01\xBB\x91\x90a\nyV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xD0W`\0\x80\xFD[Pa\x01\xD9a\x04ZV[`@Qa\x01\xE7\x92\x91\x90a\n\xDEV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xFCW`\0\x80\xFD[Pa\x02\x05a\x04|V[`@Qa\x02\x12\x91\x90a\x0B\xA0V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02'W`\0\x80\xFD[Pa\x020a\x04\x8FV[`@Qa\x02=\x91\x90a\x0B\xD1V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02RW`\0\x80\xFD[Pa\x02[a\x04\xA0V[`@Qa\x02h\x91\x90a\x0B\xECV[`@Q\x80\x91\x03\x90\xF3[a\x02ya\x04\xB1V[\0[4\x80\x15a\x02\x87W`\0\x80\xFD[Pa\x02\x90a\x07\xD9V[`@Qa\x02\x9D\x91\x90a\x0C V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xB2W`\0\x80\xFD[Pa\x02\xBBa\x07\xEAV[`@Qa\x02\xC8\x91\x90a\x0ClV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xDDW`\0\x80\xFD[Pa\x02\xE6a\x07\xF3V[`@Qa\x02\xF3\x91\x90a\x0C\x87V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x08W`\0\x80\xFD[Pa\x03\x11a\x08\x04V[`@Qa\x03\x1E\x91\x90a\tUV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x033W`\0\x80\xFD[Pa\x03=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06)\x91\x90a\x0E\xB0V[\x92PPP`@Q\x80`@\x01`@R\x80a\x06\xAF\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBC\xEF;U`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x86W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xAA\x91\x90a\x0F/V[a\x08\xD2V[\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x99s^2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xFFW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07#\x91\x90a\x0F\x88V[\x81RP`\x03`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U\x90PPPa\x07xV[`@Q\x80`@\x01`@R\x80`\0\x80\x1B\x81R` \x01`\0\x81RP`\x03`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U\x90PP[`@Q\x80`@\x01`@R\x80a\x07\x8Ba\x04\xA0V[c\xFF\xFF\xFF\xFF\x16\x81R` \x01a\x07\x9Ea\x07\xF3V[\x81RP`\x01`\0\x82\x01Q\x81`\0\x01`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP` \x82\x01Q\x81`\x01\x01U\x90PPV[`\0a\x07\xE5`Ta\x08\xDCV[\x90P\x90V[`\0`\x01\x90P\x90V[`\0a\x07\xFF`\x14a\x08\x9DV[\x90P\x90V[`\0\x80`\x02\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x90V[`\0\x80``a\x08.a\x07\xEAV[\x92Pa\x088a\x07\xF3V[\x91Pa\x08Ba\x04|V[\x90P\x90\x91\x92V[`\0\x80a\x08Ta\x08\xF5V[\x90P\x82\x81\x015``\x1C\x91PP\x91\x90PV[```\0a\x08qa\x08\xF5V[\x90P`@Q\x91P\x82\x82R\x82\x84\x82\x01` \x84\x017\x82` \x83\x01\x01`\0\x81R` \x81\x01`@RPP\x92\x91PPV[`\0\x80a\x08\xA8a\x08\xF5V[\x90P\x82\x81\x015\x91PP\x91\x90PV[`\0\x80a\x08\xC1a\x08\xF5V[\x90P\x82\x81\x015`\xE0\x1C\x91PP\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0\x80a\x08\xE7a\x08\xF5V[\x90P\x82\x81\x015\x91PP\x91\x90PV[`\0`\x026\x035`\xF0\x1C6\x03\x90P\x90V[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0a\t?a\t:a\t5\x84a\t\x06V[a\t\x1AV[a\t\x06V[\x90P\x91\x90PV[a\tO\x81a\t$V[\x82RPPV[`\0` \x82\x01\x90Pa\tj`\0\x83\x01\x84a\tFV[\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`!`\x04R`$`\0\xFD[`\x03\x81\x10a\t\xB0Wa\t\xAFa\tpV[[PV[`\0\x81\x90Pa\t\xC1\x82a\t\x9FV[\x91\x90PV[`\0a\t\xD1\x82a\t\xB3V[\x90P\x91\x90PV[a\t\xE1\x81a\t\xC6V[\x82RPPV[`\0` \x82\x01\x90Pa\t\xFC`\0\x83\x01\x84a\t\xD8V[\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\n\x17\x81a\n\x02V[\x82RPPV[`\0` \x82\x01\x90Pa\n2`\0\x83\x01\x84a\n\x0EV[\x92\x91PPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\nc\x82a\n8V[\x90P\x91\x90PV[a\ns\x81a\nXV[\x82RPPV[`\0` \x82\x01\x90Pa\n\x8E`\0\x83\x01\x84a\njV[\x92\x91PPV[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a\n\xAD\x81a\n\x94V[\x82RPPV[`\0\x81\x90P\x91\x90PV[`\0a\n\xC8\x82a\n\xB3V[\x90P\x91\x90PV[a\n\xD8\x81a\n\xBDV[\x82RPPV[`\0`@\x82\x01\x90Pa\n\xF3`\0\x83\x01\x85a\n\xA4V[a\x0B\0` \x83\x01\x84a\n\xCFV[\x93\x92PPPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x0BAW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x0B&V[\x83\x81\x11\x15a\x0BPW`\0\x84\x84\x01R[PPPPV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x0Br\x82a\x0B\x07V[a\x0B|\x81\x85a\x0B\x12V[\x93Pa\x0B\x8C\x81\x85` \x86\x01a\x0B#V[a\x0B\x95\x81a\x0BVV[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x0B\xBA\x81\x84a\x0BgV[\x90P\x92\x91PPV[a\x0B\xCB\x81a\n\xBDV[\x82RPPV[`\0` \x82\x01\x90Pa\x0B\xE6`\0\x83\x01\x84a\x0B\xC2V[\x92\x91PPV[`\0` \x82\x01\x90Pa\x0C\x01`\0\x83\x01\x84a\n\xA4V[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\x0C\x1A\x81a\x0C\x07V[\x82RPPV[`\0` \x82\x01\x90Pa\x0C5`\0\x83\x01\x84a\x0C\x11V[\x92\x91PPV[`\0a\x0CVa\x0CQa\x0CL\x84a\n\x94V[a\t\x1AV[a\n\x94V[\x90P\x91\x90PV[a\x0Cf\x81a\x0C;V[\x82RPPV[`\0` \x82\x01\x90Pa\x0C\x81`\0\x83\x01\x84a\x0C]V[\x92\x91PPV[`\0` \x82\x01\x90Pa\x0C\x9C`\0\x83\x01\x84a\n\xCFV[\x92\x91PPV[`\0``\x82\x01\x90Pa\x0C\xB7`\0\x83\x01\x86a\x0C]V[a\x0C\xC4` \x83\x01\x85a\n\xCFV[\x81\x81\x03`@\x83\x01Ra\x0C\xD6\x81\x84a\x0BgV[\x90P\x94\x93PPPPV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[\x7Fnot initialized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x82\x01RPV[`\0a\r'`\x0F\x83a\x0C\xE0V[\x91Pa\r2\x82a\x0C\xF1V[` \x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\rV\x81a\r\x1AV[\x90P\x91\x90PV[\x7Falready initialized\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x82\x01RPV[`\0a\r\x93`\x13\x83a\x0C\xE0V[\x91Pa\r\x9E\x82a\r]V[` \x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\r\xC2\x81a\r\x86V[\x90P\x91\x90PV[`\0a\r\xE4a\r\xDFa\r\xDA\x84a\n\x94V[a\t\x1AV[a\x0C\x07V[\x90P\x91\x90PV[a\r\xF4\x81a\r\xC9V[\x82RPPV[`\0` \x82\x01\x90Pa\x0E\x0F`\0\x83\x01\x84a\r\xEBV[\x92\x91PPV[`\0\x80\xFD[a\x0E#\x81a\n\x94V[\x81\x14a\x0E.W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0E@\x81a\x0E\x1AV[\x92\x91PPV[a\x0EO\x81a\t\x06V[\x81\x14a\x0EZW`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0El\x81a\x0EFV[\x92\x91PPV[`\0a\x0E}\x82a\nXV[\x90P\x91\x90PV[a\x0E\x8D\x81a\x0ErV[\x81\x14a\x0E\x98W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0E\xAA\x81a\x0E\x84V[\x92\x91PPV[`\0\x80`\0``\x84\x86\x03\x12\x15a\x0E\xC9Wa\x0E\xC8a\x0E\x15V[[`\0a\x0E\xD7\x86\x82\x87\x01a\x0E1V[\x93PP` a\x0E\xE8\x86\x82\x87\x01a\x0E]V[\x92PP`@a\x0E\xF9\x86\x82\x87\x01a\x0E\x9BV[\x91PP\x92P\x92P\x92V[a\x0F\x0C\x81a\n\xB3V[\x81\x14a\x0F\x17W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0F)\x81a\x0F\x03V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x0FEWa\x0FDa\x0E\x15V[[`\0a\x0FS\x84\x82\x85\x01a\x0F\x1AV[\x91PP\x92\x91PPV[a\x0Fe\x81a\x0C\x07V[\x81\x14a\x0FpW`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0F\x82\x81a\x0F\\V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x0F\x9EWa\x0F\x9Da\x0E\x15V[[`\0a\x0F\xAC\x84\x82\x85\x01a\x0FsV[\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 \x93\x92]\x95\x1EH\x15c\xD5:{\xB5\xE3\x88\xA3\xA0\x0CT\x80\xA85i\xC5\xACa$\xB5\x0B\x0Ea\xE0\xBCdsolcC\0\x08\x0F\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x6080604052600436106100e85760003560e01c80636361506d1161008a578063bbdc02db11610059578063bbdc02db146102a6578063bcef3b55146102d1578063cf09e0d0146102fc578063fa24f74314610327576100e8565b80636361506d1461021b5780637948690a146102465780638129fc1c1461027157806399735e321461027b576100e8565b80632810e1d6116100c65780632810e1d61461016e57806337b1b229146101995780633ec4d4d6146101c4578063609d3334146101f0576100e8565b806319effeb4146100ed578063200d2ed214610118578063250e69bd14610143575b600080fd5b3480156100f957600080fd5b50610102610354565b60405161010f9190610955565b60405180910390f35b34801561012457600080fd5b5061012d610371565b60405161013a91906109e7565b60405180910390f35b34801561014f57600080fd5b50610158610387565b6040516101659190610a1d565b60405180910390f35b34801561017a57600080fd5b50610183610390565b60405161019091906109e7565b60405180910390f35b3480156101a557600080fd5b506101ae610449565b6040516101bb9190610a79565b60405180910390f35b3480156101d057600080fd5b506101d961045a565b6040516101e7929190610ade565b60405180910390f35b3480156101fc57600080fd5b5061020561047c565b6040516102129190610ba0565b60405180910390f35b34801561022757600080fd5b5061023061048f565b60405161023d9190610bd1565b60405180910390f35b34801561025257600080fd5b5061025b6104a0565b6040516102689190610bec565b60405180910390f35b6102796104b1565b005b34801561028757600080fd5b506102906107d9565b60405161029d9190610c20565b60405180910390f35b3480156102b257600080fd5b506102bb6107ea565b6040516102c89190610c6c565b60405180910390f35b3480156102dd57600080fd5b506102e66107f3565b6040516102f39190610c87565b60405180910390f35b34801561030857600080fd5b50610311610804565b60405161031e9190610955565b60405180910390f35b34801561033357600080fd5b5061033c610821565b60405161034b93929190610ca2565b60405180910390f35b600080600a9054906101000a900467ffffffffffffffff16905090565b60008060019054906101000a900460ff16905090565b60006001905090565b60008060009054906101000a900460ff166103e0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103d790610d3d565b60405180910390fd5b6002600060016101000a81548160ff0219169083600281111561040657610405610970565b5b0217905550426000600a6101000a81548167ffffffffffffffff021916908367ffffffffffffffff160217905550600060019054906101000a900460ff16905090565b60006104556000610849565b905090565b60018060000160009054906101000a900463ffffffff16908060010154905082565b606061048a60546024610865565b905090565b600061049b603461089d565b905090565b60006104ac60746108b6565b905090565b60008054906101000a900460ff16156104ff576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104f690610da9565b60405180910390fd5b60016000806101000a81548160ff02191690831515021790555042600060026101000a81548167ffffffffffffffff021916908367ffffffffffffffff16021790555060008060016101000a81548160ff0219169083600281111561056757610566610970565b5b021790555063ffffffff801661057b6104a0565b63ffffffff16146107455760007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663bb8aa1fc6105cc6104a0565b6040518263ffffffff1660e01b81526004016105e89190610dfa565b606060405180830381865afa158015610605573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106299190610eb0565b9250505060405180604001604052806106af8373ffffffffffffffffffffffffffffffffffffffff1663bcef3b556040518163ffffffff1660e01b8152600401602060405180830381865afa158015610686573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106aa9190610f2f565b6108d2565b81526020018273ffffffffffffffffffffffffffffffffffffffff166399735e326040518163ffffffff1660e01b8152600401602060405180830381865afa1580156106ff573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107239190610f88565b8152506003600082015181600001556020820151816001015590505050610778565b60405180604001604052806000801b81526020016000815250600360008201518160000155602082015181600101559050505b604051806040016040528061078b6104a0565b63ffffffff16815260200161079e6107f3565b815250600160008201518160000160006101000a81548163ffffffff021916908363ffffffff16021790555060208201518160010155905050565b60006107e560546108dc565b905090565b60006001905090565b60006107ff601461089d565b905090565b60008060029054906101000a900467ffffffffffffffff16905090565b600080606061082e6107ea565b92506108386107f3565b915061084261047c565b9050909192565b6000806108546108f5565b90508281013560601c915050919050565b606060006108716108f5565b905060405191508282528284820160208401378260208301016000815260208101604052505092915050565b6000806108a86108f5565b905082810135915050919050565b6000806108c16108f5565b90508281013560e01c915050919050565b6000819050919050565b6000806108e76108f5565b905082810135915050919050565b6000600236033560f01c3603905090565b600067ffffffffffffffff82169050919050565b6000819050919050565b600061093f61093a61093584610906565b61091a565b610906565b9050919050565b61094f81610924565b82525050565b600060208201905061096a6000830184610946565b92915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b600381106109b0576109af610970565b5b50565b60008190506109c18261099f565b919050565b60006109d1826109b3565b9050919050565b6109e1816109c6565b82525050565b60006020820190506109fc60008301846109d8565b92915050565b60008115159050919050565b610a1781610a02565b82525050565b6000602082019050610a326000830184610a0e565b92915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000610a6382610a38565b9050919050565b610a7381610a58565b82525050565b6000602082019050610a8e6000830184610a6a565b92915050565b600063ffffffff82169050919050565b610aad81610a94565b82525050565b6000819050919050565b6000610ac882610ab3565b9050919050565b610ad881610abd565b82525050565b6000604082019050610af36000830185610aa4565b610b006020830184610acf565b9392505050565b600081519050919050565b600082825260208201905092915050565b60005b83811015610b41578082015181840152602081019050610b26565b83811115610b50576000848401525b50505050565b6000601f19601f8301169050919050565b6000610b7282610b07565b610b7c8185610b12565b9350610b8c818560208601610b23565b610b9581610b56565b840191505092915050565b60006020820190508181036000830152610bba8184610b67565b905092915050565b610bcb81610abd565b82525050565b6000602082019050610be66000830184610bc2565b92915050565b6000602082019050610c016000830184610aa4565b92915050565b6000819050919050565b610c1a81610c07565b82525050565b6000602082019050610c356000830184610c11565b92915050565b6000610c56610c51610c4c84610a94565b61091a565b610a94565b9050919050565b610c6681610c3b565b82525050565b6000602082019050610c816000830184610c5d565b92915050565b6000602082019050610c9c6000830184610acf565b92915050565b6000606082019050610cb76000830186610c5d565b610cc46020830185610acf565b8181036040830152610cd68184610b67565b9050949350505050565b600082825260208201905092915050565b7f6e6f7420696e697469616c697a65640000000000000000000000000000000000600082015250565b6000610d27600f83610ce0565b9150610d3282610cf1565b602082019050919050565b60006020820190508181036000830152610d5681610d1a565b9050919050565b7f616c726561647920696e697469616c697a656400000000000000000000000000600082015250565b6000610d93601383610ce0565b9150610d9e82610d5d565b602082019050919050565b60006020820190508181036000830152610dc281610d86565b9050919050565b6000610de4610ddf610dda84610a94565b61091a565b610c07565b9050919050565b610df481610dc9565b82525050565b6000602082019050610e0f6000830184610deb565b92915050565b600080fd5b610e2381610a94565b8114610e2e57600080fd5b50565b600081519050610e4081610e1a565b92915050565b610e4f81610906565b8114610e5a57600080fd5b50565b600081519050610e6c81610e46565b92915050565b6000610e7d82610a58565b9050919050565b610e8d81610e72565b8114610e9857600080fd5b50565b600081519050610eaa81610e84565b92915050565b600080600060608486031215610ec957610ec8610e15565b5b6000610ed786828701610e31565b9350506020610ee886828701610e5d565b9250506040610ef986828701610e9b565b9150509250925092565b610f0c81610ab3565b8114610f1757600080fd5b50565b600081519050610f2981610f03565b92915050565b600060208284031215610f4557610f44610e15565b5b6000610f5384828501610f1a565b91505092915050565b610f6581610c07565b8114610f7057600080fd5b50565b600081519050610f8281610f5c565b92915050565b600060208284031215610f9e57610f9d610e15565b5b6000610fac84828501610f73565b9150509291505056fea264697066735822122093925d951e481563d53a7bb5e388a3a00c5480a83569c5ac6124b50b0e61e0bc64736f6c634300080f0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R`\x046\x10a\0\xE8W`\x005`\xE0\x1C\x80ccaPm\x11a\0\x8AW\x80c\xBB\xDC\x02\xDB\x11a\0YW\x80c\xBB\xDC\x02\xDB\x14a\x02\xA6W\x80c\xBC\xEF;U\x14a\x02\xD1W\x80c\xCF\t\xE0\xD0\x14a\x02\xFCW\x80c\xFA$\xF7C\x14a\x03'Wa\0\xE8V[\x80ccaPm\x14a\x02\x1BW\x80cyHi\n\x14a\x02FW\x80c\x81)\xFC\x1C\x14a\x02qW\x80c\x99s^2\x14a\x02{Wa\0\xE8V[\x80c(\x10\xE1\xD6\x11a\0\xC6W\x80c(\x10\xE1\xD6\x14a\x01nW\x80c7\xB1\xB2)\x14a\x01\x99W\x80c>\xC4\xD4\xD6\x14a\x01\xC4W\x80c`\x9D34\x14a\x01\xF0Wa\0\xE8V[\x80c\x19\xEF\xFE\xB4\x14a\0\xEDW\x80c \r.\xD2\x14a\x01\x18W\x80c%\x0Ei\xBD\x14a\x01CW[`\0\x80\xFD[4\x80\x15a\0\xF9W`\0\x80\xFD[Pa\x01\x02a\x03TV[`@Qa\x01\x0F\x91\x90a\tUV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01$W`\0\x80\xFD[Pa\x01-a\x03qV[`@Qa\x01:\x91\x90a\t\xE7V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01OW`\0\x80\xFD[Pa\x01Xa\x03\x87V[`@Qa\x01e\x91\x90a\n\x1DV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01zW`\0\x80\xFD[Pa\x01\x83a\x03\x90V[`@Qa\x01\x90\x91\x90a\t\xE7V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xA5W`\0\x80\xFD[Pa\x01\xAEa\x04IV[`@Qa\x01\xBB\x91\x90a\nyV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xD0W`\0\x80\xFD[Pa\x01\xD9a\x04ZV[`@Qa\x01\xE7\x92\x91\x90a\n\xDEV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xFCW`\0\x80\xFD[Pa\x02\x05a\x04|V[`@Qa\x02\x12\x91\x90a\x0B\xA0V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02'W`\0\x80\xFD[Pa\x020a\x04\x8FV[`@Qa\x02=\x91\x90a\x0B\xD1V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02RW`\0\x80\xFD[Pa\x02[a\x04\xA0V[`@Qa\x02h\x91\x90a\x0B\xECV[`@Q\x80\x91\x03\x90\xF3[a\x02ya\x04\xB1V[\0[4\x80\x15a\x02\x87W`\0\x80\xFD[Pa\x02\x90a\x07\xD9V[`@Qa\x02\x9D\x91\x90a\x0C V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xB2W`\0\x80\xFD[Pa\x02\xBBa\x07\xEAV[`@Qa\x02\xC8\x91\x90a\x0ClV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xDDW`\0\x80\xFD[Pa\x02\xE6a\x07\xF3V[`@Qa\x02\xF3\x91\x90a\x0C\x87V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x08W`\0\x80\xFD[Pa\x03\x11a\x08\x04V[`@Qa\x03\x1E\x91\x90a\tUV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x033W`\0\x80\xFD[Pa\x03=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06)\x91\x90a\x0E\xB0V[\x92PPP`@Q\x80`@\x01`@R\x80a\x06\xAF\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBC\xEF;U`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x86W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xAA\x91\x90a\x0F/V[a\x08\xD2V[\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x99s^2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xFFW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07#\x91\x90a\x0F\x88V[\x81RP`\x03`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U\x90PPPa\x07xV[`@Q\x80`@\x01`@R\x80`\0\x80\x1B\x81R` \x01`\0\x81RP`\x03`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U\x90PP[`@Q\x80`@\x01`@R\x80a\x07\x8Ba\x04\xA0V[c\xFF\xFF\xFF\xFF\x16\x81R` \x01a\x07\x9Ea\x07\xF3V[\x81RP`\x01`\0\x82\x01Q\x81`\0\x01`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP` \x82\x01Q\x81`\x01\x01U\x90PPV[`\0a\x07\xE5`Ta\x08\xDCV[\x90P\x90V[`\0`\x01\x90P\x90V[`\0a\x07\xFF`\x14a\x08\x9DV[\x90P\x90V[`\0\x80`\x02\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x90V[`\0\x80``a\x08.a\x07\xEAV[\x92Pa\x088a\x07\xF3V[\x91Pa\x08Ba\x04|V[\x90P\x90\x91\x92V[`\0\x80a\x08Ta\x08\xF5V[\x90P\x82\x81\x015``\x1C\x91PP\x91\x90PV[```\0a\x08qa\x08\xF5V[\x90P`@Q\x91P\x82\x82R\x82\x84\x82\x01` \x84\x017\x82` \x83\x01\x01`\0\x81R` \x81\x01`@RPP\x92\x91PPV[`\0\x80a\x08\xA8a\x08\xF5V[\x90P\x82\x81\x015\x91PP\x91\x90PV[`\0\x80a\x08\xC1a\x08\xF5V[\x90P\x82\x81\x015`\xE0\x1C\x91PP\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0\x80a\x08\xE7a\x08\xF5V[\x90P\x82\x81\x015\x91PP\x91\x90PV[`\0`\x026\x035`\xF0\x1C6\x03\x90P\x90V[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0a\t?a\t:a\t5\x84a\t\x06V[a\t\x1AV[a\t\x06V[\x90P\x91\x90PV[a\tO\x81a\t$V[\x82RPPV[`\0` \x82\x01\x90Pa\tj`\0\x83\x01\x84a\tFV[\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`!`\x04R`$`\0\xFD[`\x03\x81\x10a\t\xB0Wa\t\xAFa\tpV[[PV[`\0\x81\x90Pa\t\xC1\x82a\t\x9FV[\x91\x90PV[`\0a\t\xD1\x82a\t\xB3V[\x90P\x91\x90PV[a\t\xE1\x81a\t\xC6V[\x82RPPV[`\0` \x82\x01\x90Pa\t\xFC`\0\x83\x01\x84a\t\xD8V[\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\n\x17\x81a\n\x02V[\x82RPPV[`\0` \x82\x01\x90Pa\n2`\0\x83\x01\x84a\n\x0EV[\x92\x91PPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\nc\x82a\n8V[\x90P\x91\x90PV[a\ns\x81a\nXV[\x82RPPV[`\0` \x82\x01\x90Pa\n\x8E`\0\x83\x01\x84a\njV[\x92\x91PPV[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a\n\xAD\x81a\n\x94V[\x82RPPV[`\0\x81\x90P\x91\x90PV[`\0a\n\xC8\x82a\n\xB3V[\x90P\x91\x90PV[a\n\xD8\x81a\n\xBDV[\x82RPPV[`\0`@\x82\x01\x90Pa\n\xF3`\0\x83\x01\x85a\n\xA4V[a\x0B\0` \x83\x01\x84a\n\xCFV[\x93\x92PPPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x0BAW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x0B&V[\x83\x81\x11\x15a\x0BPW`\0\x84\x84\x01R[PPPPV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x0Br\x82a\x0B\x07V[a\x0B|\x81\x85a\x0B\x12V[\x93Pa\x0B\x8C\x81\x85` \x86\x01a\x0B#V[a\x0B\x95\x81a\x0BVV[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x0B\xBA\x81\x84a\x0BgV[\x90P\x92\x91PPV[a\x0B\xCB\x81a\n\xBDV[\x82RPPV[`\0` \x82\x01\x90Pa\x0B\xE6`\0\x83\x01\x84a\x0B\xC2V[\x92\x91PPV[`\0` \x82\x01\x90Pa\x0C\x01`\0\x83\x01\x84a\n\xA4V[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\x0C\x1A\x81a\x0C\x07V[\x82RPPV[`\0` \x82\x01\x90Pa\x0C5`\0\x83\x01\x84a\x0C\x11V[\x92\x91PPV[`\0a\x0CVa\x0CQa\x0CL\x84a\n\x94V[a\t\x1AV[a\n\x94V[\x90P\x91\x90PV[a\x0Cf\x81a\x0C;V[\x82RPPV[`\0` \x82\x01\x90Pa\x0C\x81`\0\x83\x01\x84a\x0C]V[\x92\x91PPV[`\0` \x82\x01\x90Pa\x0C\x9C`\0\x83\x01\x84a\n\xCFV[\x92\x91PPV[`\0``\x82\x01\x90Pa\x0C\xB7`\0\x83\x01\x86a\x0C]V[a\x0C\xC4` \x83\x01\x85a\n\xCFV[\x81\x81\x03`@\x83\x01Ra\x0C\xD6\x81\x84a\x0BgV[\x90P\x94\x93PPPPV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[\x7Fnot initialized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x82\x01RPV[`\0a\r'`\x0F\x83a\x0C\xE0V[\x91Pa\r2\x82a\x0C\xF1V[` \x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\rV\x81a\r\x1AV[\x90P\x91\x90PV[\x7Falready initialized\0\0\0\0\0\0\0\0\0\0\0\0\0`\0\x82\x01RPV[`\0a\r\x93`\x13\x83a\x0C\xE0V[\x91Pa\r\x9E\x82a\r]V[` \x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\r\xC2\x81a\r\x86V[\x90P\x91\x90PV[`\0a\r\xE4a\r\xDFa\r\xDA\x84a\n\x94V[a\t\x1AV[a\x0C\x07V[\x90P\x91\x90PV[a\r\xF4\x81a\r\xC9V[\x82RPPV[`\0` \x82\x01\x90Pa\x0E\x0F`\0\x83\x01\x84a\r\xEBV[\x92\x91PPV[`\0\x80\xFD[a\x0E#\x81a\n\x94V[\x81\x14a\x0E.W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0E@\x81a\x0E\x1AV[\x92\x91PPV[a\x0EO\x81a\t\x06V[\x81\x14a\x0EZW`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0El\x81a\x0EFV[\x92\x91PPV[`\0a\x0E}\x82a\nXV[\x90P\x91\x90PV[a\x0E\x8D\x81a\x0ErV[\x81\x14a\x0E\x98W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0E\xAA\x81a\x0E\x84V[\x92\x91PPV[`\0\x80`\0``\x84\x86\x03\x12\x15a\x0E\xC9Wa\x0E\xC8a\x0E\x15V[[`\0a\x0E\xD7\x86\x82\x87\x01a\x0E1V[\x93PP` a\x0E\xE8\x86\x82\x87\x01a\x0E]V[\x92PP`@a\x0E\xF9\x86\x82\x87\x01a\x0E\x9BV[\x91PP\x92P\x92P\x92V[a\x0F\x0C\x81a\n\xB3V[\x81\x14a\x0F\x17W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0F)\x81a\x0F\x03V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x0FEWa\x0FDa\x0E\x15V[[`\0a\x0FS\x84\x82\x85\x01a\x0F\x1AV[\x91PP\x92\x91PPV[a\x0Fe\x81a\x0C\x07V[\x81\x14a\x0FpW`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0F\x82\x81a\x0F\\V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x0F\x9EWa\x0F\x9Da\x0E\x15V[[`\0a\x0F\xAC\x84\x82\x85\x01a\x0FsV[\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 \x93\x92]\x95\x1EH\x15c\xD5:{\xB5\xE3\x88\xA3\xA0\x0CT\x80\xA85i\xC5\xACa$\xB5\x0B\x0Ea\xE0\xBCdsolcC\0\x08\x0F\x003", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameStatus(u8); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u8 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<8>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameStatus { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u8) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u8 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameStatus { + fn from(value: u8) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u8 { + fn from(value: GameStatus) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameStatus { + type RustType = u8; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameStatus { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Claim(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Claim { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Claim { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Claim) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Claim { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Claim { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Hash(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Hash { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Hash { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Hash) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Hash { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Hash { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Timestamp(u64); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u64 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<64>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Timestamp { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u64) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u64 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Timestamp { + fn from(value: u64) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u64 { + fn from(value: Timestamp) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Timestamp { + type RustType = u64; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Timestamp { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**Event with signature `Resolved(uint8)` and selector `0x5e186f09b9c93491f14e277eea7faa5de6a2d4bda75a79af7a3684fbfb42da60`. +```solidity +event Resolved(GameStatus indexed status); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Resolved { + #[allow(missing_docs)] + pub status: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Resolved { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>, GameStatus); + const SIGNATURE: &'static str = "Resolved(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { status: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.status.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.status, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Resolved { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Resolved> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Resolved) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _disputeGameFactory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _disputeGameFactory: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._disputeGameFactory,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _disputeGameFactory: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._disputeGameFactory, + ), + ) + } + } + }; + /**Function with signature `claimData()` and selector `0x3ec4d4d6`. +```solidity +function claimData() external view returns (uint32 parentIndex, Claim claim); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimDataCall; + ///Container type for the return parameters of the [`claimData()`](claimDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimDataReturn { + #[allow(missing_docs)] + pub parentIndex: u32, + #[allow(missing_docs)] + pub claim: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>, Claim); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + u32, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimDataReturn) -> Self { + (value.parentIndex, value.claim) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + parentIndex: tuple.0, + claim: tuple.1, + } + } + } + } + impl claimDataReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.parentIndex), + ::tokenize(&self.claim), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for claimDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = claimDataReturn; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>, Claim); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "claimData()"; + const SELECTOR: [u8; 4] = [62u8, 196u8, 212u8, 214u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + claimDataReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `createdAt()` and selector `0xcf09e0d0`. +```solidity +function createdAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtCall; + ///Container type for the return parameters of the [`createdAt()`](createdAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createdAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "createdAt()"; + const SELECTOR: [u8; 4] = [207u8, 9u8, 224u8, 208u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `extraData()` and selector `0x609d3334`. +```solidity +function extraData() external pure returns (bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataCall; + ///Container type for the return parameters of the [`extraData()`](extraDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataReturn { + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataReturn) -> Self { + (value.extraData_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { extraData_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for extraDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Bytes; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "extraData()"; + const SELECTOR: [u8; 4] = [96u8, 157u8, 51u8, 52u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + } + }; + /**Function with signature `gameCreator()` and selector `0x37b1b229`. +```solidity +function gameCreator() external pure returns (address creator_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorCall; + ///Container type for the return parameters of the [`gameCreator()`](gameCreatorCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorReturn { + #[allow(missing_docs)] + pub creator_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorReturn) -> Self { + (value.creator_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { creator_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameCreatorCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameCreator()"; + const SELECTOR: [u8; 4] = [55u8, 177u8, 178u8, 41u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r.creator_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r.creator_ + }) + } + } + }; + /**Function with signature `gameData()` and selector `0xfa24f743`. +```solidity +function gameData() external pure returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataCall; + ///Container type for the return parameters of the [`gameData()`](gameDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + #[allow(missing_docs)] + pub rootClaim_: ::RustType, + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataReturn) -> Self { + (value.gameType_, value.rootClaim_, value.extraData_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + gameType_: tuple.0, + rootClaim_: tuple.1, + extraData_: tuple.2, + } + } + } + } + impl gameDataReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.gameType_), + ::tokenize(&self.rootClaim_), + ::tokenize( + &self.extraData_, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = gameDataReturn; + type ReturnTuple<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameData()"; + const SELECTOR: [u8; 4] = [250u8, 36u8, 247u8, 67u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + gameDataReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `gameType()` and selector `0xbbdc02db`. +```solidity +function gameType() external pure returns (GameType gameType_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeCall; + ///Container type for the return parameters of the [`gameType()`](gameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeReturn) -> Self { + (value.gameType_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { gameType_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameTypeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameType,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameType()"; + const SELECTOR: [u8; 4] = [187u8, 220u8, 2u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r.gameType_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r.gameType_ + }) + } + } + }; + /**Function with signature `initialize()` and selector `0x8129fc1c`. +```solidity +function initialize() external payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall; + ///Container type for the return parameters of the [`initialize()`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize()"; + const SELECTOR: [u8; 4] = [129u8, 41u8, 252u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `l1Head()` and selector `0x6361506d`. +```solidity +function l1Head() external pure returns (Hash l1Head_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadCall; + ///Container type for the return parameters of the [`l1Head()`](l1HeadCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadReturn { + #[allow(missing_docs)] + pub l1Head_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadReturn) -> Self { + (value.l1Head_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l1Head_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l1HeadCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Hash,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l1Head()"; + const SELECTOR: [u8; 4] = [99u8, 97u8, 80u8, 109u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r.l1Head_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r.l1Head_ + }) + } + } + }; + /**Function with signature `l2SequenceNumber()` and selector `0x99735e32`. +```solidity +function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberCall; + ///Container type for the return parameters of the [`l2SequenceNumber()`](l2SequenceNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberReturn { + #[allow(missing_docs)] + pub l2SequenceNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberReturn) -> Self { + (value.l2SequenceNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l2SequenceNumber_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2SequenceNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2SequenceNumber()"; + const SELECTOR: [u8; 4] = [153u8, 115u8, 94u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + } + }; + /**Function with signature `parentIndex()` and selector `0x7948690a`. +```solidity +function parentIndex() external pure returns (uint32 parentIndex_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct parentIndexCall; + ///Container type for the return parameters of the [`parentIndex()`](parentIndexCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct parentIndexReturn { + #[allow(missing_docs)] + pub parentIndex_: u32, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: parentIndexCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for parentIndexCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u32,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: parentIndexReturn) -> Self { + (value.parentIndex_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for parentIndexReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { parentIndex_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for parentIndexCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u32; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "parentIndex()"; + const SELECTOR: [u8; 4] = [121u8, 72u8, 105u8, 10u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: parentIndexReturn = r.into(); + r.parentIndex_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: parentIndexReturn = r.into(); + r.parentIndex_ + }) + } + } + }; + /**Function with signature `resolve()` and selector `0x2810e1d6`. +```solidity +function resolve() external returns (GameStatus status_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveCall; + ///Container type for the return parameters of the [`resolve()`](resolveCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveReturn { + #[allow(missing_docs)] + pub status_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveReturn) -> Self { + (value.status_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { status_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolveCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolve()"; + const SELECTOR: [u8; 4] = [40u8, 16u8, 225u8, 214u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolveReturn = r.into(); + r.status_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolveReturn = r.into(); + r.status_ + }) + } + } + }; + /**Function with signature `resolvedAt()` and selector `0x19effeb4`. +```solidity +function resolvedAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtCall; + ///Container type for the return parameters of the [`resolvedAt()`](resolvedAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolvedAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolvedAt()"; + const SELECTOR: [u8; 4] = [25u8, 239u8, 254u8, 180u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `rootClaim()` and selector `0xbcef3b55`. +```solidity +function rootClaim() external pure returns (Claim rootClaim_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimCall; + ///Container type for the return parameters of the [`rootClaim()`](rootClaimCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimReturn { + #[allow(missing_docs)] + pub rootClaim_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Claim,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimReturn) -> Self { + (value.rootClaim_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { rootClaim_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for rootClaimCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Claim,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "rootClaim()"; + const SELECTOR: [u8; 4] = [188u8, 239u8, 59u8, 85u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r.rootClaim_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r.rootClaim_ + }) + } + } + }; + /**Function with signature `status()` and selector `0x200d2ed2`. +```solidity +function status() external view returns (GameStatus); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusCall; + ///Container type for the return parameters of the [`status()`](statusCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for statusCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "status()"; + const SELECTOR: [u8; 4] = [32u8, 13u8, 46u8, 210u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `wasRespectedGameTypeWhenCreated()` and selector `0x250e69bd`. +```solidity +function wasRespectedGameTypeWhenCreated() external pure returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedCall; + ///Container type for the return parameters of the [`wasRespectedGameTypeWhenCreated()`](wasRespectedGameTypeWhenCreatedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for wasRespectedGameTypeWhenCreatedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "wasRespectedGameTypeWhenCreated()"; + const SELECTOR: [u8; 4] = [37u8, 14u8, 105u8, 189u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`MockPermissionedDisputeGame`](self) function calls. + #[derive(Clone)] + pub enum MockPermissionedDisputeGameCalls { + #[allow(missing_docs)] + claimData(claimDataCall), + #[allow(missing_docs)] + createdAt(createdAtCall), + #[allow(missing_docs)] + extraData(extraDataCall), + #[allow(missing_docs)] + gameCreator(gameCreatorCall), + #[allow(missing_docs)] + gameData(gameDataCall), + #[allow(missing_docs)] + gameType(gameTypeCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + l1Head(l1HeadCall), + #[allow(missing_docs)] + l2SequenceNumber(l2SequenceNumberCall), + #[allow(missing_docs)] + parentIndex(parentIndexCall), + #[allow(missing_docs)] + resolve(resolveCall), + #[allow(missing_docs)] + resolvedAt(resolvedAtCall), + #[allow(missing_docs)] + rootClaim(rootClaimCall), + #[allow(missing_docs)] + status(statusCall), + #[allow(missing_docs)] + wasRespectedGameTypeWhenCreated(wasRespectedGameTypeWhenCreatedCall), + } + impl MockPermissionedDisputeGameCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [25u8, 239u8, 254u8, 180u8], + [32u8, 13u8, 46u8, 210u8], + [37u8, 14u8, 105u8, 189u8], + [40u8, 16u8, 225u8, 214u8], + [55u8, 177u8, 178u8, 41u8], + [62u8, 196u8, 212u8, 214u8], + [96u8, 157u8, 51u8, 52u8], + [99u8, 97u8, 80u8, 109u8], + [121u8, 72u8, 105u8, 10u8], + [129u8, 41u8, 252u8, 28u8], + [153u8, 115u8, 94u8, 50u8], + [187u8, 220u8, 2u8, 219u8], + [188u8, 239u8, 59u8, 85u8], + [207u8, 9u8, 224u8, 208u8], + [250u8, 36u8, 247u8, 67u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(resolvedAt), + ::core::stringify!(status), + ::core::stringify!(wasRespectedGameTypeWhenCreated), + ::core::stringify!(resolve), + ::core::stringify!(gameCreator), + ::core::stringify!(claimData), + ::core::stringify!(extraData), + ::core::stringify!(l1Head), + ::core::stringify!(parentIndex), + ::core::stringify!(initialize), + ::core::stringify!(l2SequenceNumber), + ::core::stringify!(gameType), + ::core::stringify!(rootClaim), + ::core::stringify!(createdAt), + ::core::stringify!(gameData), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for MockPermissionedDisputeGameCalls { + const NAME: &'static str = "MockPermissionedDisputeGameCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 15usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::claimData(_) => { + ::SELECTOR + } + Self::createdAt(_) => { + ::SELECTOR + } + Self::extraData(_) => { + ::SELECTOR + } + Self::gameCreator(_) => { + ::SELECTOR + } + Self::gameData(_) => ::SELECTOR, + Self::gameType(_) => ::SELECTOR, + Self::initialize(_) => { + ::SELECTOR + } + Self::l1Head(_) => ::SELECTOR, + Self::l2SequenceNumber(_) => { + ::SELECTOR + } + Self::parentIndex(_) => { + ::SELECTOR + } + Self::resolve(_) => ::SELECTOR, + Self::resolvedAt(_) => { + ::SELECTOR + } + Self::rootClaim(_) => { + ::SELECTOR + } + Self::status(_) => ::SELECTOR, + Self::wasRespectedGameTypeWhenCreated(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockPermissionedDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(MockPermissionedDisputeGameCalls::status) + } + status + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + MockPermissionedDisputeGameCalls::wasRespectedGameTypeWhenCreated, + ) + } + wasRespectedGameTypeWhenCreated + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(MockPermissionedDisputeGameCalls::resolve) + } + resolve + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockPermissionedDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn claimData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(MockPermissionedDisputeGameCalls::claimData) + } + claimData + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(MockPermissionedDisputeGameCalls::extraData) + } + extraData + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(MockPermissionedDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn parentIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockPermissionedDisputeGameCalls::parentIndex) + } + parentIndex + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockPermissionedDisputeGameCalls::initialize) + } + initialize + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MockPermissionedDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(MockPermissionedDisputeGameCalls::gameType) + } + gameType + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(MockPermissionedDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(MockPermissionedDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(MockPermissionedDisputeGameCalls::gameData) + } + gameData + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::status) + } + status + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + MockPermissionedDisputeGameCalls::wasRespectedGameTypeWhenCreated, + ) + } + wasRespectedGameTypeWhenCreated + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::resolve) + } + resolve + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn claimData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::claimData) + } + claimData + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::extraData) + } + extraData + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn parentIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::parentIndex) + } + parentIndex + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::initialize) + } + initialize + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::gameType) + } + gameType + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MockPermissionedDisputeGameCalls::gameData) + } + gameData + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::claimData(inner) => { + ::abi_encoded_size(inner) + } + Self::createdAt(inner) => { + ::abi_encoded_size(inner) + } + Self::extraData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameCreator(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::gameData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameType(inner) => { + ::abi_encoded_size(inner) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::l1Head(inner) => { + ::abi_encoded_size(inner) + } + Self::l2SequenceNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::parentIndex(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::resolve(inner) => { + ::abi_encoded_size(inner) + } + Self::resolvedAt(inner) => { + ::abi_encoded_size(inner) + } + Self::rootClaim(inner) => { + ::abi_encoded_size(inner) + } + Self::status(inner) => { + ::abi_encoded_size(inner) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::claimData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::createdAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::extraData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameCreator(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l1Head(inner) => { + ::abi_encode_raw(inner, out) + } + Self::l2SequenceNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::parentIndex(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::resolve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::resolvedAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::rootClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::status(inner) => { + ::abi_encode_raw(inner, out) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`MockPermissionedDisputeGame`](self) events. + #[derive(Clone)] + pub enum MockPermissionedDisputeGameEvents { + #[allow(missing_docs)] + Resolved(Resolved), + } + impl MockPermissionedDisputeGameEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(Resolved), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for MockPermissionedDisputeGameEvents { + const NAME: &'static str = "MockPermissionedDisputeGameEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Resolved) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for MockPermissionedDisputeGameEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`MockPermissionedDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`MockPermissionedDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> MockPermissionedDisputeGameInstance { + MockPermissionedDisputeGameInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _disputeGameFactory: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + MockPermissionedDisputeGameInstance::< + P, + N, + >::deploy(__provider, _disputeGameFactory) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _disputeGameFactory: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + MockPermissionedDisputeGameInstance::< + P, + N, + >::deploy_builder(__provider, _disputeGameFactory) + } + /**A [`MockPermissionedDisputeGame`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`MockPermissionedDisputeGame`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct MockPermissionedDisputeGameInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for MockPermissionedDisputeGameInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("MockPermissionedDisputeGameInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > MockPermissionedDisputeGameInstance { + /**Creates a new wrapper around an on-chain [`MockPermissionedDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`MockPermissionedDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + _disputeGameFactory: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider, _disputeGameFactory); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder( + __provider: P, + _disputeGameFactory: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _disputeGameFactory, + }, + )[..], + ] + .concat() + .into(), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl MockPermissionedDisputeGameInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> MockPermissionedDisputeGameInstance { + MockPermissionedDisputeGameInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > MockPermissionedDisputeGameInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`claimData`] function. + pub fn claimData(&self) -> alloy_contract::SolCallBuilder<&P, claimDataCall, N> { + self.call_builder(&claimDataCall) + } + ///Creates a new call builder for the [`createdAt`] function. + pub fn createdAt(&self) -> alloy_contract::SolCallBuilder<&P, createdAtCall, N> { + self.call_builder(&createdAtCall) + } + ///Creates a new call builder for the [`extraData`] function. + pub fn extraData(&self) -> alloy_contract::SolCallBuilder<&P, extraDataCall, N> { + self.call_builder(&extraDataCall) + } + ///Creates a new call builder for the [`gameCreator`] function. + pub fn gameCreator( + &self, + ) -> alloy_contract::SolCallBuilder<&P, gameCreatorCall, N> { + self.call_builder(&gameCreatorCall) + } + ///Creates a new call builder for the [`gameData`] function. + pub fn gameData(&self) -> alloy_contract::SolCallBuilder<&P, gameDataCall, N> { + self.call_builder(&gameDataCall) + } + ///Creates a new call builder for the [`gameType`] function. + pub fn gameType(&self) -> alloy_contract::SolCallBuilder<&P, gameTypeCall, N> { + self.call_builder(&gameTypeCall) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder(&initializeCall) + } + ///Creates a new call builder for the [`l1Head`] function. + pub fn l1Head(&self) -> alloy_contract::SolCallBuilder<&P, l1HeadCall, N> { + self.call_builder(&l1HeadCall) + } + ///Creates a new call builder for the [`l2SequenceNumber`] function. + pub fn l2SequenceNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2SequenceNumberCall, N> { + self.call_builder(&l2SequenceNumberCall) + } + ///Creates a new call builder for the [`parentIndex`] function. + pub fn parentIndex( + &self, + ) -> alloy_contract::SolCallBuilder<&P, parentIndexCall, N> { + self.call_builder(&parentIndexCall) + } + ///Creates a new call builder for the [`resolve`] function. + pub fn resolve(&self) -> alloy_contract::SolCallBuilder<&P, resolveCall, N> { + self.call_builder(&resolveCall) + } + ///Creates a new call builder for the [`resolvedAt`] function. + pub fn resolvedAt( + &self, + ) -> alloy_contract::SolCallBuilder<&P, resolvedAtCall, N> { + self.call_builder(&resolvedAtCall) + } + ///Creates a new call builder for the [`rootClaim`] function. + pub fn rootClaim(&self) -> alloy_contract::SolCallBuilder<&P, rootClaimCall, N> { + self.call_builder(&rootClaimCall) + } + ///Creates a new call builder for the [`status`] function. + pub fn status(&self) -> alloy_contract::SolCallBuilder<&P, statusCall, N> { + self.call_builder(&statusCall) + } + ///Creates a new call builder for the [`wasRespectedGameTypeWhenCreated`] function. + pub fn wasRespectedGameTypeWhenCreated( + &self, + ) -> alloy_contract::SolCallBuilder<&P, wasRespectedGameTypeWhenCreatedCall, N> { + self.call_builder(&wasRespectedGameTypeWhenCreatedCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > MockPermissionedDisputeGameInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`Resolved`] event. + pub fn Resolved_filter(&self) -> alloy_contract::Event<&P, Resolved, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/mod.rs b/bindings/src/codegen/mod.rs new file mode 100644 index 000000000..9a649c889 --- /dev/null +++ b/bindings/src/codegen/mod.rs @@ -0,0 +1,20 @@ +#![allow(unused_imports, unused_attributes, clippy::all, rustdoc::all)] +//! This module contains the sol! generated bindings for solidity contracts. +//! This is autogenerated code. +//! Do not manually edit these files. +//! These files may be overwritten by the codegen system at any time. +pub mod r#access_manager; +pub mod r#anchor_state_registry; +pub mod r#dispute_game_factory; +pub mod r#erc1967_proxy; +pub mod r#i_anchor_state_registry; +pub mod r#i_dispute_game; +pub mod r#i_dispute_game_factory; +pub mod r#i_fault_dispute_game; +pub mod r#mock_optimism_portal2; +pub mod r#mock_permissioned_dispute_game; +pub mod r#op_succinct_dispute_game; +pub mod r#op_succinct_fault_dispute_game; +pub mod r#op_succinct_l2_output_oracle; +pub mod r#sp1_mock_verifier; +pub mod r#superchain_config; diff --git a/bindings/src/codegen/op_succinct_dispute_game.rs b/bindings/src/codegen/op_succinct_dispute_game.rs new file mode 100644 index 000000000..f604c37ca --- /dev/null +++ b/bindings/src/codegen/op_succinct_dispute_game.rs @@ -0,0 +1,5561 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface OPSuccinctDisputeGame { + type GameStatus is uint8; + type Claim is bytes32; + type GameType is uint32; + type Hash is bytes32; + type Timestamp is uint64; + + error GameNotInProgress(); + + event Resolved(GameStatus indexed status); + + constructor(address _l2OutputOracle, address _anchorStateRegistry); + + function anchorStateRegistry() external view returns (address registry_); + function configName() external pure returns (bytes32 configName_); + function createdAt() external view returns (Timestamp); + function extraData() external pure returns (bytes memory extraData_); + function gameCreator() external pure returns (address); + function gameData() external pure returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); + function gameType() external pure returns (GameType); + function initialize() external payable; + function l1BlockNumber() external pure returns (uint256 l1BlockNumber_); + function l1Head() external pure returns (Hash); + function l2OutputOracle() external view returns (address l2OutputOracle_); + function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); + function proof() external pure returns (bytes memory proof_); + function proverAddress() external pure returns (address proverAddress_); + function resolve() external returns (GameStatus status_); + function resolvedAt() external view returns (Timestamp); + function rootClaim() external pure returns (Claim); + function status() external view returns (GameStatus); + function version() external view returns (string memory); + function wasRespectedGameTypeWhenCreated() external view returns (bool); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_l2OutputOracle", + "type": "address", + "internalType": "address" + }, + { + "name": "_anchorStateRegistry", + "type": "address", + "internalType": "contract IAnchorStateRegistry" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "anchorStateRegistry", + "inputs": [], + "outputs": [ + { + "name": "registry_", + "type": "address", + "internalType": "contract IAnchorStateRegistry" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "configName", + "inputs": [], + "outputs": [ + { + "name": "configName_", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "createdAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "extraData", + "inputs": [], + "outputs": [ + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameCreator", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameData", + "inputs": [], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "rootClaim_", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameType", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint32", + "internalType": "GameType" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "l1BlockNumber", + "inputs": [], + "outputs": [ + { + "name": "l1BlockNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "l1Head", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "Hash" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "l2OutputOracle", + "inputs": [], + "outputs": [ + { + "name": "l2OutputOracle_", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "l2SequenceNumber", + "inputs": [], + "outputs": [ + { + "name": "l2SequenceNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "proof", + "inputs": [], + "outputs": [ + { + "name": "proof_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "proverAddress", + "inputs": [], + "outputs": [ + { + "name": "proverAddress_", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "resolve", + "inputs": [], + "outputs": [ + { + "name": "status_", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "resolvedAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "rootClaim", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "Claim" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "status", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "wasRespectedGameTypeWhenCreated", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "Resolved", + "inputs": [ + { + "name": "status", + "type": "uint8", + "indexed": true, + "internalType": "enum GameStatus" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "GameNotInProgress", + "inputs": [] + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod OPSuccinctDisputeGame { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\xC0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`@Qb\0\x10\xDD8\x03\x80b\0\x10\xDD\x839\x81\x81\x01`@R\x81\x01\x90b\0\x007\x91\x90b\0\x01VV[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x80\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\xA0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPPPPb\0\x01\x9DV[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0b\0\0\xD9\x82b\0\0\xACV[\x90P\x91\x90PV[b\0\0\xEB\x81b\0\0\xCCV[\x81\x14b\0\0\xF7W`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x01\x0B\x81b\0\0\xE0V[\x92\x91PPV[`\0b\0\x01\x1E\x82b\0\0\xCCV[\x90P\x91\x90PV[b\0\x010\x81b\0\x01\x11V[\x81\x14b\0\x01W`\0\x80\xFD[Pa\x03Ga\x08EV[`@Qa\x03T\x91\x90a\n\xD1V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03iW`\0\x80\xFD[Pa\x03ra\x08VV[`@Qa\x03\x7F\x91\x90a\r\x9BV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x94W`\0\x80\xFD[Pa\x03\x9Da\x08_V[`@Qa\x03\xAA\x91\x90a\r\xC5V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xBFW`\0\x80\xFD[Pa\x03\xC8a\x08pV[`@Qa\x03\xD5\x91\x90a\t\xD5V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xEAW`\0\x80\xFD[Pa\x03\xF3a\x08\x88V[`@Qa\x04\x02\x93\x92\x91\x90a\r\xE0V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x17W`\0\x80\xFD[Pa\x04 a\x08\xB0V[`@Qa\x04-\x91\x90a\x0C\xC8V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04BW`\0\x80\xFD[Pa\x04Ka\x08\xD4V[`@Qa\x04X\x91\x90a\x0B-V[`@Q\x80\x91\x03\x90\xF3[`\0`\x08\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0`\x11\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0\x80`\x02\x81\x11\x15a\x04\xB6Wa\x04\xB5a\t\xF0V[[`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x04\xD8Wa\x04\xD7a\t\xF0V[[\x14a\x05\x0FW`@Q\x7Fg\xFE\x19P\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[B`\0`\x08a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x02\x90P\x80`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x05aWa\x05`a\t\xF0V[[\x02\x17\x90U`\x02\x81\x11\x15a\x05wWa\x05va\t\xF0V[[\x7F^\x18o\t\xB9\xC94\x91\xF1N'~\xEA\x7F\xAA]\xE6\xA2\xD4\xBD\xA7Zy\xAFz6\x84\xFB\xFBB\xDA``@Q`@Q\x80\x91\x03\x90\xA2\x90V[`\0a\x05\xB2`ta\x08\xE5V[\x90P\x90V[`\0a\x05\xC3`\0a\x08\xFEV[\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fv4.0.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[```\0`T`\x02\x806\x035`\xF0\x1C\x03\x03\x90Pa\x06o`T\x82a\t\x1AV[\x91PP\x90V[`\0a\x06\x81`4a\tRV[\x90P\x90V[`\0a\x06\x92`\xA8a\tRV[\x90P\x90V[B`\0\x80a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0\x80`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x06\xE4Wa\x06\xE3a\t\xF0V[[\x02\x17\x90UP`\x01`\0`\x11a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA4\xEE\x9D{a\x07Ma\x06\x86V[a\x07]a\x07Xa\x08_V[a\tkV[a\x07ea\x08EV[a\x07ma\x05\xA6V[a\x07ua\x08\xB0V[a\x07}a\x08\xD4V[`@Q\x87c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07\x9E\x96\x95\x94\x93\x92\x91\x90a\x0E\x1EV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x07\xB8W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x07\xCCW=`\0\x80>=`\0\xFD[PPPP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c(\x10\xE1\xD6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81`\0\x87Z\xF1\x15\x80\x15a\x08\x1DW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08A\x91\x90a\x0E\xB0V[PPV[`\0a\x08Q`Ta\x08\xE5V[\x90P\x90V[`\0`\x06\x90P\x90V[`\0a\x08k`\x14a\tRV[\x90P\x90V[`\0\x80T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0\x80``a\x08\x95a\x08VV[\x92Pa\x08\x9Fa\x08_V[\x91Pa\x08\xA9a\x06QV[\x90P\x90\x91\x92V[```\0`\xC8`\x02\x806\x035`\xF0\x1C\x03\x03\x90Pa\x08\xCE`\xC8\x82a\t\x1AV[\x91PP\x90V[`\0a\x08\xE0`\x94a\x08\xFEV[\x90P\x90V[`\0\x80a\x08\xF0a\tuV[\x90P\x82\x81\x015\x91PP\x91\x90PV[`\0\x80a\t\ta\tuV[\x90P\x82\x81\x015``\x1C\x91PP\x91\x90PV[```\0a\t&a\tuV[\x90P`@Q\x91P\x82\x82R\x82\x84\x82\x01` \x84\x017\x82` \x83\x01\x01`\0\x81R` \x81\x01`@RPP\x92\x91PPV[`\0\x80a\t]a\tuV[\x90P\x82\x81\x015\x91PP\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0`\x026\x035`\xF0\x1C6\x03\x90P\x90V[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0a\t\xBFa\t\xBAa\t\xB5\x84a\t\x86V[a\t\x9AV[a\t\x86V[\x90P\x91\x90PV[a\t\xCF\x81a\t\xA4V[\x82RPPV[`\0` \x82\x01\x90Pa\t\xEA`\0\x83\x01\x84a\t\xC6V[\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`!`\x04R`$`\0\xFD[`\x03\x81\x10a\n0Wa\n/a\t\xF0V[[PV[`\0\x81\x90Pa\nA\x82a\n\x1FV[\x91\x90PV[`\0a\nQ\x82a\n3V[\x90P\x91\x90PV[a\na\x81a\nFV[\x82RPPV[`\0` \x82\x01\x90Pa\n|`\0\x83\x01\x84a\nXV[\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\n\x97\x81a\n\x82V[\x82RPPV[`\0` \x82\x01\x90Pa\n\xB2`\0\x83\x01\x84a\n\x8EV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\n\xCB\x81a\n\xB8V[\x82RPPV[`\0` \x82\x01\x90Pa\n\xE6`\0\x83\x01\x84a\n\xC2V[\x92\x91PPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x0B\x17\x82a\n\xECV[\x90P\x91\x90PV[a\x0B'\x81a\x0B\x0CV[\x82RPPV[`\0` \x82\x01\x90Pa\x0BB`\0\x83\x01\x84a\x0B\x1EV[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x0B\x82W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x0BgV[\x83\x81\x11\x15a\x0B\x91W`\0\x84\x84\x01R[PPPPV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x0B\xB3\x82a\x0BHV[a\x0B\xBD\x81\x85a\x0BSV[\x93Pa\x0B\xCD\x81\x85` \x86\x01a\x0BdV[a\x0B\xD6\x81a\x0B\x97V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x0B\xFB\x81\x84a\x0B\xA8V[\x90P\x92\x91PPV[`\0a\x0C\x1Ea\x0C\x19a\x0C\x14\x84a\n\xECV[a\t\x9AV[a\n\xECV[\x90P\x91\x90PV[`\0a\x0C0\x82a\x0C\x03V[\x90P\x91\x90PV[`\0a\x0CB\x82a\x0C%V[\x90P\x91\x90PV[a\x0CR\x81a\x0C7V[\x82RPPV[`\0` \x82\x01\x90Pa\x0Cm`\0\x83\x01\x84a\x0CIV[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0a\x0C\x9A\x82a\x0CsV[a\x0C\xA4\x81\x85a\x0C~V[\x93Pa\x0C\xB4\x81\x85` \x86\x01a\x0BdV[a\x0C\xBD\x81a\x0B\x97V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x0C\xE2\x81\x84a\x0C\x8FV[\x90P\x92\x91PPV[`\0\x81\x90P\x91\x90PV[`\0a\x0C\xFF\x82a\x0C\xEAV[\x90P\x91\x90PV[a\r\x0F\x81a\x0C\xF4V[\x82RPPV[`\0` \x82\x01\x90Pa\r*`\0\x83\x01\x84a\r\x06V[\x92\x91PPV[a\r9\x81a\x0C\xEAV[\x82RPPV[`\0` \x82\x01\x90Pa\rT`\0\x83\x01\x84a\r0V[\x92\x91PPV[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\r\x85a\r\x80a\r{\x84a\rZV[a\t\x9AV[a\rZV[\x90P\x91\x90PV[a\r\x95\x81a\rjV[\x82RPPV[`\0` \x82\x01\x90Pa\r\xB0`\0\x83\x01\x84a\r\x8CV[\x92\x91PPV[a\r\xBF\x81a\x0C\xF4V[\x82RPPV[`\0` \x82\x01\x90Pa\r\xDA`\0\x83\x01\x84a\r\xB6V[\x92\x91PPV[`\0``\x82\x01\x90Pa\r\xF5`\0\x83\x01\x86a\r\x8CV[a\x0E\x02` \x83\x01\x85a\r\xB6V[\x81\x81\x03`@\x83\x01Ra\x0E\x14\x81\x84a\x0C\x8FV[\x90P\x94\x93PPPPV[`\0`\xC0\x82\x01\x90Pa\x0E3`\0\x83\x01\x89a\r0V[a\x0E@` \x83\x01\x88a\r0V[a\x0EM`@\x83\x01\x87a\n\xC2V[a\x0EZ``\x83\x01\x86a\n\xC2V[\x81\x81\x03`\x80\x83\x01Ra\x0El\x81\x85a\x0C\x8FV[\x90Pa\x0E{`\xA0\x83\x01\x84a\x0B\x1EV[\x97\x96PPPPPPPV[`\0\x80\xFD[`\x03\x81\x10a\x0E\x98W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0E\xAA\x81a\x0E\x8BV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x0E\xC6Wa\x0E\xC5a\x0E\x86V[[`\0a\x0E\xD4\x84\x82\x85\x01a\x0E\x9BV[\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 l<\x92\xB8\x865\x98\x86\x1EU\xD6q\x13RZ\t\xCBT\xA2P!M\xB9VN\xED5\x86\x86G\x0F\x04dsolcC\0\x08\x0F\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R`\x046\x10a\x01\x1FW`\x005`\xE0\x1C\x80ccaPm\x11a\0\xA0W\x80c\xBC\xEF;U\x11a\0dW\x80c\xBC\xEF;U\x14a\x03\x88W\x80c\xCF\t\xE0\xD0\x14a\x03\xB3W\x80c\xFA$\xF7C\x14a\x03\xDEW\x80c\xFA\xF9$\xCF\x14a\x04\x0BW\x80c\xFFU\x99\xEC\x14a\x046Wa\x01\x1FV[\x80ccaPm\x14a\x02\xD2W\x80c{\xEDt\x93\x14a\x02\xFDW\x80c\x81)\xFC\x1C\x14a\x03(W\x80c\x99s^2\x14a\x032W\x80c\xBB\xDC\x02\xDB\x14a\x03]Wa\x01\x1FV[\x80c7\xB1\xB2)\x11a\0\xE7W\x80c7\xB1\xB2)\x14a\x01\xFBW\x80cM\x9F\x15Y\x14a\x02&W\x80cT\xFDMP\x14a\x02QW\x80c\\\x0C\xBA3\x14a\x02|W\x80c`\x9D34\x14a\x02\xA7Wa\x01\x1FV[\x80c\x19\xEF\xFE\xB4\x14a\x01$W\x80c \r.\xD2\x14a\x01OW\x80c%\x0Ei\xBD\x14a\x01zW\x80c(\x10\xE1\xD6\x14a\x01\xA5W\x80c)\x8C\x90\x05\x14a\x01\xD0W[`\0\x80\xFD[4\x80\x15a\x010W`\0\x80\xFD[Pa\x019a\x04aV[`@Qa\x01F\x91\x90a\t\xD5V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01[W`\0\x80\xFD[Pa\x01da\x04{V[`@Qa\x01q\x91\x90a\ngV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x86W`\0\x80\xFD[Pa\x01\x8Fa\x04\x8EV[`@Qa\x01\x9C\x91\x90a\n\x9DV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xB1W`\0\x80\xFD[Pa\x01\xBAa\x04\xA1V[`@Qa\x01\xC7\x91\x90a\ngV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xDCW`\0\x80\xFD[Pa\x01\xE5a\x05\xA6V[`@Qa\x01\xF2\x91\x90a\n\xD1V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\x07W`\0\x80\xFD[Pa\x02\x10a\x05\xB7V[`@Qa\x02\x1D\x91\x90a\x0B-V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x022W`\0\x80\xFD[Pa\x02;a\x05\xC8V[`@Qa\x02H\x91\x90a\x0B-V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02]W`\0\x80\xFD[Pa\x02fa\x05\xF0V[`@Qa\x02s\x91\x90a\x0B\xE1V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\x88W`\0\x80\xFD[Pa\x02\x91a\x06)V[`@Qa\x02\x9E\x91\x90a\x0CXV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xB3W`\0\x80\xFD[Pa\x02\xBCa\x06QV[`@Qa\x02\xC9\x91\x90a\x0C\xC8V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xDEW`\0\x80\xFD[Pa\x02\xE7a\x06uV[`@Qa\x02\xF4\x91\x90a\r\x15V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\tW`\0\x80\xFD[Pa\x03\x12a\x06\x86V[`@Qa\x03\x1F\x91\x90a\r?V[`@Q\x80\x91\x03\x90\xF3[a\x030a\x06\x97V[\0[4\x80\x15a\x03>W`\0\x80\xFD[Pa\x03Ga\x08EV[`@Qa\x03T\x91\x90a\n\xD1V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03iW`\0\x80\xFD[Pa\x03ra\x08VV[`@Qa\x03\x7F\x91\x90a\r\x9BV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x94W`\0\x80\xFD[Pa\x03\x9Da\x08_V[`@Qa\x03\xAA\x91\x90a\r\xC5V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xBFW`\0\x80\xFD[Pa\x03\xC8a\x08pV[`@Qa\x03\xD5\x91\x90a\t\xD5V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xEAW`\0\x80\xFD[Pa\x03\xF3a\x08\x88V[`@Qa\x04\x02\x93\x92\x91\x90a\r\xE0V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x17W`\0\x80\xFD[Pa\x04 a\x08\xB0V[`@Qa\x04-\x91\x90a\x0C\xC8V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04BW`\0\x80\xFD[Pa\x04Ka\x08\xD4V[`@Qa\x04X\x91\x90a\x0B-V[`@Q\x80\x91\x03\x90\xF3[`\0`\x08\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0`\x11\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0\x80`\x02\x81\x11\x15a\x04\xB6Wa\x04\xB5a\t\xF0V[[`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x04\xD8Wa\x04\xD7a\t\xF0V[[\x14a\x05\x0FW`@Q\x7Fg\xFE\x19P\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[B`\0`\x08a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x02\x90P\x80`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x05aWa\x05`a\t\xF0V[[\x02\x17\x90U`\x02\x81\x11\x15a\x05wWa\x05va\t\xF0V[[\x7F^\x18o\t\xB9\xC94\x91\xF1N'~\xEA\x7F\xAA]\xE6\xA2\xD4\xBD\xA7Zy\xAFz6\x84\xFB\xFBB\xDA``@Q`@Q\x80\x91\x03\x90\xA2\x90V[`\0a\x05\xB2`ta\x08\xE5V[\x90P\x90V[`\0a\x05\xC3`\0a\x08\xFEV[\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fv4.0.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[```\0`T`\x02\x806\x035`\xF0\x1C\x03\x03\x90Pa\x06o`T\x82a\t\x1AV[\x91PP\x90V[`\0a\x06\x81`4a\tRV[\x90P\x90V[`\0a\x06\x92`\xA8a\tRV[\x90P\x90V[B`\0\x80a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0\x80`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x06\xE4Wa\x06\xE3a\t\xF0V[[\x02\x17\x90UP`\x01`\0`\x11a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xA4\xEE\x9D{a\x07Ma\x06\x86V[a\x07]a\x07Xa\x08_V[a\tkV[a\x07ea\x08EV[a\x07ma\x05\xA6V[a\x07ua\x08\xB0V[a\x07}a\x08\xD4V[`@Q\x87c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07\x9E\x96\x95\x94\x93\x92\x91\x90a\x0E\x1EV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x07\xB8W`\0\x80\xFD[PZ\xF1\x15\x80\x15a\x07\xCCW=`\0\x80>=`\0\xFD[PPPP0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c(\x10\xE1\xD6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81`\0\x87Z\xF1\x15\x80\x15a\x08\x1DW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08A\x91\x90a\x0E\xB0V[PPV[`\0a\x08Q`Ta\x08\xE5V[\x90P\x90V[`\0`\x06\x90P\x90V[`\0a\x08k`\x14a\tRV[\x90P\x90V[`\0\x80T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0\x80``a\x08\x95a\x08VV[\x92Pa\x08\x9Fa\x08_V[\x91Pa\x08\xA9a\x06QV[\x90P\x90\x91\x92V[```\0`\xC8`\x02\x806\x035`\xF0\x1C\x03\x03\x90Pa\x08\xCE`\xC8\x82a\t\x1AV[\x91PP\x90V[`\0a\x08\xE0`\x94a\x08\xFEV[\x90P\x90V[`\0\x80a\x08\xF0a\tuV[\x90P\x82\x81\x015\x91PP\x91\x90PV[`\0\x80a\t\ta\tuV[\x90P\x82\x81\x015``\x1C\x91PP\x91\x90PV[```\0a\t&a\tuV[\x90P`@Q\x91P\x82\x82R\x82\x84\x82\x01` \x84\x017\x82` \x83\x01\x01`\0\x81R` \x81\x01`@RPP\x92\x91PPV[`\0\x80a\t]a\tuV[\x90P\x82\x81\x015\x91PP\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0`\x026\x035`\xF0\x1C6\x03\x90P\x90V[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0\x81\x90P\x91\x90PV[`\0a\t\xBFa\t\xBAa\t\xB5\x84a\t\x86V[a\t\x9AV[a\t\x86V[\x90P\x91\x90PV[a\t\xCF\x81a\t\xA4V[\x82RPPV[`\0` \x82\x01\x90Pa\t\xEA`\0\x83\x01\x84a\t\xC6V[\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`!`\x04R`$`\0\xFD[`\x03\x81\x10a\n0Wa\n/a\t\xF0V[[PV[`\0\x81\x90Pa\nA\x82a\n\x1FV[\x91\x90PV[`\0a\nQ\x82a\n3V[\x90P\x91\x90PV[a\na\x81a\nFV[\x82RPPV[`\0` \x82\x01\x90Pa\n|`\0\x83\x01\x84a\nXV[\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\n\x97\x81a\n\x82V[\x82RPPV[`\0` \x82\x01\x90Pa\n\xB2`\0\x83\x01\x84a\n\x8EV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\n\xCB\x81a\n\xB8V[\x82RPPV[`\0` \x82\x01\x90Pa\n\xE6`\0\x83\x01\x84a\n\xC2V[\x92\x91PPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\x0B\x17\x82a\n\xECV[\x90P\x91\x90PV[a\x0B'\x81a\x0B\x0CV[\x82RPPV[`\0` \x82\x01\x90Pa\x0BB`\0\x83\x01\x84a\x0B\x1EV[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x0B\x82W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x0BgV[\x83\x81\x11\x15a\x0B\x91W`\0\x84\x84\x01R[PPPPV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x0B\xB3\x82a\x0BHV[a\x0B\xBD\x81\x85a\x0BSV[\x93Pa\x0B\xCD\x81\x85` \x86\x01a\x0BdV[a\x0B\xD6\x81a\x0B\x97V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x0B\xFB\x81\x84a\x0B\xA8V[\x90P\x92\x91PPV[`\0a\x0C\x1Ea\x0C\x19a\x0C\x14\x84a\n\xECV[a\t\x9AV[a\n\xECV[\x90P\x91\x90PV[`\0a\x0C0\x82a\x0C\x03V[\x90P\x91\x90PV[`\0a\x0CB\x82a\x0C%V[\x90P\x91\x90PV[a\x0CR\x81a\x0C7V[\x82RPPV[`\0` \x82\x01\x90Pa\x0Cm`\0\x83\x01\x84a\x0CIV[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0a\x0C\x9A\x82a\x0CsV[a\x0C\xA4\x81\x85a\x0C~V[\x93Pa\x0C\xB4\x81\x85` \x86\x01a\x0BdV[a\x0C\xBD\x81a\x0B\x97V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x0C\xE2\x81\x84a\x0C\x8FV[\x90P\x92\x91PPV[`\0\x81\x90P\x91\x90PV[`\0a\x0C\xFF\x82a\x0C\xEAV[\x90P\x91\x90PV[a\r\x0F\x81a\x0C\xF4V[\x82RPPV[`\0` \x82\x01\x90Pa\r*`\0\x83\x01\x84a\r\x06V[\x92\x91PPV[a\r9\x81a\x0C\xEAV[\x82RPPV[`\0` \x82\x01\x90Pa\rT`\0\x83\x01\x84a\r0V[\x92\x91PPV[`\0c\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\r\x85a\r\x80a\r{\x84a\rZV[a\t\x9AV[a\rZV[\x90P\x91\x90PV[a\r\x95\x81a\rjV[\x82RPPV[`\0` \x82\x01\x90Pa\r\xB0`\0\x83\x01\x84a\r\x8CV[\x92\x91PPV[a\r\xBF\x81a\x0C\xF4V[\x82RPPV[`\0` \x82\x01\x90Pa\r\xDA`\0\x83\x01\x84a\r\xB6V[\x92\x91PPV[`\0``\x82\x01\x90Pa\r\xF5`\0\x83\x01\x86a\r\x8CV[a\x0E\x02` \x83\x01\x85a\r\xB6V[\x81\x81\x03`@\x83\x01Ra\x0E\x14\x81\x84a\x0C\x8FV[\x90P\x94\x93PPPPV[`\0`\xC0\x82\x01\x90Pa\x0E3`\0\x83\x01\x89a\r0V[a\x0E@` \x83\x01\x88a\r0V[a\x0EM`@\x83\x01\x87a\n\xC2V[a\x0EZ``\x83\x01\x86a\n\xC2V[\x81\x81\x03`\x80\x83\x01Ra\x0El\x81\x85a\x0C\x8FV[\x90Pa\x0E{`\xA0\x83\x01\x84a\x0B\x1EV[\x97\x96PPPPPPPV[`\0\x80\xFD[`\x03\x81\x10a\x0E\x98W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x0E\xAA\x81a\x0E\x8BV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x0E\xC6Wa\x0E\xC5a\x0E\x86V[[`\0a\x0E\xD4\x84\x82\x85\x01a\x0E\x9BV[\x91PP\x92\x91PPV\xFE\xA2dipfsX\"\x12 l<\x92\xB8\x865\x98\x86\x1EU\xD6q\x13RZ\t\xCBT\xA2P!M\xB9VN\xED5\x86\x86G\x0F\x04dsolcC\0\x08\x0F\x003", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameStatus(u8); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u8 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<8>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameStatus { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u8) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u8 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameStatus { + fn from(value: u8) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u8 { + fn from(value: GameStatus) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameStatus { + type RustType = u8; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameStatus { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Claim(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Claim { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Claim { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Claim) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Claim { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Claim { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Hash(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Hash { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Hash { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Hash) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Hash { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Hash { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Timestamp(u64); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u64 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<64>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Timestamp { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u64) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u64 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Timestamp { + fn from(value: u64) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u64 { + fn from(value: Timestamp) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Timestamp { + type RustType = u64; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Timestamp { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**Custom error with signature `GameNotInProgress()` and selector `0x67fe1950`. +```solidity +error GameNotInProgress(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameNotInProgress; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameNotInProgress) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameNotInProgress { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameNotInProgress { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameNotInProgress()"; + const SELECTOR: [u8; 4] = [103u8, 254u8, 25u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Event with signature `Resolved(uint8)` and selector `0x5e186f09b9c93491f14e277eea7faa5de6a2d4bda75a79af7a3684fbfb42da60`. +```solidity +event Resolved(GameStatus indexed status); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Resolved { + #[allow(missing_docs)] + pub status: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Resolved { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>, GameStatus); + const SIGNATURE: &'static str = "Resolved(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { status: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.status.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.status, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Resolved { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Resolved> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Resolved) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _l2OutputOracle, address _anchorStateRegistry); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _l2OutputOracle: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _anchorStateRegistry: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._l2OutputOracle, value._anchorStateRegistry) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _l2OutputOracle: tuple.0, + _anchorStateRegistry: tuple.1, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._l2OutputOracle, + ), + ::tokenize( + &self._anchorStateRegistry, + ), + ) + } + } + }; + /**Function with signature `anchorStateRegistry()` and selector `0x5c0cba33`. +```solidity +function anchorStateRegistry() external view returns (address registry_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorStateRegistryCall; + ///Container type for the return parameters of the [`anchorStateRegistry()`](anchorStateRegistryCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorStateRegistryReturn { + #[allow(missing_docs)] + pub registry_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: anchorStateRegistryCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for anchorStateRegistryCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: anchorStateRegistryReturn) -> Self { + (value.registry_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for anchorStateRegistryReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { registry_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for anchorStateRegistryCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "anchorStateRegistry()"; + const SELECTOR: [u8; 4] = [92u8, 12u8, 186u8, 51u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: anchorStateRegistryReturn = r.into(); + r.registry_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: anchorStateRegistryReturn = r.into(); + r.registry_ + }) + } + } + }; + /**Function with signature `configName()` and selector `0x7bed7493`. +```solidity +function configName() external pure returns (bytes32 configName_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct configNameCall; + ///Container type for the return parameters of the [`configName()`](configNameCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct configNameReturn { + #[allow(missing_docs)] + pub configName_: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: configNameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for configNameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: configNameReturn) -> Self { + (value.configName_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for configNameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { configName_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for configNameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "configName()"; + const SELECTOR: [u8; 4] = [123u8, 237u8, 116u8, 147u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: configNameReturn = r.into(); + r.configName_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: configNameReturn = r.into(); + r.configName_ + }) + } + } + }; + /**Function with signature `createdAt()` and selector `0xcf09e0d0`. +```solidity +function createdAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtCall; + ///Container type for the return parameters of the [`createdAt()`](createdAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createdAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "createdAt()"; + const SELECTOR: [u8; 4] = [207u8, 9u8, 224u8, 208u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `extraData()` and selector `0x609d3334`. +```solidity +function extraData() external pure returns (bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataCall; + ///Container type for the return parameters of the [`extraData()`](extraDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataReturn { + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataReturn) -> Self { + (value.extraData_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { extraData_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for extraDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Bytes; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "extraData()"; + const SELECTOR: [u8; 4] = [96u8, 157u8, 51u8, 52u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + } + }; + /**Function with signature `gameCreator()` and selector `0x37b1b229`. +```solidity +function gameCreator() external pure returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorCall; + ///Container type for the return parameters of the [`gameCreator()`](gameCreatorCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameCreatorCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameCreator()"; + const SELECTOR: [u8; 4] = [55u8, 177u8, 178u8, 41u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `gameData()` and selector `0xfa24f743`. +```solidity +function gameData() external pure returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataCall; + ///Container type for the return parameters of the [`gameData()`](gameDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + #[allow(missing_docs)] + pub rootClaim_: ::RustType, + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataReturn) -> Self { + (value.gameType_, value.rootClaim_, value.extraData_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + gameType_: tuple.0, + rootClaim_: tuple.1, + extraData_: tuple.2, + } + } + } + } + impl gameDataReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.gameType_), + ::tokenize(&self.rootClaim_), + ::tokenize( + &self.extraData_, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = gameDataReturn; + type ReturnTuple<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameData()"; + const SELECTOR: [u8; 4] = [250u8, 36u8, 247u8, 67u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + gameDataReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `gameType()` and selector `0xbbdc02db`. +```solidity +function gameType() external pure returns (GameType); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeCall; + ///Container type for the return parameters of the [`gameType()`](gameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameTypeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameType,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameType()"; + const SELECTOR: [u8; 4] = [187u8, 220u8, 2u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initialize()` and selector `0x8129fc1c`. +```solidity +function initialize() external payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall; + ///Container type for the return parameters of the [`initialize()`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize()"; + const SELECTOR: [u8; 4] = [129u8, 41u8, 252u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `l1BlockNumber()` and selector `0x298c9005`. +```solidity +function l1BlockNumber() external pure returns (uint256 l1BlockNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1BlockNumberCall; + ///Container type for the return parameters of the [`l1BlockNumber()`](l1BlockNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1BlockNumberReturn { + #[allow(missing_docs)] + pub l1BlockNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1BlockNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1BlockNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1BlockNumberReturn) -> Self { + (value.l1BlockNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1BlockNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l1BlockNumber_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l1BlockNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l1BlockNumber()"; + const SELECTOR: [u8; 4] = [41u8, 140u8, 144u8, 5u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l1BlockNumberReturn = r.into(); + r.l1BlockNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l1BlockNumberReturn = r.into(); + r.l1BlockNumber_ + }) + } + } + }; + /**Function with signature `l1Head()` and selector `0x6361506d`. +```solidity +function l1Head() external pure returns (Hash); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadCall; + ///Container type for the return parameters of the [`l1Head()`](l1HeadCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l1HeadCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Hash,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l1Head()"; + const SELECTOR: [u8; 4] = [99u8, 97u8, 80u8, 109u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `l2OutputOracle()` and selector `0x4d9f1559`. +```solidity +function l2OutputOracle() external view returns (address l2OutputOracle_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2OutputOracleCall; + ///Container type for the return parameters of the [`l2OutputOracle()`](l2OutputOracleCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2OutputOracleReturn { + #[allow(missing_docs)] + pub l2OutputOracle_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l2OutputOracleCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l2OutputOracleCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2OutputOracleReturn) -> Self { + (value.l2OutputOracle_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2OutputOracleReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l2OutputOracle_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2OutputOracleCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2OutputOracle()"; + const SELECTOR: [u8; 4] = [77u8, 159u8, 21u8, 89u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2OutputOracleReturn = r.into(); + r.l2OutputOracle_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2OutputOracleReturn = r.into(); + r.l2OutputOracle_ + }) + } + } + }; + /**Function with signature `l2SequenceNumber()` and selector `0x99735e32`. +```solidity +function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberCall; + ///Container type for the return parameters of the [`l2SequenceNumber()`](l2SequenceNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberReturn { + #[allow(missing_docs)] + pub l2SequenceNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberReturn) -> Self { + (value.l2SequenceNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l2SequenceNumber_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2SequenceNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2SequenceNumber()"; + const SELECTOR: [u8; 4] = [153u8, 115u8, 94u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + } + }; + /**Function with signature `proof()` and selector `0xfaf924cf`. +```solidity +function proof() external pure returns (bytes memory proof_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofCall; + ///Container type for the return parameters of the [`proof()`](proofCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofReturn { + #[allow(missing_docs)] + pub proof_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proofCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proofCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proofReturn) -> Self { + (value.proof_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proofReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { proof_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proofCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Bytes; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proof()"; + const SELECTOR: [u8; 4] = [250u8, 249u8, 36u8, 207u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proofReturn = r.into(); + r.proof_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proofReturn = r.into(); + r.proof_ + }) + } + } + }; + /**Function with signature `proverAddress()` and selector `0xff5599ec`. +```solidity +function proverAddress() external pure returns (address proverAddress_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proverAddressCall; + ///Container type for the return parameters of the [`proverAddress()`](proverAddressCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proverAddressReturn { + #[allow(missing_docs)] + pub proverAddress_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proverAddressCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proverAddressCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proverAddressReturn) -> Self { + (value.proverAddress_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proverAddressReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { proverAddress_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proverAddressCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proverAddress()"; + const SELECTOR: [u8; 4] = [255u8, 85u8, 153u8, 236u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proverAddressReturn = r.into(); + r.proverAddress_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proverAddressReturn = r.into(); + r.proverAddress_ + }) + } + } + }; + /**Function with signature `resolve()` and selector `0x2810e1d6`. +```solidity +function resolve() external returns (GameStatus status_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveCall; + ///Container type for the return parameters of the [`resolve()`](resolveCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveReturn { + #[allow(missing_docs)] + pub status_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveReturn) -> Self { + (value.status_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { status_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolveCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolve()"; + const SELECTOR: [u8; 4] = [40u8, 16u8, 225u8, 214u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolveReturn = r.into(); + r.status_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolveReturn = r.into(); + r.status_ + }) + } + } + }; + /**Function with signature `resolvedAt()` and selector `0x19effeb4`. +```solidity +function resolvedAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtCall; + ///Container type for the return parameters of the [`resolvedAt()`](resolvedAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolvedAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolvedAt()"; + const SELECTOR: [u8; 4] = [25u8, 239u8, 254u8, 180u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `rootClaim()` and selector `0xbcef3b55`. +```solidity +function rootClaim() external pure returns (Claim); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimCall; + ///Container type for the return parameters of the [`rootClaim()`](rootClaimCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Claim,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for rootClaimCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Claim,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "rootClaim()"; + const SELECTOR: [u8; 4] = [188u8, 239u8, 59u8, 85u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `status()` and selector `0x200d2ed2`. +```solidity +function status() external view returns (GameStatus); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusCall; + ///Container type for the return parameters of the [`status()`](statusCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for statusCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "status()"; + const SELECTOR: [u8; 4] = [32u8, 13u8, 46u8, 210u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `version()` and selector `0x54fd4d50`. +```solidity +function version() external view returns (string memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionCall; + ///Container type for the return parameters of the [`version()`](versionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for versionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "version()"; + const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `wasRespectedGameTypeWhenCreated()` and selector `0x250e69bd`. +```solidity +function wasRespectedGameTypeWhenCreated() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedCall; + ///Container type for the return parameters of the [`wasRespectedGameTypeWhenCreated()`](wasRespectedGameTypeWhenCreatedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for wasRespectedGameTypeWhenCreatedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "wasRespectedGameTypeWhenCreated()"; + const SELECTOR: [u8; 4] = [37u8, 14u8, 105u8, 189u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`OPSuccinctDisputeGame`](self) function calls. + #[derive(Clone)] + pub enum OPSuccinctDisputeGameCalls { + #[allow(missing_docs)] + anchorStateRegistry(anchorStateRegistryCall), + #[allow(missing_docs)] + configName(configNameCall), + #[allow(missing_docs)] + createdAt(createdAtCall), + #[allow(missing_docs)] + extraData(extraDataCall), + #[allow(missing_docs)] + gameCreator(gameCreatorCall), + #[allow(missing_docs)] + gameData(gameDataCall), + #[allow(missing_docs)] + gameType(gameTypeCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + l1BlockNumber(l1BlockNumberCall), + #[allow(missing_docs)] + l1Head(l1HeadCall), + #[allow(missing_docs)] + l2OutputOracle(l2OutputOracleCall), + #[allow(missing_docs)] + l2SequenceNumber(l2SequenceNumberCall), + #[allow(missing_docs)] + proof(proofCall), + #[allow(missing_docs)] + proverAddress(proverAddressCall), + #[allow(missing_docs)] + resolve(resolveCall), + #[allow(missing_docs)] + resolvedAt(resolvedAtCall), + #[allow(missing_docs)] + rootClaim(rootClaimCall), + #[allow(missing_docs)] + status(statusCall), + #[allow(missing_docs)] + version(versionCall), + #[allow(missing_docs)] + wasRespectedGameTypeWhenCreated(wasRespectedGameTypeWhenCreatedCall), + } + impl OPSuccinctDisputeGameCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [25u8, 239u8, 254u8, 180u8], + [32u8, 13u8, 46u8, 210u8], + [37u8, 14u8, 105u8, 189u8], + [40u8, 16u8, 225u8, 214u8], + [41u8, 140u8, 144u8, 5u8], + [55u8, 177u8, 178u8, 41u8], + [77u8, 159u8, 21u8, 89u8], + [84u8, 253u8, 77u8, 80u8], + [92u8, 12u8, 186u8, 51u8], + [96u8, 157u8, 51u8, 52u8], + [99u8, 97u8, 80u8, 109u8], + [123u8, 237u8, 116u8, 147u8], + [129u8, 41u8, 252u8, 28u8], + [153u8, 115u8, 94u8, 50u8], + [187u8, 220u8, 2u8, 219u8], + [188u8, 239u8, 59u8, 85u8], + [207u8, 9u8, 224u8, 208u8], + [250u8, 36u8, 247u8, 67u8], + [250u8, 249u8, 36u8, 207u8], + [255u8, 85u8, 153u8, 236u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(resolvedAt), + ::core::stringify!(status), + ::core::stringify!(wasRespectedGameTypeWhenCreated), + ::core::stringify!(resolve), + ::core::stringify!(l1BlockNumber), + ::core::stringify!(gameCreator), + ::core::stringify!(l2OutputOracle), + ::core::stringify!(version), + ::core::stringify!(anchorStateRegistry), + ::core::stringify!(extraData), + ::core::stringify!(l1Head), + ::core::stringify!(configName), + ::core::stringify!(initialize), + ::core::stringify!(l2SequenceNumber), + ::core::stringify!(gameType), + ::core::stringify!(rootClaim), + ::core::stringify!(createdAt), + ::core::stringify!(gameData), + ::core::stringify!(proof), + ::core::stringify!(proverAddress), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for OPSuccinctDisputeGameCalls { + const NAME: &'static str = "OPSuccinctDisputeGameCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 20usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::anchorStateRegistry(_) => { + ::SELECTOR + } + Self::configName(_) => { + ::SELECTOR + } + Self::createdAt(_) => { + ::SELECTOR + } + Self::extraData(_) => { + ::SELECTOR + } + Self::gameCreator(_) => { + ::SELECTOR + } + Self::gameData(_) => ::SELECTOR, + Self::gameType(_) => ::SELECTOR, + Self::initialize(_) => { + ::SELECTOR + } + Self::l1BlockNumber(_) => { + ::SELECTOR + } + Self::l1Head(_) => ::SELECTOR, + Self::l2OutputOracle(_) => { + ::SELECTOR + } + Self::l2SequenceNumber(_) => { + ::SELECTOR + } + Self::proof(_) => ::SELECTOR, + Self::proverAddress(_) => { + ::SELECTOR + } + Self::resolve(_) => ::SELECTOR, + Self::resolvedAt(_) => { + ::SELECTOR + } + Self::rootClaim(_) => { + ::SELECTOR + } + Self::status(_) => ::SELECTOR, + Self::version(_) => ::SELECTOR, + Self::wasRespectedGameTypeWhenCreated(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::status) + } + status + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + OPSuccinctDisputeGameCalls::wasRespectedGameTypeWhenCreated, + ) + } + wasRespectedGameTypeWhenCreated + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::resolve) + } + resolve + }, + { + fn l1BlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameCalls::l1BlockNumber) + } + l1BlockNumber + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn l2OutputOracle( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameCalls::l2OutputOracle) + } + l2OutputOracle + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::version) + } + version + }, + { + fn anchorStateRegistry( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameCalls::anchorStateRegistry) + } + anchorStateRegistry + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::extraData) + } + extraData + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn configName( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameCalls::configName) + } + configName + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameCalls::initialize) + } + initialize + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::gameType) + } + gameType + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::gameData) + } + gameData + }, + { + fn proof( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctDisputeGameCalls::proof) + } + proof + }, + { + fn proverAddress( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameCalls::proverAddress) + } + proverAddress + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::status) + } + status + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + OPSuccinctDisputeGameCalls::wasRespectedGameTypeWhenCreated, + ) + } + wasRespectedGameTypeWhenCreated + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::resolve) + } + resolve + }, + { + fn l1BlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::l1BlockNumber) + } + l1BlockNumber + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn l2OutputOracle( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::l2OutputOracle) + } + l2OutputOracle + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::version) + } + version + }, + { + fn anchorStateRegistry( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::anchorStateRegistry) + } + anchorStateRegistry + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::extraData) + } + extraData + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn configName( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::configName) + } + configName + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::initialize) + } + initialize + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::gameType) + } + gameType + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::gameData) + } + gameData + }, + { + fn proof( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::proof) + } + proof + }, + { + fn proverAddress( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameCalls::proverAddress) + } + proverAddress + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::anchorStateRegistry(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::configName(inner) => { + ::abi_encoded_size(inner) + } + Self::createdAt(inner) => { + ::abi_encoded_size(inner) + } + Self::extraData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameCreator(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::gameData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameType(inner) => { + ::abi_encoded_size(inner) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::l1BlockNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::l1Head(inner) => { + ::abi_encoded_size(inner) + } + Self::l2OutputOracle(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::l2SequenceNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::proof(inner) => { + ::abi_encoded_size(inner) + } + Self::proverAddress(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::resolve(inner) => { + ::abi_encoded_size(inner) + } + Self::resolvedAt(inner) => { + ::abi_encoded_size(inner) + } + Self::rootClaim(inner) => { + ::abi_encoded_size(inner) + } + Self::status(inner) => { + ::abi_encoded_size(inner) + } + Self::version(inner) => { + ::abi_encoded_size(inner) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::anchorStateRegistry(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::configName(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::createdAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::extraData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameCreator(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l1BlockNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l1Head(inner) => { + ::abi_encode_raw(inner, out) + } + Self::l2OutputOracle(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l2SequenceNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proof(inner) => { + ::abi_encode_raw(inner, out) + } + Self::proverAddress(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::resolve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::resolvedAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::rootClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::status(inner) => { + ::abi_encode_raw(inner, out) + } + Self::version(inner) => { + ::abi_encode_raw(inner, out) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`OPSuccinctDisputeGame`](self) custom errors. + #[derive(Clone)] + pub enum OPSuccinctDisputeGameErrors { + #[allow(missing_docs)] + GameNotInProgress(GameNotInProgress), + } + impl OPSuccinctDisputeGameErrors { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[[103u8, 254u8, 25u8, 80u8]]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(GameNotInProgress), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for OPSuccinctDisputeGameErrors { + const NAME: &'static str = "OPSuccinctDisputeGameErrors"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 1usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::GameNotInProgress(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn GameNotInProgress( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctDisputeGameErrors::GameNotInProgress) + } + GameNotInProgress + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn GameNotInProgress( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctDisputeGameErrors::GameNotInProgress) + } + GameNotInProgress + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::GameNotInProgress(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::GameNotInProgress(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`OPSuccinctDisputeGame`](self) events. + #[derive(Clone)] + pub enum OPSuccinctDisputeGameEvents { + #[allow(missing_docs)] + Resolved(Resolved), + } + impl OPSuccinctDisputeGameEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(Resolved), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for OPSuccinctDisputeGameEvents { + const NAME: &'static str = "OPSuccinctDisputeGameEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Resolved) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OPSuccinctDisputeGameEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`OPSuccinctDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`OPSuccinctDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> OPSuccinctDisputeGameInstance { + OPSuccinctDisputeGameInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _l2OutputOracle: alloy::sol_types::private::Address, + _anchorStateRegistry: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + OPSuccinctDisputeGameInstance::< + P, + N, + >::deploy(__provider, _l2OutputOracle, _anchorStateRegistry) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _l2OutputOracle: alloy::sol_types::private::Address, + _anchorStateRegistry: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + OPSuccinctDisputeGameInstance::< + P, + N, + >::deploy_builder(__provider, _l2OutputOracle, _anchorStateRegistry) + } + /**A [`OPSuccinctDisputeGame`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`OPSuccinctDisputeGame`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct OPSuccinctDisputeGameInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for OPSuccinctDisputeGameInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("OPSuccinctDisputeGameInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OPSuccinctDisputeGameInstance { + /**Creates a new wrapper around an on-chain [`OPSuccinctDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`OPSuccinctDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + _l2OutputOracle: alloy::sol_types::private::Address, + _anchorStateRegistry: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + __provider, + _l2OutputOracle, + _anchorStateRegistry, + ); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder( + __provider: P, + _l2OutputOracle: alloy::sol_types::private::Address, + _anchorStateRegistry: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _l2OutputOracle, + _anchorStateRegistry, + }, + )[..], + ] + .concat() + .into(), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl OPSuccinctDisputeGameInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> OPSuccinctDisputeGameInstance { + OPSuccinctDisputeGameInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OPSuccinctDisputeGameInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`anchorStateRegistry`] function. + pub fn anchorStateRegistry( + &self, + ) -> alloy_contract::SolCallBuilder<&P, anchorStateRegistryCall, N> { + self.call_builder(&anchorStateRegistryCall) + } + ///Creates a new call builder for the [`configName`] function. + pub fn configName( + &self, + ) -> alloy_contract::SolCallBuilder<&P, configNameCall, N> { + self.call_builder(&configNameCall) + } + ///Creates a new call builder for the [`createdAt`] function. + pub fn createdAt(&self) -> alloy_contract::SolCallBuilder<&P, createdAtCall, N> { + self.call_builder(&createdAtCall) + } + ///Creates a new call builder for the [`extraData`] function. + pub fn extraData(&self) -> alloy_contract::SolCallBuilder<&P, extraDataCall, N> { + self.call_builder(&extraDataCall) + } + ///Creates a new call builder for the [`gameCreator`] function. + pub fn gameCreator( + &self, + ) -> alloy_contract::SolCallBuilder<&P, gameCreatorCall, N> { + self.call_builder(&gameCreatorCall) + } + ///Creates a new call builder for the [`gameData`] function. + pub fn gameData(&self) -> alloy_contract::SolCallBuilder<&P, gameDataCall, N> { + self.call_builder(&gameDataCall) + } + ///Creates a new call builder for the [`gameType`] function. + pub fn gameType(&self) -> alloy_contract::SolCallBuilder<&P, gameTypeCall, N> { + self.call_builder(&gameTypeCall) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder(&initializeCall) + } + ///Creates a new call builder for the [`l1BlockNumber`] function. + pub fn l1BlockNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l1BlockNumberCall, N> { + self.call_builder(&l1BlockNumberCall) + } + ///Creates a new call builder for the [`l1Head`] function. + pub fn l1Head(&self) -> alloy_contract::SolCallBuilder<&P, l1HeadCall, N> { + self.call_builder(&l1HeadCall) + } + ///Creates a new call builder for the [`l2OutputOracle`] function. + pub fn l2OutputOracle( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2OutputOracleCall, N> { + self.call_builder(&l2OutputOracleCall) + } + ///Creates a new call builder for the [`l2SequenceNumber`] function. + pub fn l2SequenceNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2SequenceNumberCall, N> { + self.call_builder(&l2SequenceNumberCall) + } + ///Creates a new call builder for the [`proof`] function. + pub fn proof(&self) -> alloy_contract::SolCallBuilder<&P, proofCall, N> { + self.call_builder(&proofCall) + } + ///Creates a new call builder for the [`proverAddress`] function. + pub fn proverAddress( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proverAddressCall, N> { + self.call_builder(&proverAddressCall) + } + ///Creates a new call builder for the [`resolve`] function. + pub fn resolve(&self) -> alloy_contract::SolCallBuilder<&P, resolveCall, N> { + self.call_builder(&resolveCall) + } + ///Creates a new call builder for the [`resolvedAt`] function. + pub fn resolvedAt( + &self, + ) -> alloy_contract::SolCallBuilder<&P, resolvedAtCall, N> { + self.call_builder(&resolvedAtCall) + } + ///Creates a new call builder for the [`rootClaim`] function. + pub fn rootClaim(&self) -> alloy_contract::SolCallBuilder<&P, rootClaimCall, N> { + self.call_builder(&rootClaimCall) + } + ///Creates a new call builder for the [`status`] function. + pub fn status(&self) -> alloy_contract::SolCallBuilder<&P, statusCall, N> { + self.call_builder(&statusCall) + } + ///Creates a new call builder for the [`version`] function. + pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> { + self.call_builder(&versionCall) + } + ///Creates a new call builder for the [`wasRespectedGameTypeWhenCreated`] function. + pub fn wasRespectedGameTypeWhenCreated( + &self, + ) -> alloy_contract::SolCallBuilder<&P, wasRespectedGameTypeWhenCreatedCall, N> { + self.call_builder(&wasRespectedGameTypeWhenCreatedCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OPSuccinctDisputeGameInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`Resolved`] event. + pub fn Resolved_filter(&self) -> alloy_contract::Event<&P, Resolved, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/op_succinct_fault_dispute_game.rs b/bindings/src/codegen/op_succinct_fault_dispute_game.rs new file mode 100644 index 000000000..38bb416cb --- /dev/null +++ b/bindings/src/codegen/op_succinct_fault_dispute_game.rs @@ -0,0 +1,12385 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface OPSuccinctFaultDisputeGame { + type BondDistributionMode is uint8; + type GameStatus is uint8; + type ProposalStatus is uint8; + type Claim is bytes32; + type Duration is uint64; + type GameType is uint32; + type Hash is bytes32; + type Timestamp is uint64; + + error AlreadyInitialized(); + error BadAuth(); + error BondTransferFailed(); + error ClaimAlreadyChallenged(); + error ClaimAlreadyResolved(); + error GameNotFinalized(); + error GameNotOver(); + error GameOver(); + error IncorrectBondAmount(); + error IncorrectDisputeGameFactory(); + error InvalidBondDistributionMode(); + error InvalidParentGame(); + error InvalidProposalStatus(); + error NoCreditToClaim(); + error ParentGameNotResolved(); + error UnexpectedRootClaim(Claim rootClaim); + + event Challenged(address indexed challenger); + event GameClosed(BondDistributionMode bondDistributionMode); + event Proved(address indexed prover); + event Resolved(GameStatus indexed status); + + constructor(Duration _maxChallengeDuration, Duration _maxProveDuration, address _disputeGameFactory, address _sp1Verifier, bytes32 _rollupConfigHash, bytes32 _aggregationVkey, bytes32 _rangeVkeyCommitment, uint256 _challengerBond, address _anchorStateRegistry, address _accessManager); + + function accessManager() external view returns (address accessManager_); + function aggregationVkey() external view returns (bytes32 aggregationVkey_); + function anchorStateRegistry() external view returns (address registry_); + function bondDistributionMode() external view returns (BondDistributionMode); + function challenge() external payable returns (ProposalStatus); + function challengerBond() external view returns (uint256 challengerBond_); + function claimCredit(address _recipient) external; + function claimData() external view returns (uint32 parentIndex, address counteredBy, address prover, Claim claim, ProposalStatus status, Timestamp deadline); + function closeGame() external; + function createdAt() external view returns (Timestamp); + function credit(address _recipient) external view returns (uint256 credit_); + function disputeGameFactory() external view returns (address disputeGameFactory_); + function extraData() external pure returns (bytes memory extraData_); + function gameCreator() external pure returns (address creator_); + function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); + function gameOver() external view returns (bool gameOver_); + function gameType() external view returns (GameType gameType_); + function initialize() external payable; + function l1Head() external pure returns (Hash l1Head_); + function l2BlockNumber() external pure returns (uint256 l2BlockNumber_); + function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); + function maxChallengeDuration() external view returns (Duration maxChallengeDuration_); + function maxProveDuration() external view returns (Duration maxProveDuration_); + function normalModeCredit(address) external view returns (uint256); + function parentIndex() external pure returns (uint32 parentIndex_); + function prove(bytes memory proofBytes) external returns (ProposalStatus); + function rangeVkeyCommitment() external view returns (bytes32 rangeVkeyCommitment_); + function refundModeCredit(address) external view returns (uint256); + function resolve() external returns (GameStatus); + function resolvedAt() external view returns (Timestamp); + function rollupConfigHash() external view returns (bytes32 rollupConfigHash_); + function rootClaim() external pure returns (Claim rootClaim_); + function sp1Verifier() external view returns (address verifier_); + function startingBlockNumber() external view returns (uint256 startingBlockNumber_); + function startingOutputRoot() external view returns (Hash root, uint256 l2SequenceNumber); + function startingRootHash() external view returns (Hash startingRootHash_); + function status() external view returns (GameStatus); + function version() external view returns (string memory); + function wasRespectedGameTypeWhenCreated() external view returns (bool); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_maxChallengeDuration", + "type": "uint64", + "internalType": "Duration" + }, + { + "name": "_maxProveDuration", + "type": "uint64", + "internalType": "Duration" + }, + { + "name": "_disputeGameFactory", + "type": "address", + "internalType": "contract IDisputeGameFactory" + }, + { + "name": "_sp1Verifier", + "type": "address", + "internalType": "contract ISP1Verifier" + }, + { + "name": "_rollupConfigHash", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_aggregationVkey", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_rangeVkeyCommitment", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_challengerBond", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_anchorStateRegistry", + "type": "address", + "internalType": "contract IAnchorStateRegistry" + }, + { + "name": "_accessManager", + "type": "address", + "internalType": "contract AccessManager" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "accessManager", + "inputs": [], + "outputs": [ + { + "name": "accessManager_", + "type": "address", + "internalType": "contract AccessManager" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "aggregationVkey", + "inputs": [], + "outputs": [ + { + "name": "aggregationVkey_", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "anchorStateRegistry", + "inputs": [], + "outputs": [ + { + "name": "registry_", + "type": "address", + "internalType": "contract IAnchorStateRegistry" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "bondDistributionMode", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum BondDistributionMode" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "challenge", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum OPSuccinctFaultDisputeGame.ProposalStatus" + } + ], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "challengerBond", + "inputs": [], + "outputs": [ + { + "name": "challengerBond_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "claimCredit", + "inputs": [ + { + "name": "_recipient", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "claimData", + "inputs": [], + "outputs": [ + { + "name": "parentIndex", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "counteredBy", + "type": "address", + "internalType": "address" + }, + { + "name": "prover", + "type": "address", + "internalType": "address" + }, + { + "name": "claim", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "status", + "type": "uint8", + "internalType": "enum OPSuccinctFaultDisputeGame.ProposalStatus" + }, + { + "name": "deadline", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "closeGame", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "createdAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "credit", + "inputs": [ + { + "name": "_recipient", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "credit_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "disputeGameFactory", + "inputs": [], + "outputs": [ + { + "name": "disputeGameFactory_", + "type": "address", + "internalType": "contract IDisputeGameFactory" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "extraData", + "inputs": [], + "outputs": [ + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameCreator", + "inputs": [], + "outputs": [ + { + "name": "creator_", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "gameData", + "inputs": [], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + }, + { + "name": "rootClaim_", + "type": "bytes32", + "internalType": "Claim" + }, + { + "name": "extraData_", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameOver", + "inputs": [], + "outputs": [ + { + "name": "gameOver_", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "gameType", + "inputs": [], + "outputs": [ + { + "name": "gameType_", + "type": "uint32", + "internalType": "GameType" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "l1Head", + "inputs": [], + "outputs": [ + { + "name": "l1Head_", + "type": "bytes32", + "internalType": "Hash" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "l2BlockNumber", + "inputs": [], + "outputs": [ + { + "name": "l2BlockNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "l2SequenceNumber", + "inputs": [], + "outputs": [ + { + "name": "l2SequenceNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "maxChallengeDuration", + "inputs": [], + "outputs": [ + { + "name": "maxChallengeDuration_", + "type": "uint64", + "internalType": "Duration" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "maxProveDuration", + "inputs": [], + "outputs": [ + { + "name": "maxProveDuration_", + "type": "uint64", + "internalType": "Duration" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "normalModeCredit", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "parentIndex", + "inputs": [], + "outputs": [ + { + "name": "parentIndex_", + "type": "uint32", + "internalType": "uint32" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "prove", + "inputs": [ + { + "name": "proofBytes", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum OPSuccinctFaultDisputeGame.ProposalStatus" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "rangeVkeyCommitment", + "inputs": [], + "outputs": [ + { + "name": "rangeVkeyCommitment_", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "refundModeCredit", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "resolve", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "resolvedAt", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "Timestamp" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "rollupConfigHash", + "inputs": [], + "outputs": [ + { + "name": "rollupConfigHash_", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "rootClaim", + "inputs": [], + "outputs": [ + { + "name": "rootClaim_", + "type": "bytes32", + "internalType": "Claim" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "sp1Verifier", + "inputs": [], + "outputs": [ + { + "name": "verifier_", + "type": "address", + "internalType": "contract ISP1Verifier" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "startingBlockNumber", + "inputs": [], + "outputs": [ + { + "name": "startingBlockNumber_", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "startingOutputRoot", + "inputs": [], + "outputs": [ + { + "name": "root", + "type": "bytes32", + "internalType": "Hash" + }, + { + "name": "l2SequenceNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "startingRootHash", + "inputs": [], + "outputs": [ + { + "name": "startingRootHash_", + "type": "bytes32", + "internalType": "Hash" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "status", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum GameStatus" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "wasRespectedGameTypeWhenCreated", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "Challenged", + "inputs": [ + { + "name": "challenger", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "GameClosed", + "inputs": [ + { + "name": "bondDistributionMode", + "type": "uint8", + "indexed": false, + "internalType": "enum BondDistributionMode" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Proved", + "inputs": [ + { + "name": "prover", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Resolved", + "inputs": [ + { + "name": "status", + "type": "uint8", + "indexed": true, + "internalType": "enum GameStatus" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "AlreadyInitialized", + "inputs": [] + }, + { + "type": "error", + "name": "BadAuth", + "inputs": [] + }, + { + "type": "error", + "name": "BondTransferFailed", + "inputs": [] + }, + { + "type": "error", + "name": "ClaimAlreadyChallenged", + "inputs": [] + }, + { + "type": "error", + "name": "ClaimAlreadyResolved", + "inputs": [] + }, + { + "type": "error", + "name": "GameNotFinalized", + "inputs": [] + }, + { + "type": "error", + "name": "GameNotOver", + "inputs": [] + }, + { + "type": "error", + "name": "GameOver", + "inputs": [] + }, + { + "type": "error", + "name": "IncorrectBondAmount", + "inputs": [] + }, + { + "type": "error", + "name": "IncorrectDisputeGameFactory", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidBondDistributionMode", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidParentGame", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidProposalStatus", + "inputs": [] + }, + { + "type": "error", + "name": "NoCreditToClaim", + "inputs": [] + }, + { + "type": "error", + "name": "ParentGameNotResolved", + "inputs": [] + }, + { + "type": "error", + "name": "UnexpectedRootClaim", + "inputs": [ + { + "name": "rootClaim", + "type": "bytes32", + "internalType": "Claim" + } + ] + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod OPSuccinctFaultDisputeGame { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"a\x01\xE0`@R4\x80\x15b\0\0\x12W`\0\x80\xFD[P`@Qb\0CV8\x03\x80b\0CV\x839\x81\x81\x01`@R\x81\x01\x90b\0\08\x91\x90b\0\x03\x94V[`*c\xFF\xFF\xFF\xFF\x16`\xC0\x81c\xFF\xFF\xFF\xFF\x16\x81RPP\x89g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x80\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x88g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\xA0\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x87s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\xE0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x86s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x01\0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x85a\x01 \x81\x81RPP\x84a\x01@\x81\x81RPP\x83a\x01`\x81\x81RPP\x82a\x01\x80\x81\x81RPP\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x01\xA0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x01\xC0\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPPPPPPPPPPPPb\0\x04\x8AV[`\0\x80\xFD[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[b\0\x01\xB0\x81b\0\x01\x91V[\x81\x14b\0\x01\xBCW`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x01\xD0\x81b\0\x01\xA5V[\x92\x91PPV[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0b\0\x02\x03\x82b\0\x01\xD6V[\x90P\x91\x90PV[`\0b\0\x02\x17\x82b\0\x01\xF6V[\x90P\x91\x90PV[b\0\x02)\x81b\0\x02\nV[\x81\x14b\0\x025W`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x02I\x81b\0\x02\x1EV[\x92\x91PPV[`\0b\0\x02\\\x82b\0\x01\xF6V[\x90P\x91\x90PV[b\0\x02n\x81b\0\x02OV[\x81\x14b\0\x02zW`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x02\x8E\x81b\0\x02cV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[b\0\x02\xA9\x81b\0\x02\x94V[\x81\x14b\0\x02\xB5W`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x02\xC9\x81b\0\x02\x9EV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[b\0\x02\xE4\x81b\0\x02\xCFV[\x81\x14b\0\x02\xF0W`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x03\x04\x81b\0\x02\xD9V[\x92\x91PPV[`\0b\0\x03\x17\x82b\0\x01\xF6V[\x90P\x91\x90PV[b\0\x03)\x81b\0\x03\nV[\x81\x14b\0\x035W`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x03I\x81b\0\x03\x1EV[\x92\x91PPV[`\0b\0\x03\\\x82b\0\x01\xF6V[\x90P\x91\x90PV[b\0\x03n\x81b\0\x03OV[\x81\x14b\0\x03zW`\0\x80\xFD[PV[`\0\x81Q\x90Pb\0\x03\x8E\x81b\0\x03cV[\x92\x91PPV[`\0\x80`\0\x80`\0\x80`\0\x80`\0\x80a\x01@\x8B\x8D\x03\x12\x15b\0\x03\xBBWb\0\x03\xBAb\0\x01\x8CV[[`\0b\0\x03\xCB\x8D\x82\x8E\x01b\0\x01\xBFV[\x9APP` b\0\x03\xDE\x8D\x82\x8E\x01b\0\x01\xBFV[\x99PP`@b\0\x03\xF1\x8D\x82\x8E\x01b\0\x028V[\x98PP``b\0\x04\x04\x8D\x82\x8E\x01b\0\x02}V[\x97PP`\x80b\0\x04\x17\x8D\x82\x8E\x01b\0\x02\xB8V[\x96PP`\xA0b\0\x04*\x8D\x82\x8E\x01b\0\x02\xB8V[\x95PP`\xC0b\0\x04=\x8D\x82\x8E\x01b\0\x02\xB8V[\x94PP`\xE0b\0\x04P\x8D\x82\x8E\x01b\0\x02\xF3V[\x93PPa\x01\0b\0\x04d\x8D\x82\x8E\x01b\0\x038V[\x92PPa\x01 b\0\x04x\x8D\x82\x8E\x01b\0\x03}V[\x91PP\x92\x95\x98\x9B\x91\x94\x97\x9AP\x92\x95\x98PV[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\x01@Qa\x01`Qa\x01\x80Qa\x01\xA0Qa\x01\xC0Qa=\x9Db\0\x05\xB9`\09`\0\x81\x81a\x1C\xD7\x01R\x81\x81a)-\x01Ra-l\x01R`\0\x81\x81a\x15\x1D\x01R\x81\x81a\x19W\x01R\x81\x81a\x1A*\x01R\x81\x81a\x1A\xB1\x01R\x81\x81a\x1E\x85\x01R\x81\x81a\x1F&\x01R\x81\x81a\x1F\xC7\x01R\x81\x81a\"}\x01Ra&e\x01R`\0\x81\x81a\x0Eu\x01R\x81\x81a\x0E\xFD\x01R\x81\x81a\x18\x15\x01Ra*<\x01R`\0\x81\x81a\x10l\x01Ra\x11@\x01R`\0\x81\x81a\x11\xBE\x01Ra(V\x01R`\0\x81\x81a\x11\x1A\x01Ra\x18=\x01R`\0\x81\x81a\x11\x82\x01Ra\x14\xAA\x01R`\0\x81\x81a\x1Ci\x01R\x81\x81a\x1D\xE0\x01R\x81\x81a-\x1C\x01Ra-\xB0\x01R`\0\x81\x81a\"\xB9\x01R\x81\x81a&>\x01Ra'8\x01R`\0\x81\x81a'`\x01Ra+\t\x01R`\0\x81\x81a$)\x01Ra(\x96\x01Ra=\x9D`\0\xF3\xFE`\x80`@R`\x046\x10a\x020W`\x005`\xE0\x1C\x80cm\x9A\x1C\x8B\x11a\x01.W\x80c\xBD\xB37\xD1\x11a\0\xABW\x80c\xD2\xEFs\x98\x11a\0oW\x80c\xD2\xEFs\x98\x14a\x07\xF0W\x80c\xD5\xD4M\x80\x14a\x08\x0EW\x80c\xF2\xB4\xE6\x17\x14a\x08KW\x80c\xFA$\xF7C\x14a\x08vW\x80c\xFD\xCB`h\x14a\x08\xA3Wa\x020V[\x80c\xBD\xB37\xD1\x14a\x07\x07W\x80c\xC0\xD8\xBBt\x14a\x072W\x80c\xC3.N>\x14a\x07oW\x80c\xCF\t\xE0\xD0\x14a\x07\x9AW\x80c\xD2\x17{\xDD\x14a\x07\xC5Wa\x020V[\x80c\x8B\x85\x90+\x11a\0\xF2W\x80c\x8B\x85\x90+\x14a\x060W\x80c\x99s^2\x14a\x06[W\x80c\xBB\xDC\x02\xDB\x14a\x06\x86W\x80c\xBC\xBEP\x94\x14a\x06\xB1W\x80c\xBC\xEF;U\x14a\x06\xDCWa\x020V[\x80cm\x9A\x1C\x8B\x14a\x05\x8EW\x80cp\x87*\xA5\x14a\x05\xB9W\x80cxk\x84K\x14a\x05\xE4W\x80cyHi\n\x14a\x05\xFBW\x80c\x81)\xFC\x1C\x14a\x06&Wa\x020V[\x80c>\xC4\xD4\xD6\x11a\x01\xBCW\x80c\\\x0C\xBA3\x11a\x01\x80W\x80c\\\x0C\xBA3\x14a\x04\xB9W\x80c`\x9D34\x14a\x04\xE4W\x80c`\xE2td\x14a\x05\x0FW\x80ccaPm\x14a\x058W\x80ch\xCC\xDC\x86\x14a\x05cWa\x020V[\x80c>\xC4\xD4\xD6\x14a\x03\xCAW\x80cR\x9Dj\x8C\x14a\x03\xFAW\x80cR\xA0\x7F\xA3\x14a\x047W\x80cT\xFDMP\x14a\x04bW\x80cW\xDA\x95\x0E\x14a\x04\x8DWa\x020V[\x80c(\x10\xE1\xD6\x11a\x02\x03W\x80c(\x10\xE1\xD6\x14a\x02\xE1W\x80c+1\x84\x1E\x14a\x03\x0CW\x80c7[\xFA]\x14a\x037W\x80c7\x8D\xD4\x8C\x14a\x03tW\x80c7\xB1\xB2)\x14a\x03\x9FWa\x020V[\x80c\x19\xEF\xFE\xB4\x14a\x025W\x80c \r.\xD2\x14a\x02`W\x80c%\x0Ei\xBD\x14a\x02\x8BW\x80c%\xFC*\xCE\x14a\x02\xB6W[`\0\x80\xFD[4\x80\x15a\x02AW`\0\x80\xFD[Pa\x02Ja\x08\xCEV[`@Qa\x02W\x91\x90a/\xF2V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02lW`\0\x80\xFD[Pa\x02ua\x08\xE8V[`@Qa\x02\x82\x91\x90a0\x84V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\x97W`\0\x80\xFD[Pa\x02\xA0a\x08\xFBV[`@Qa\x02\xAD\x91\x90a0\xBAV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xC2W`\0\x80\xFD[Pa\x02\xCBa\t\x0EV[`@Qa\x02\xD8\x91\x90a1\0V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xEDW`\0\x80\xFD[Pa\x02\xF6a\t\x1BV[`@Qa\x03\x03\x91\x90a0\x84V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x18W`\0\x80\xFD[Pa\x03!a\x10hV[`@Qa\x03.\x91\x90a1*V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03CW`\0\x80\xFD[Pa\x03^`\x04\x806\x03\x81\x01\x90a\x03Y\x91\x90a1\xB4V[a\x10\x90V[`@Qa\x03k\x91\x90a2IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x80W`\0\x80\xFD[Pa\x03\x89a\x13\xCFV[`@Qa\x03\x96\x91\x90a2\xACV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xABW`\0\x80\xFD[Pa\x03\xB4a\x13\xE2V[`@Qa\x03\xC1\x91\x90a3\x08V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xD6W`\0\x80\xFD[Pa\x03\xDFa\x13\xF3V[`@Qa\x03\xF1\x96\x95\x94\x93\x92\x91\x90a3QV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x06W`\0\x80\xFD[Pa\x04!`\x04\x806\x03\x81\x01\x90a\x04\x1C\x91\x90a3\xDEV[a\x14\x8EV[`@Qa\x04.\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04CW`\0\x80\xFD[Pa\x04La\x14\xA6V[`@Qa\x04Y\x91\x90a4\x94V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04nW`\0\x80\xFD[Pa\x04wa\x14\xCEV[`@Qa\x04\x84\x91\x90a5HV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x99W`\0\x80\xFD[Pa\x04\xA2a\x15\x07V[`@Qa\x04\xB0\x92\x91\x90a5jV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xC5W`\0\x80\xFD[Pa\x04\xCEa\x15\x19V[`@Qa\x04\xDB\x91\x90a5\xB4V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xF0W`\0\x80\xFD[Pa\x04\xF9a\x15AV[`@Qa\x05\x06\x91\x90a6$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\x1BW`\0\x80\xFD[Pa\x056`\x04\x806\x03\x81\x01\x90a\x051\x91\x90a3\xDEV[a\x15TV[\0[4\x80\x15a\x05DW`\0\x80\xFD[Pa\x05Ma\x18\0V[`@Qa\x05Z\x91\x90a1\0V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05oW`\0\x80\xFD[Pa\x05xa\x18\x11V[`@Qa\x05\x85\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\x9AW`\0\x80\xFD[Pa\x05\xA3a\x189V[`@Qa\x05\xB0\x91\x90a1*V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\xC5W`\0\x80\xFD[Pa\x05\xCEa\x18aV[`@Qa\x05\xDB\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\xF0W`\0\x80\xFD[Pa\x05\xF9a\x18nV[\0[4\x80\x15a\x06\x07W`\0\x80\xFD[Pa\x06\x10a\x1B\xF8V[`@Qa\x06\x1D\x91\x90a6FV[`@Q\x80\x91\x03\x90\xF3[a\x06.a\x1C\tV[\0[4\x80\x15a\x06W`\0\x80\xFD[Pa\x07Y`\x04\x806\x03\x81\x01\x90a\x07T\x91\x90a3\xDEV[a(:V[`@Qa\x07f\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07{W`\0\x80\xFD[Pa\x07\x84a(RV[`@Qa\x07\x91\x91\x90a1*V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07\xA6W`\0\x80\xFD[Pa\x07\xAFa(zV[`@Qa\x07\xBC\x91\x90a/\xF2V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07\xD1W`\0\x80\xFD[Pa\x07\xDAa(\x92V[`@Qa\x07\xE7\x91\x90a6\xBCV[`@Q\x80\x91\x03\x90\xF3[a\x07\xF8a(\xBAV[`@Qa\x08\x05\x91\x90a2IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\x1AW`\0\x80\xFD[Pa\x085`\x04\x806\x03\x81\x01\x90a\x080\x91\x90a3\xDEV[a,MV[`@Qa\x08B\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08WW`\0\x80\xFD[Pa\x08`a-\x18V[`@Qa\x08m\x91\x90a7\x13V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\x82W`\0\x80\xFD[Pa\x08\x8Ba-@V[`@Qa\x08\x9A\x93\x92\x91\x90a7.V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\xAFW`\0\x80\xFD[Pa\x08\xB8a-hV[`@Qa\x08\xC5\x91\x90a7\x8DV[`@Q\x80\x91\x03\x90\xF3[`\0`\x08\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\t`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0`\x07`\0\x01T\x90P\x90V[`\0\x80`\x02\x81\x11\x15a\t0Wa\t/a0\rV[[`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\tRWa\tQa0\rV[[\x14a\t\x89W`@Q\x7F\xF1\xA9E\x81\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\t\x93a-\x90V[\x90P`\0`\x02\x81\x11\x15a\t\xA9Wa\t\xA8a0\rV[[\x81`\x02\x81\x11\x15a\t\xBCWa\t\xBBa0\rV[[\x03a\t\xF3W`@Q\x7F\x92\xC5\x06\xAE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x02\x81\x11\x15a\n\x07Wa\n\x06a0\rV[[\x81`\x02\x81\x11\x15a\n\x1AWa\n\x19a0\rV[[\x03a\n\xB8W`\x01`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\nEWa\nDa0\rV[[\x02\x17\x90UPG`\x05`\0`\x01`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0F\xADV[a\n\xC0a'\x95V[a\n\xF6W`@Q\x7F\x04d<9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`\x04\x81\x11\x15a\x0B\nWa\x0B\ta0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a\x0B/Wa\x0B.a0\rV[[\x03a\x0B\xAFW`\x02`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x0BZWa\x0BYa0\rV[[\x02\x17\x90UPG`\x05`\0a\x0Bla\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0F\xACV[`\x01`\x04\x81\x11\x15a\x0B\xC3Wa\x0B\xC2a0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a\x0B\xE8Wa\x0B\xE7a0\rV[[\x03a\x0C\x86W`\x01`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x0C\x13Wa\x0C\x12a0\rV[[\x02\x17\x90UPG`\x05`\0`\x01`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0F\xABV[`\x02`\x04\x81\x11\x15a\x0C\x9AWa\x0C\x99a0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a\x0C\xBFWa\x0C\xBEa0\rV[[\x03a\r?W`\x02`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x0C\xEAWa\x0C\xE9a0\rV[[\x02\x17\x90UPG`\x05`\0a\x0C\xFCa\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0F\xAAV[`\x03`\x04\x81\x11\x15a\rSWa\rRa0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a\rxWa\rwa0\rV[[\x03a\x0FwW`\x02`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\r\xA3Wa\r\xA2a0\rV[[\x02\x17\x90UPa\r\xB0a\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x0EsWG`\x05`\0`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0FrV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x05`\0`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0Ga\x0F'\x91\x90a7\xD7V[`\x05`\0a\x0F3a\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP[a\x0F\xA9V[`@Q\x7Ft\x92\xA2i\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[[[[[`\x04`\x01`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a\x0F\xD6Wa\x0F\xD5a0\rV[[\x02\x17\x90UPB`\0`\x08a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x10&Wa\x10%a0\rV[[\x7F^\x18o\t\xB9\xC94\x91\xF1N'~\xEA\x7F\xAA]\xE6\xA2\xD4\xBD\xA7Zy\xAFz6\x84\xFB\xFBB\xDA``@Q`@Q\x80\x91\x03\x90\xA2`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x91PP\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0a\x10\x9Aa'\x95V[\x15a\x10\xD1W`@Q\x7F\xDFF\x9C\xCB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`@Q\x80`\xE0\x01`@R\x80a\x10\xE6a\x18\0V[\x81R` \x01`\x07`\0\x01T\x81R` \x01a\x11\x06a\x11\x01a'\x84V[a.\xD2V[\x81R` \x01a\x11\x13a'#V[\x81R` \x01\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` \x01\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` \x013s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cAI<`\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83`@Q` \x01a\x11\xEE\x91\x90a8\xC6V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x87\x87`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12\x1E\x94\x93\x92\x91\x90a9\x1DV[`\0`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x126W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x12JW=`\0\x80>=`\0\xFD[PPPP3`\x01\x80\x01`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x13\x1DW`\x02`\x01`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a\x13\x13Wa\x13\x12a0\rV[[\x02\x17\x90UPa\x13LV[`\x03`\x01`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a\x13FWa\x13Ea0\rV[[\x02\x17\x90UP[`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F^ee\xD9\xCA/\\\x85\x01\xD6A\x8B\xF5c2*rC\xBAz\xCE&mu\xEA\xC9\x9FJ\xDB\xB3\x0B\xA7`@Q`@Q\x80\x91\x03\x90\xA2`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x91PP\x92\x91PPV[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0a\x13\xEE`\0a.\xDCV[\x90P\x90V[`\x01\x80`\0\x01`\0\x90T\x90a\x01\0\n\x90\x04c\xFF\xFF\xFF\xFF\x16\x90\x80`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x80`\x01\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x80`\x02\x01T\x90\x80`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x90\x80`\x03\x01`\x01\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x86V[`\x05` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F2.0.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\x07\x80`\0\x01T\x90\x80`\x01\x01T\x90P\x82V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[``a\x15O`T`$a.\xF8V[\x90P\x90V[a\x15\\a\x18nV[`\0`\x02\x80\x81\x11\x15a\x15qWa\x15pa0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x15\x93Wa\x15\x92a0\rV[[\x03a\x15\xDFW`\x06`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90Pa\x16\x94V[`\x01`\x02\x81\x11\x15a\x15\xF3Wa\x15\xF2a0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x16\x15Wa\x16\x14a0\rV[[\x03a\x16aW`\x05`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90Pa\x16\x93V[`@Q\x7F\x07\x8A=\xF4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[[`\0\x81\x03a\x16\xCEW`@Q\x7F\x17\xBF\xE5\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`\x06`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP`\0`\x05`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82`@Qa\x17~\x90a9\x95V[`\0`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a\x17\xBBW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x17\xC0V[``\x91P[PP\x90P\x80a\x17\xFBW`@Q\x7F\x83\xE6\xCCk\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPV[`\0a\x18\x0C`4a/0V[\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0`\x07`\x01\x01T\x90P\x90V[`\x02\x80\x81\x11\x15a\x18\x81Wa\x18\x80a0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x18\xA3Wa\x18\xA2a0\rV[[\x14\x80a\x18\xE2WP`\x01`\x02\x81\x11\x15a\x18\xBEWa\x18\xBDa0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x18\xE0Wa\x18\xDFa0\rV[[\x14[a\x1B\xF6W`\0`\x02\x81\x11\x15a\x18\xFAWa\x18\xF9a0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x19\x1CWa\x19\x1Ba0\rV[[\x14a\x19SW`@Q\x7F\x07\x8A=\xF4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x03\x14\xD2\xB30`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x19\xAE\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\xCBW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19\xEF\x91\x90a:\x12V[\x90P\x80a\x1A(W`@Q\x7FHQ\xBD\x9B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x17\xCF!\xA90`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1A\x81\x91\x90a9\xCBV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x1A\x9BW`\0\x80\xFD[PZ\xF1\x92PPP\x80\x15a\x1A\xACWP`\x01[P`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cIk\x9C\x160`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1B\x08\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1B%W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1BI\x91\x90a:\x12V[\x90P\x80\x15a\x1B\x81W`\x01`\t`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x1BwWa\x1Bva0\rV[[\x02\x17\x90UPa\x1B\xADV[`\x02`\t`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x1B\xA7Wa\x1B\xA6a0\rV[[\x02\x17\x90UP[\x7F\x99\x08\xEA\xAC\x06E\xDF\x9D\x07\x04\xD0j\xDC\x9E\x073|\x95\x1D\xE2\xF0k_(6\x15\x1DH\xD5\xE4r/`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`@Qa\x1B\xEB\x91\x90a2\xACV[`@Q\x80\x91\x03\x90\xA1PP[V[`\0a\x1C\x04`ta/IV[\x90P\x90V[`\0`\x11\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a\x1CPW`@Q\x7F\r\xC1I\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x1C\xD5W`@Q\x7F\x94\r8\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x1D2%\xE3a\x1D\x19a\x13\xE2V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1D5\x91\x90a3\x08V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1DRW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1Dv\x91\x90a:\x12V[a\x1D\xACW`@Q\x7F\xD3\x86\xEF>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`~6\x14a\x1D\xC2Wc\x98$\xBD\xAB`\0R`\x04`\x1C\xFD[c\xFF\xFF\xFF\xFF\x80\x16a\x1D\xD1a\x1B\xF8V[c\xFF\xFF\xFF\xFF\x16\x14a\"{W`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBB\x8A\xA1\xFCa\x1E\"a\x1B\xF8V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E>\x91\x90a:pV[```@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1E[W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1E\x7F\x91\x90a;!V[\x92PPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x04\xE5\x0F\xED\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E\xDC\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1E\xF9W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1F\x1D\x91\x90a:\x12V[\x15\x80a\x1F\xBFWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c4\xA3F\xEA\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1F}\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1F\x9AW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1F\xBE\x91\x90a:\x12V[[\x80a `WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cYX\xA1\x93\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \x1E\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a ;W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a _\x91\x90a:\x12V[[\x15a \x97W`@Q\x7F4a\x19\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x80`@\x01`@R\x80a!\x19\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBC\xEF;U`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a \xF0W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\x14\x91\x90a;\xA0V[a.\xD2V[\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x99s^2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a!iW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\x8D\x91\x90a;\xF9V[\x81RP`\x07`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U\x90PP`\x01`\x02\x81\x11\x15a!\xBDWa!\xBCa0\rV[[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\"\x08W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\",\x91\x90aWa\"=a0\rV[[\x03a\"uW`@Q\x7F4a\x19\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[Pa#OV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16crX\xA8\x07\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\"\xF4\x91\x90a6\x92V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#\x10W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#4\x91\x90a<\xA4V[`\x07`\0\x01`\0`\x07`\x01\x01`\0\x84\x91\x90PU\x83\x91\x90PUPP[`\x07`\x01\x01Ta#]a'#V[\x11a#\xA6Wa#ja'\x84V[`@Q\x7F\xF4\x029\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a#\x9D\x91\x90a6\xD7V[`@Q\x80\x91\x03\x90\xFD[`@Q\x80`\xC0\x01`@R\x80a#\xB9a\x1B\xF8V[c\xFF\xFF\xFF\xFF\x16\x81R` \x01`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01a$\x06a'\x84V[\x81R` \x01`\0`\x04\x81\x11\x15a$\x1FWa$\x1Ea0\rV[[\x81R` \x01a$W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a/eV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16Ba$l\x91\x90a<\xE4V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP`\x01`\0\x82\x01Q\x81`\0\x01`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP` \x82\x01Q\x81`\0\x01`\x04a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`@\x82\x01Q\x81`\x01\x01`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP``\x82\x01Q\x81`\x02\x01U`\x80\x82\x01Q\x81`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a%eWa%da0\rV[[\x02\x17\x90UP`\xA0\x82\x01Q\x81`\x03\x01`\x01a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x90PP`\x01`\0`\x11a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP4`\x06`\0a%\xC4a\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x82Ta&\r\x91\x90a<\xE4V[\x92PP\x81\x90UPB`\0\x80a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0c\xFF\xFF\xFF\xFF\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c<\x9F9|`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a&\xCEW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a&\xF2\x91\x90a=:V[c\xFF\xFF\xFF\xFF\x16\x14`\t`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPV[`\0a'\x1Ea'#V[\x90P\x90V[`\0a'/`Ta/oV[\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0a'\x90`\x14a/0V[\x90P\x90V[`\0Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a'\xCE`\x01`\x03\x01`\x01\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a/\x88V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10\x80a(5WP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x90P\x90V[`\x06` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80`\x04\x81\x11\x15a(\xCFWa(\xCEa0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a(\xF4Wa(\xF3a0\rV[[\x14a)+W`@Q\x7F\x85\xC3E\xB0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFFY\xAE}3`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a)\x84\x91\x90a3\x08V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a)\xA1W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a)\xC5\x91\x90a:\x12V[a)\xFBW`@Q\x7F\xD3\x86\xEF>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a*\x03a'\x95V[\x15a*:W`@Q\x7F\xDFF\x9C\xCB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x004\x14a*\x93W`@Q\x7F\x86 \xAA\x19\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3`\x01`\0\x01`\x04a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x01\x80`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a*\xFFWa*\xFEa0\rV[[\x02\x17\x90UPa+7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a/eV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16Ba+L\x91\x90a<\xE4V[`\x01`\x03\x01`\x01a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP4`\x06`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x82Ta+\xC6\x91\x90a<\xE4V[\x92PP\x81\x90UP`\x01`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x98\x02{8\x15?\x99\\K\x80*\\~ce\xBE\xE3\xAD\xDB%\xAFk)\x81\x8C\x0C0F\x84\xD8\x05,`@Q`@Q\x80\x91\x03\x90\xA2`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x90P\x90V[`\0`\x02\x80\x81\x11\x15a,bWa,aa0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a,\x84Wa,\x83a0\rV[[\x03a,\xD0W`\x06`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90Pa-\x13V[`\x05`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90P[\x91\x90PV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80``a-Ma'4V[\x92Pa-Wa'\x84V[\x91Pa-aa\x15AV[\x90P\x90\x91\x92V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0c\xFF\xFF\xFF\xFF\x80\x16a-\xA1a\x1B\xF8V[c\xFF\xFF\xFF\xFF\x16\x14a.\xCAW`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBB\x8A\xA1\xFCa-\xF2a\x1B\xF8V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a.\x0E\x91\x90a:pV[```@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a.+W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a.O\x91\x90a;!V[\x92PPP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a.\x9EW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a.\xC2\x91\x90a\x81\x84a5\xEBV[\x90P\x92\x91PPV[`\0` \x82\x01\x90Pa6[`\0\x83\x01\x84a33V[\x92\x91PPV[`\0a6|a6wa6r\x84a3#V[a/\xB7V[a3#V[\x90P\x91\x90PV[a6\x8C\x81a6aV[\x82RPPV[`\0` \x82\x01\x90Pa6\xA7`\0\x83\x01\x84a6\x83V[\x92\x91PPV[a6\xB6\x81a/\xC1V[\x82RPPV[`\0` \x82\x01\x90Pa6\xD1`\0\x83\x01\x84a6\xADV[\x92\x91PPV[`\0` \x82\x01\x90Pa6\xEC`\0\x83\x01\x84a3BV[\x92\x91PPV[`\0a6\xFD\x82a4aV[\x90P\x91\x90PV[a7\r\x81a6\xF2V[\x82RPPV[`\0` \x82\x01\x90Pa7(`\0\x83\x01\x84a7\x04V[\x92\x91PPV[`\0``\x82\x01\x90Pa7C`\0\x83\x01\x86a6\x83V[a7P` \x83\x01\x85a3BV[\x81\x81\x03`@\x83\x01Ra7b\x81\x84a5\xEBV[\x90P\x94\x93PPPPV[`\0a7w\x82a4aV[\x90P\x91\x90PV[a7\x87\x81a7lV[\x82RPPV[`\0` \x82\x01\x90Pa7\xA2`\0\x83\x01\x84a7~V[\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x11`\x04R`$`\0\xFD[`\0a7\xE2\x82a4\x0BV[\x91Pa7\xED\x83a4\x0BV[\x92P\x82\x82\x10\x15a8\0Wa7\xFFa7\xA8V[[\x82\x82\x03\x90P\x92\x91PPV[a8\x14\x81a0\xD5V[\x82RPPV[a8#\x81a4\x0BV[\x82RPPV[a82\x81a2\xE7V[\x82RPPV[`\xE0\x82\x01`\0\x82\x01Qa8N`\0\x85\x01\x82a8\x0BV[P` \x82\x01Qa8a` \x85\x01\x82a8\x0BV[P`@\x82\x01Qa8t`@\x85\x01\x82a8\x0BV[P``\x82\x01Qa8\x87``\x85\x01\x82a8\x1AV[P`\x80\x82\x01Qa8\x9A`\x80\x85\x01\x82a8\x0BV[P`\xA0\x82\x01Qa8\xAD`\xA0\x85\x01\x82a8\x0BV[P`\xC0\x82\x01Qa8\xC0`\xC0\x85\x01\x82a8)V[PPPPV[`\0`\xE0\x82\x01\x90Pa8\xDB`\0\x83\x01\x84a88V[\x92\x91PPV[\x82\x81\x837`\0\x83\x83\x01RPPPV[`\0a8\xFC\x83\x85a5\xDAV[\x93Pa9\t\x83\x85\x84a8\xE1V[a9\x12\x83a4\xFEV[\x84\x01\x90P\x93\x92PPPV[`\0``\x82\x01\x90Pa92`\0\x83\x01\x87a1\x1BV[\x81\x81\x03` \x83\x01Ra9D\x81\x86a5\xEBV[\x90P\x81\x81\x03`@\x83\x01Ra9Y\x81\x84\x86a8\xF0V[\x90P\x95\x94PPPPPV[`\0\x81\x90P\x92\x91PPV[PV[`\0a9\x7F`\0\x83a9dV[\x91Pa9\x8A\x82a9oV[`\0\x82\x01\x90P\x91\x90PV[`\0a9\xA0\x82a9rV[\x91P\x81\x90P\x91\x90PV[`\0a9\xB5\x82a4aV[\x90P\x91\x90PV[a9\xC5\x81a9\xAAV[\x82RPPV[`\0` \x82\x01\x90Pa9\xE0`\0\x83\x01\x84a9\xBCV[\x92\x91PPV[a9\xEF\x81a0\x9FV[\x81\x14a9\xFAW`\0\x80\xFD[PV[`\0\x81Q\x90Pa:\x0C\x81a9\xE6V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a:(Wa:'a1EV[[`\0a:6\x84\x82\x85\x01a9\xFDV[\x91PP\x92\x91PPV[`\0a:Za:Ua:P\x84a3#V[a/\xB7V[a4\x0BV[\x90P\x91\x90PV[a:j\x81a:?V[\x82RPPV[`\0` \x82\x01\x90Pa:\x85`\0\x83\x01\x84a:aV[\x92\x91PPV[a:\x94\x81a3#V[\x81\x14a:\x9FW`\0\x80\xFD[PV[`\0\x81Q\x90Pa:\xB1\x81a:\x8BV[\x92\x91PPV[a:\xC0\x81a/\xA3V[\x81\x14a:\xCBW`\0\x80\xFD[PV[`\0\x81Q\x90Pa:\xDD\x81a:\xB7V[\x92\x91PPV[`\0a:\xEE\x82a2\xE7V[\x90P\x91\x90PV[a:\xFE\x81a:\xE3V[\x81\x14a;\tW`\0\x80\xFD[PV[`\0\x81Q\x90Pa;\x1B\x81a:\xF5V[\x92\x91PPV[`\0\x80`\0``\x84\x86\x03\x12\x15a;:Wa;9a1EV[[`\0a;H\x86\x82\x87\x01a:\xA2V[\x93PP` a;Y\x86\x82\x87\x01a:\xCEV[\x92PP`@a;j\x86\x82\x87\x01a;\x0CV[\x91PP\x92P\x92P\x92V[a;}\x81a0\xD5V[\x81\x14a;\x88W`\0\x80\xFD[PV[`\0\x81Q\x90Pa;\x9A\x81a;tV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a;\xB6Wa;\xB5a1EV[[`\0a;\xC4\x84\x82\x85\x01a;\x8BV[\x91PP\x92\x91PPV[a;\xD6\x81a4\x0BV[\x81\x14a;\xE1W`\0\x80\xFD[PV[`\0\x81Q\x90Pa;\xF3\x81a;\xCDV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a<\x0FWa<\x0Ea1EV[[`\0a<\x1D\x84\x82\x85\x01a;\xE4V[\x91PP\x92\x91PPV[`\x03\x81\x10a<3W`\0\x80\xFD[PV[`\0\x81Q\x90Pa\x14a\x07oW\x80c\xCF\t\xE0\xD0\x14a\x07\x9AW\x80c\xD2\x17{\xDD\x14a\x07\xC5Wa\x020V[\x80c\x8B\x85\x90+\x11a\0\xF2W\x80c\x8B\x85\x90+\x14a\x060W\x80c\x99s^2\x14a\x06[W\x80c\xBB\xDC\x02\xDB\x14a\x06\x86W\x80c\xBC\xBEP\x94\x14a\x06\xB1W\x80c\xBC\xEF;U\x14a\x06\xDCWa\x020V[\x80cm\x9A\x1C\x8B\x14a\x05\x8EW\x80cp\x87*\xA5\x14a\x05\xB9W\x80cxk\x84K\x14a\x05\xE4W\x80cyHi\n\x14a\x05\xFBW\x80c\x81)\xFC\x1C\x14a\x06&Wa\x020V[\x80c>\xC4\xD4\xD6\x11a\x01\xBCW\x80c\\\x0C\xBA3\x11a\x01\x80W\x80c\\\x0C\xBA3\x14a\x04\xB9W\x80c`\x9D34\x14a\x04\xE4W\x80c`\xE2td\x14a\x05\x0FW\x80ccaPm\x14a\x058W\x80ch\xCC\xDC\x86\x14a\x05cWa\x020V[\x80c>\xC4\xD4\xD6\x14a\x03\xCAW\x80cR\x9Dj\x8C\x14a\x03\xFAW\x80cR\xA0\x7F\xA3\x14a\x047W\x80cT\xFDMP\x14a\x04bW\x80cW\xDA\x95\x0E\x14a\x04\x8DWa\x020V[\x80c(\x10\xE1\xD6\x11a\x02\x03W\x80c(\x10\xE1\xD6\x14a\x02\xE1W\x80c+1\x84\x1E\x14a\x03\x0CW\x80c7[\xFA]\x14a\x037W\x80c7\x8D\xD4\x8C\x14a\x03tW\x80c7\xB1\xB2)\x14a\x03\x9FWa\x020V[\x80c\x19\xEF\xFE\xB4\x14a\x025W\x80c \r.\xD2\x14a\x02`W\x80c%\x0Ei\xBD\x14a\x02\x8BW\x80c%\xFC*\xCE\x14a\x02\xB6W[`\0\x80\xFD[4\x80\x15a\x02AW`\0\x80\xFD[Pa\x02Ja\x08\xCEV[`@Qa\x02W\x91\x90a/\xF2V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02lW`\0\x80\xFD[Pa\x02ua\x08\xE8V[`@Qa\x02\x82\x91\x90a0\x84V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\x97W`\0\x80\xFD[Pa\x02\xA0a\x08\xFBV[`@Qa\x02\xAD\x91\x90a0\xBAV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xC2W`\0\x80\xFD[Pa\x02\xCBa\t\x0EV[`@Qa\x02\xD8\x91\x90a1\0V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\xEDW`\0\x80\xFD[Pa\x02\xF6a\t\x1BV[`@Qa\x03\x03\x91\x90a0\x84V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x18W`\0\x80\xFD[Pa\x03!a\x10hV[`@Qa\x03.\x91\x90a1*V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03CW`\0\x80\xFD[Pa\x03^`\x04\x806\x03\x81\x01\x90a\x03Y\x91\x90a1\xB4V[a\x10\x90V[`@Qa\x03k\x91\x90a2IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x80W`\0\x80\xFD[Pa\x03\x89a\x13\xCFV[`@Qa\x03\x96\x91\x90a2\xACV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xABW`\0\x80\xFD[Pa\x03\xB4a\x13\xE2V[`@Qa\x03\xC1\x91\x90a3\x08V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xD6W`\0\x80\xFD[Pa\x03\xDFa\x13\xF3V[`@Qa\x03\xF1\x96\x95\x94\x93\x92\x91\x90a3QV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x06W`\0\x80\xFD[Pa\x04!`\x04\x806\x03\x81\x01\x90a\x04\x1C\x91\x90a3\xDEV[a\x14\x8EV[`@Qa\x04.\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04CW`\0\x80\xFD[Pa\x04La\x14\xA6V[`@Qa\x04Y\x91\x90a4\x94V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04nW`\0\x80\xFD[Pa\x04wa\x14\xCEV[`@Qa\x04\x84\x91\x90a5HV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x99W`\0\x80\xFD[Pa\x04\xA2a\x15\x07V[`@Qa\x04\xB0\x92\x91\x90a5jV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xC5W`\0\x80\xFD[Pa\x04\xCEa\x15\x19V[`@Qa\x04\xDB\x91\x90a5\xB4V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xF0W`\0\x80\xFD[Pa\x04\xF9a\x15AV[`@Qa\x05\x06\x91\x90a6$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\x1BW`\0\x80\xFD[Pa\x056`\x04\x806\x03\x81\x01\x90a\x051\x91\x90a3\xDEV[a\x15TV[\0[4\x80\x15a\x05DW`\0\x80\xFD[Pa\x05Ma\x18\0V[`@Qa\x05Z\x91\x90a1\0V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05oW`\0\x80\xFD[Pa\x05xa\x18\x11V[`@Qa\x05\x85\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\x9AW`\0\x80\xFD[Pa\x05\xA3a\x189V[`@Qa\x05\xB0\x91\x90a1*V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\xC5W`\0\x80\xFD[Pa\x05\xCEa\x18aV[`@Qa\x05\xDB\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\xF0W`\0\x80\xFD[Pa\x05\xF9a\x18nV[\0[4\x80\x15a\x06\x07W`\0\x80\xFD[Pa\x06\x10a\x1B\xF8V[`@Qa\x06\x1D\x91\x90a6FV[`@Q\x80\x91\x03\x90\xF3[a\x06.a\x1C\tV[\0[4\x80\x15a\x06W`\0\x80\xFD[Pa\x07Y`\x04\x806\x03\x81\x01\x90a\x07T\x91\x90a3\xDEV[a(:V[`@Qa\x07f\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07{W`\0\x80\xFD[Pa\x07\x84a(RV[`@Qa\x07\x91\x91\x90a1*V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07\xA6W`\0\x80\xFD[Pa\x07\xAFa(zV[`@Qa\x07\xBC\x91\x90a/\xF2V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07\xD1W`\0\x80\xFD[Pa\x07\xDAa(\x92V[`@Qa\x07\xE7\x91\x90a6\xBCV[`@Q\x80\x91\x03\x90\xF3[a\x07\xF8a(\xBAV[`@Qa\x08\x05\x91\x90a2IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\x1AW`\0\x80\xFD[Pa\x085`\x04\x806\x03\x81\x01\x90a\x080\x91\x90a3\xDEV[a,MV[`@Qa\x08B\x91\x90a4$V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08WW`\0\x80\xFD[Pa\x08`a-\x18V[`@Qa\x08m\x91\x90a7\x13V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\x82W`\0\x80\xFD[Pa\x08\x8Ba-@V[`@Qa\x08\x9A\x93\x92\x91\x90a7.V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\xAFW`\0\x80\xFD[Pa\x08\xB8a-hV[`@Qa\x08\xC5\x91\x90a7\x8DV[`@Q\x80\x91\x03\x90\xF3[`\0`\x08\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\t`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0`\x07`\0\x01T\x90P\x90V[`\0\x80`\x02\x81\x11\x15a\t0Wa\t/a0\rV[[`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\tRWa\tQa0\rV[[\x14a\t\x89W`@Q\x7F\xF1\xA9E\x81\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\t\x93a-\x90V[\x90P`\0`\x02\x81\x11\x15a\t\xA9Wa\t\xA8a0\rV[[\x81`\x02\x81\x11\x15a\t\xBCWa\t\xBBa0\rV[[\x03a\t\xF3W`@Q\x7F\x92\xC5\x06\xAE\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x02\x81\x11\x15a\n\x07Wa\n\x06a0\rV[[\x81`\x02\x81\x11\x15a\n\x1AWa\n\x19a0\rV[[\x03a\n\xB8W`\x01`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\nEWa\nDa0\rV[[\x02\x17\x90UPG`\x05`\0`\x01`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0F\xADV[a\n\xC0a'\x95V[a\n\xF6W`@Q\x7F\x04d<9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`\x04\x81\x11\x15a\x0B\nWa\x0B\ta0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a\x0B/Wa\x0B.a0\rV[[\x03a\x0B\xAFW`\x02`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x0BZWa\x0BYa0\rV[[\x02\x17\x90UPG`\x05`\0a\x0Bla\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0F\xACV[`\x01`\x04\x81\x11\x15a\x0B\xC3Wa\x0B\xC2a0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a\x0B\xE8Wa\x0B\xE7a0\rV[[\x03a\x0C\x86W`\x01`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x0C\x13Wa\x0C\x12a0\rV[[\x02\x17\x90UPG`\x05`\0`\x01`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0F\xABV[`\x02`\x04\x81\x11\x15a\x0C\x9AWa\x0C\x99a0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a\x0C\xBFWa\x0C\xBEa0\rV[[\x03a\r?W`\x02`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x0C\xEAWa\x0C\xE9a0\rV[[\x02\x17\x90UPG`\x05`\0a\x0C\xFCa\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0F\xAAV[`\x03`\x04\x81\x11\x15a\rSWa\rRa0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a\rxWa\rwa0\rV[[\x03a\x0FwW`\x02`\0`\x10a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\r\xA3Wa\r\xA2a0\rV[[\x02\x17\x90UPa\r\xB0a\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x0EsWG`\x05`\0`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPa\x0FrV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x05`\0`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0Ga\x0F'\x91\x90a7\xD7V[`\x05`\0a\x0F3a\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP[a\x0F\xA9V[`@Q\x7Ft\x92\xA2i\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[[[[[`\x04`\x01`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a\x0F\xD6Wa\x0F\xD5a0\rV[[\x02\x17\x90UPB`\0`\x08a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x10&Wa\x10%a0\rV[[\x7F^\x18o\t\xB9\xC94\x91\xF1N'~\xEA\x7F\xAA]\xE6\xA2\xD4\xBD\xA7Zy\xAFz6\x84\xFB\xFBB\xDA``@Q`@Q\x80\x91\x03\x90\xA2`\0`\x10\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x91PP\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0a\x10\x9Aa'\x95V[\x15a\x10\xD1W`@Q\x7F\xDFF\x9C\xCB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`@Q\x80`\xE0\x01`@R\x80a\x10\xE6a\x18\0V[\x81R` \x01`\x07`\0\x01T\x81R` \x01a\x11\x06a\x11\x01a'\x84V[a.\xD2V[\x81R` \x01a\x11\x13a'#V[\x81R` \x01\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` \x01\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R` \x013s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90P\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cAI<`\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83`@Q` \x01a\x11\xEE\x91\x90a8\xC6V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x87\x87`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12\x1E\x94\x93\x92\x91\x90a9\x1DV[`\0`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x126W`\0\x80\xFD[PZ\xFA\x15\x80\x15a\x12JW=`\0\x80>=`\0\xFD[PPPP3`\x01\x80\x01`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x13\x1DW`\x02`\x01`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a\x13\x13Wa\x13\x12a0\rV[[\x02\x17\x90UPa\x13LV[`\x03`\x01`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a\x13FWa\x13Ea0\rV[[\x02\x17\x90UP[`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F^ee\xD9\xCA/\\\x85\x01\xD6A\x8B\xF5c2*rC\xBAz\xCE&mu\xEA\xC9\x9FJ\xDB\xB3\x0B\xA7`@Q`@Q\x80\x91\x03\x90\xA2`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x91PP\x92\x91PPV[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0a\x13\xEE`\0a.\xDCV[\x90P\x90V[`\x01\x80`\0\x01`\0\x90T\x90a\x01\0\n\x90\x04c\xFF\xFF\xFF\xFF\x16\x90\x80`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x80`\x01\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x80`\x02\x01T\x90\x80`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x90\x80`\x03\x01`\x01\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x86V[`\x05` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F2.0.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\x07\x80`\0\x01T\x90\x80`\x01\x01T\x90P\x82V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[``a\x15O`T`$a.\xF8V[\x90P\x90V[a\x15\\a\x18nV[`\0`\x02\x80\x81\x11\x15a\x15qWa\x15pa0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x15\x93Wa\x15\x92a0\rV[[\x03a\x15\xDFW`\x06`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90Pa\x16\x94V[`\x01`\x02\x81\x11\x15a\x15\xF3Wa\x15\xF2a0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x16\x15Wa\x16\x14a0\rV[[\x03a\x16aW`\x05`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90Pa\x16\x93V[`@Q\x7F\x07\x8A=\xF4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[[`\0\x81\x03a\x16\xCEW`@Q\x7F\x17\xBF\xE5\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`\x06`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP`\0`\x05`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP`\0\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82`@Qa\x17~\x90a9\x95V[`\0`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80`\0\x81\x14a\x17\xBBW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\x17\xC0V[``\x91P[PP\x90P\x80a\x17\xFBW`@Q\x7F\x83\xE6\xCCk\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPV[`\0a\x18\x0C`4a/0V[\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0`\x07`\x01\x01T\x90P\x90V[`\x02\x80\x81\x11\x15a\x18\x81Wa\x18\x80a0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x18\xA3Wa\x18\xA2a0\rV[[\x14\x80a\x18\xE2WP`\x01`\x02\x81\x11\x15a\x18\xBEWa\x18\xBDa0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x18\xE0Wa\x18\xDFa0\rV[[\x14[a\x1B\xF6W`\0`\x02\x81\x11\x15a\x18\xFAWa\x18\xF9a0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a\x19\x1CWa\x19\x1Ba0\rV[[\x14a\x19SW`@Q\x7F\x07\x8A=\xF4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x03\x14\xD2\xB30`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x19\xAE\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\xCBW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19\xEF\x91\x90a:\x12V[\x90P\x80a\x1A(W`@Q\x7FHQ\xBD\x9B\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x17\xCF!\xA90`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1A\x81\x91\x90a9\xCBV[`\0`@Q\x80\x83\x03\x81`\0\x87\x80;\x15\x80\x15a\x1A\x9BW`\0\x80\xFD[PZ\xF1\x92PPP\x80\x15a\x1A\xACWP`\x01[P`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cIk\x9C\x160`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1B\x08\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1B%W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1BI\x91\x90a:\x12V[\x90P\x80\x15a\x1B\x81W`\x01`\t`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x1BwWa\x1Bva0\rV[[\x02\x17\x90UPa\x1B\xADV[`\x02`\t`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x02\x81\x11\x15a\x1B\xA7Wa\x1B\xA6a0\rV[[\x02\x17\x90UP[\x7F\x99\x08\xEA\xAC\x06E\xDF\x9D\x07\x04\xD0j\xDC\x9E\x073|\x95\x1D\xE2\xF0k_(6\x15\x1DH\xD5\xE4r/`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`@Qa\x1B\xEB\x91\x90a2\xACV[`@Q\x80\x91\x03\x90\xA1PP[V[`\0a\x1C\x04`ta/IV[\x90P\x90V[`\0`\x11\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a\x1CPW`@Q\x7F\r\xC1I\xF0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x1C\xD5W`@Q\x7F\x94\r8\xC7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x1D2%\xE3a\x1D\x19a\x13\xE2V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1D5\x91\x90a3\x08V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1DRW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1Dv\x91\x90a:\x12V[a\x1D\xACW`@Q\x7F\xD3\x86\xEF>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`~6\x14a\x1D\xC2Wc\x98$\xBD\xAB`\0R`\x04`\x1C\xFD[c\xFF\xFF\xFF\xFF\x80\x16a\x1D\xD1a\x1B\xF8V[c\xFF\xFF\xFF\xFF\x16\x14a\"{W`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBB\x8A\xA1\xFCa\x1E\"a\x1B\xF8V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E>\x91\x90a:pV[```@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1E[W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1E\x7F\x91\x90a;!V[\x92PPP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x04\xE5\x0F\xED\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1E\xDC\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1E\xF9W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1F\x1D\x91\x90a:\x12V[\x15\x80a\x1F\xBFWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c4\xA3F\xEA\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1F}\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1F\x9AW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1F\xBE\x91\x90a:\x12V[[\x80a `WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cYX\xA1\x93\x82`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a \x1E\x91\x90a9\xCBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a ;W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a _\x91\x90a:\x12V[[\x15a \x97W`@Q\x7F4a\x19\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x80`@\x01`@R\x80a!\x19\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBC\xEF;U`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a \xF0W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\x14\x91\x90a;\xA0V[a.\xD2V[\x81R` \x01\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x99s^2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a!iW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a!\x8D\x91\x90a;\xF9V[\x81RP`\x07`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U\x90PP`\x01`\x02\x81\x11\x15a!\xBDWa!\xBCa0\rV[[\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\"\x08W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\",\x91\x90aWa\"=a0\rV[[\x03a\"uW`@Q\x7F4a\x19\xF7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[Pa#OV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16crX\xA8\x07\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\"\xF4\x91\x90a6\x92V[`@\x80Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#\x10W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#4\x91\x90a<\xA4V[`\x07`\0\x01`\0`\x07`\x01\x01`\0\x84\x91\x90PU\x83\x91\x90PUPP[`\x07`\x01\x01Ta#]a'#V[\x11a#\xA6Wa#ja'\x84V[`@Q\x7F\xF4\x029\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a#\x9D\x91\x90a6\xD7V[`@Q\x80\x91\x03\x90\xFD[`@Q\x80`\xC0\x01`@R\x80a#\xB9a\x1B\xF8V[c\xFF\xFF\xFF\xFF\x16\x81R` \x01`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01a$\x06a'\x84V[\x81R` \x01`\0`\x04\x81\x11\x15a$\x1FWa$\x1Ea0\rV[[\x81R` \x01a$W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a/eV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16Ba$l\x91\x90a<\xE4V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP`\x01`\0\x82\x01Q\x81`\0\x01`\0a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83c\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP` \x82\x01Q\x81`\0\x01`\x04a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`@\x82\x01Q\x81`\x01\x01`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP``\x82\x01Q\x81`\x02\x01U`\x80\x82\x01Q\x81`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a%eWa%da0\rV[[\x02\x17\x90UP`\xA0\x82\x01Q\x81`\x03\x01`\x01a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x90PP`\x01`\0`\x11a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP4`\x06`\0a%\xC4a\x13\xE2V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x82Ta&\r\x91\x90a<\xE4V[\x92PP\x81\x90UPB`\0\x80a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0c\xFF\xFF\xFF\xFF\x16\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c<\x9F9|`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a&\xCEW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a&\xF2\x91\x90a=:V[c\xFF\xFF\xFF\xFF\x16\x14`\t`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPV[`\0a'\x1Ea'#V[\x90P\x90V[`\0a'/`Ta/oV[\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0a'\x90`\x14a/0V[\x90P\x90V[`\0Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a'\xCE`\x01`\x03\x01`\x01\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a/\x88V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10\x80a(5WP`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x80\x01`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x90P\x90V[`\x06` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80`\x04\x81\x11\x15a(\xCFWa(\xCEa0\rV[[`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x04\x81\x11\x15a(\xF4Wa(\xF3a0\rV[[\x14a)+W`@Q\x7F\x85\xC3E\xB0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFFY\xAE}3`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a)\x84\x91\x90a3\x08V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a)\xA1W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a)\xC5\x91\x90a:\x12V[a)\xFBW`@Q\x7F\xD3\x86\xEF>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a*\x03a'\x95V[\x15a*:W`@Q\x7F\xDFF\x9C\xCB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x004\x14a*\x93W`@Q\x7F\x86 \xAA\x19\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3`\x01`\0\x01`\x04a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\x01\x80`\x03\x01`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\x04\x81\x11\x15a*\xFFWa*\xFEa0\rV[[\x02\x17\x90UPa+7\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a/eV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16Ba+L\x91\x90a<\xE4V[`\x01`\x03\x01`\x01a\x01\0\n\x81T\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP4`\x06`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x82Ta+\xC6\x91\x90a<\xE4V[\x92PP\x81\x90UP`\x01`\0\x01`\x04\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x98\x02{8\x15?\x99\\K\x80*\\~ce\xBE\xE3\xAD\xDB%\xAFk)\x81\x8C\x0C0F\x84\xD8\x05,`@Q`@Q\x80\x91\x03\x90\xA2`\x01`\x03\x01`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x90P\x90V[`\0`\x02\x80\x81\x11\x15a,bWa,aa0\rV[[`\t`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16`\x02\x81\x11\x15a,\x84Wa,\x83a0\rV[[\x03a,\xD0W`\x06`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90Pa-\x13V[`\x05`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90P[\x91\x90PV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80``a-Ma'4V[\x92Pa-Wa'\x84V[\x91Pa-aa\x15AV[\x90P\x90\x91\x92V[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0c\xFF\xFF\xFF\xFF\x80\x16a-\xA1a\x1B\xF8V[c\xFF\xFF\xFF\xFF\x16\x14a.\xCAW`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xBB\x8A\xA1\xFCa-\xF2a\x1B\xF8V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a.\x0E\x91\x90a:pV[```@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a.+W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a.O\x91\x90a;!V[\x92PPP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c \r.\xD2`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a.\x9EW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a.\xC2\x91\x90a\x81\x84a5\xEBV[\x90P\x92\x91PPV[`\0` \x82\x01\x90Pa6[`\0\x83\x01\x84a33V[\x92\x91PPV[`\0a6|a6wa6r\x84a3#V[a/\xB7V[a3#V[\x90P\x91\x90PV[a6\x8C\x81a6aV[\x82RPPV[`\0` \x82\x01\x90Pa6\xA7`\0\x83\x01\x84a6\x83V[\x92\x91PPV[a6\xB6\x81a/\xC1V[\x82RPPV[`\0` \x82\x01\x90Pa6\xD1`\0\x83\x01\x84a6\xADV[\x92\x91PPV[`\0` \x82\x01\x90Pa6\xEC`\0\x83\x01\x84a3BV[\x92\x91PPV[`\0a6\xFD\x82a4aV[\x90P\x91\x90PV[a7\r\x81a6\xF2V[\x82RPPV[`\0` \x82\x01\x90Pa7(`\0\x83\x01\x84a7\x04V[\x92\x91PPV[`\0``\x82\x01\x90Pa7C`\0\x83\x01\x86a6\x83V[a7P` \x83\x01\x85a3BV[\x81\x81\x03`@\x83\x01Ra7b\x81\x84a5\xEBV[\x90P\x94\x93PPPPV[`\0a7w\x82a4aV[\x90P\x91\x90PV[a7\x87\x81a7lV[\x82RPPV[`\0` \x82\x01\x90Pa7\xA2`\0\x83\x01\x84a7~V[\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x11`\x04R`$`\0\xFD[`\0a7\xE2\x82a4\x0BV[\x91Pa7\xED\x83a4\x0BV[\x92P\x82\x82\x10\x15a8\0Wa7\xFFa7\xA8V[[\x82\x82\x03\x90P\x92\x91PPV[a8\x14\x81a0\xD5V[\x82RPPV[a8#\x81a4\x0BV[\x82RPPV[a82\x81a2\xE7V[\x82RPPV[`\xE0\x82\x01`\0\x82\x01Qa8N`\0\x85\x01\x82a8\x0BV[P` \x82\x01Qa8a` \x85\x01\x82a8\x0BV[P`@\x82\x01Qa8t`@\x85\x01\x82a8\x0BV[P``\x82\x01Qa8\x87``\x85\x01\x82a8\x1AV[P`\x80\x82\x01Qa8\x9A`\x80\x85\x01\x82a8\x0BV[P`\xA0\x82\x01Qa8\xAD`\xA0\x85\x01\x82a8\x0BV[P`\xC0\x82\x01Qa8\xC0`\xC0\x85\x01\x82a8)V[PPPPV[`\0`\xE0\x82\x01\x90Pa8\xDB`\0\x83\x01\x84a88V[\x92\x91PPV[\x82\x81\x837`\0\x83\x83\x01RPPPV[`\0a8\xFC\x83\x85a5\xDAV[\x93Pa9\t\x83\x85\x84a8\xE1V[a9\x12\x83a4\xFEV[\x84\x01\x90P\x93\x92PPPV[`\0``\x82\x01\x90Pa92`\0\x83\x01\x87a1\x1BV[\x81\x81\x03` \x83\x01Ra9D\x81\x86a5\xEBV[\x90P\x81\x81\x03`@\x83\x01Ra9Y\x81\x84\x86a8\xF0V[\x90P\x95\x94PPPPPV[`\0\x81\x90P\x92\x91PPV[PV[`\0a9\x7F`\0\x83a9dV[\x91Pa9\x8A\x82a9oV[`\0\x82\x01\x90P\x91\x90PV[`\0a9\xA0\x82a9rV[\x91P\x81\x90P\x91\x90PV[`\0a9\xB5\x82a4aV[\x90P\x91\x90PV[a9\xC5\x81a9\xAAV[\x82RPPV[`\0` \x82\x01\x90Pa9\xE0`\0\x83\x01\x84a9\xBCV[\x92\x91PPV[a9\xEF\x81a0\x9FV[\x81\x14a9\xFAW`\0\x80\xFD[PV[`\0\x81Q\x90Pa:\x0C\x81a9\xE6V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a:(Wa:'a1EV[[`\0a:6\x84\x82\x85\x01a9\xFDV[\x91PP\x92\x91PPV[`\0a:Za:Ua:P\x84a3#V[a/\xB7V[a4\x0BV[\x90P\x91\x90PV[a:j\x81a:?V[\x82RPPV[`\0` \x82\x01\x90Pa:\x85`\0\x83\x01\x84a:aV[\x92\x91PPV[a:\x94\x81a3#V[\x81\x14a:\x9FW`\0\x80\xFD[PV[`\0\x81Q\x90Pa:\xB1\x81a:\x8BV[\x92\x91PPV[a:\xC0\x81a/\xA3V[\x81\x14a:\xCBW`\0\x80\xFD[PV[`\0\x81Q\x90Pa:\xDD\x81a:\xB7V[\x92\x91PPV[`\0a:\xEE\x82a2\xE7V[\x90P\x91\x90PV[a:\xFE\x81a:\xE3V[\x81\x14a;\tW`\0\x80\xFD[PV[`\0\x81Q\x90Pa;\x1B\x81a:\xF5V[\x92\x91PPV[`\0\x80`\0``\x84\x86\x03\x12\x15a;:Wa;9a1EV[[`\0a;H\x86\x82\x87\x01a:\xA2V[\x93PP` a;Y\x86\x82\x87\x01a:\xCEV[\x92PP`@a;j\x86\x82\x87\x01a;\x0CV[\x91PP\x92P\x92P\x92V[a;}\x81a0\xD5V[\x81\x14a;\x88W`\0\x80\xFD[PV[`\0\x81Q\x90Pa;\x9A\x81a;tV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a;\xB6Wa;\xB5a1EV[[`\0a;\xC4\x84\x82\x85\x01a;\x8BV[\x91PP\x92\x91PPV[a;\xD6\x81a4\x0BV[\x81\x14a;\xE1W`\0\x80\xFD[PV[`\0\x81Q\x90Pa;\xF3\x81a;\xCDV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a<\x0FWa<\x0Ea1EV[[`\0a<\x1D\x84\x82\x85\x01a;\xE4V[\x91PP\x92\x91PPV[`\x03\x81\x10a<3W`\0\x80\xFD[PV[`\0\x81Q\x90Pa for u8 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<8>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl BondDistributionMode { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u8) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u8 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for BondDistributionMode { + fn from(value: u8) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u8 { + fn from(value: BondDistributionMode) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for BondDistributionMode { + type RustType = u8; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for BondDistributionMode { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameStatus(u8); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u8 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<8>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameStatus { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u8) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u8 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameStatus { + fn from(value: u8) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u8 { + fn from(value: GameStatus) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameStatus { + type RustType = u8; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameStatus { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProposalStatus(u8); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u8 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<8>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl ProposalStatus { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u8) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u8 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for ProposalStatus { + fn from(value: u8) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u8 { + fn from(value: ProposalStatus) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for ProposalStatus { + type RustType = u8; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for ProposalStatus { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Claim(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Claim { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Claim { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Claim) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Claim { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Claim { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Duration(u64); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u64 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<64>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Duration { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u64) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u64 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Duration { + fn from(value: u64) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u64 { + fn from(value: Duration) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Duration { + type RustType = u64; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Duration { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameType(u32); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u32 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl GameType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u32) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u32 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for GameType { + fn from(value: u32) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u32 { + fn from(value: GameType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for GameType { + type RustType = u32; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for GameType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Hash(alloy::sol_types::private::FixedBytes<32>); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue + for alloy::sol_types::private::FixedBytes<32> { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::FixedBytes<32>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Hash { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying( + value: alloy::sol_types::private::FixedBytes<32>, + ) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying( + self, + ) -> alloy::sol_types::private::FixedBytes<32> { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From> for Hash { + fn from(value: alloy::sol_types::private::FixedBytes<32>) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for alloy::sol_types::private::FixedBytes<32> { + fn from(value: Hash) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Hash { + type RustType = alloy::sol_types::private::FixedBytes<32>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Hash { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Timestamp(u64); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u64 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<64>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl Timestamp { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u64) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u64 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for Timestamp { + fn from(value: u64) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u64 { + fn from(value: Timestamp) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Timestamp { + type RustType = u64; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Timestamp { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**Custom error with signature `AlreadyInitialized()` and selector `0x0dc149f0`. +```solidity +error AlreadyInitialized(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct AlreadyInitialized; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: AlreadyInitialized) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for AlreadyInitialized { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for AlreadyInitialized { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "AlreadyInitialized()"; + const SELECTOR: [u8; 4] = [13u8, 193u8, 73u8, 240u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `BadAuth()` and selector `0xd386ef3e`. +```solidity +error BadAuth(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BadAuth; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: BadAuth) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for BadAuth { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for BadAuth { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "BadAuth()"; + const SELECTOR: [u8; 4] = [211u8, 134u8, 239u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `BondTransferFailed()` and selector `0x83e6cc6b`. +```solidity +error BondTransferFailed(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BondTransferFailed; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: BondTransferFailed) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for BondTransferFailed { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for BondTransferFailed { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "BondTransferFailed()"; + const SELECTOR: [u8; 4] = [131u8, 230u8, 204u8, 107u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ClaimAlreadyChallenged()` and selector `0x85c345b0`. +```solidity +error ClaimAlreadyChallenged(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ClaimAlreadyChallenged; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ClaimAlreadyChallenged) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ClaimAlreadyChallenged { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ClaimAlreadyChallenged { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ClaimAlreadyChallenged()"; + const SELECTOR: [u8; 4] = [133u8, 195u8, 69u8, 176u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ClaimAlreadyResolved()` and selector `0xf1a94581`. +```solidity +error ClaimAlreadyResolved(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ClaimAlreadyResolved; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ClaimAlreadyResolved) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ClaimAlreadyResolved { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ClaimAlreadyResolved { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ClaimAlreadyResolved()"; + const SELECTOR: [u8; 4] = [241u8, 169u8, 69u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `GameNotFinalized()` and selector `0x4851bd9b`. +```solidity +error GameNotFinalized(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameNotFinalized; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameNotFinalized) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameNotFinalized { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameNotFinalized { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameNotFinalized()"; + const SELECTOR: [u8; 4] = [72u8, 81u8, 189u8, 155u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `GameNotOver()` and selector `0x04643c39`. +```solidity +error GameNotOver(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameNotOver; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameNotOver) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameNotOver { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameNotOver { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameNotOver()"; + const SELECTOR: [u8; 4] = [4u8, 100u8, 60u8, 57u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `GameOver()` and selector `0xdf469ccb`. +```solidity +error GameOver(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GameOver; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: GameOver) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for GameOver { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for GameOver { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GameOver()"; + const SELECTOR: [u8; 4] = [223u8, 70u8, 156u8, 203u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `IncorrectBondAmount()` and selector `0x8620aa19`. +```solidity +error IncorrectBondAmount(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IncorrectBondAmount; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IncorrectBondAmount) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IncorrectBondAmount { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for IncorrectBondAmount { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IncorrectBondAmount()"; + const SELECTOR: [u8; 4] = [134u8, 32u8, 170u8, 25u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `IncorrectDisputeGameFactory()` and selector `0x940d38c7`. +```solidity +error IncorrectDisputeGameFactory(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IncorrectDisputeGameFactory; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: IncorrectDisputeGameFactory) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for IncorrectDisputeGameFactory { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for IncorrectDisputeGameFactory { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IncorrectDisputeGameFactory()"; + const SELECTOR: [u8; 4] = [148u8, 13u8, 56u8, 199u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidBondDistributionMode()` and selector `0x078a3df4`. +```solidity +error InvalidBondDistributionMode(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidBondDistributionMode; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: InvalidBondDistributionMode) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for InvalidBondDistributionMode { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidBondDistributionMode { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidBondDistributionMode()"; + const SELECTOR: [u8; 4] = [7u8, 138u8, 61u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidParentGame()` and selector `0x346119f7`. +```solidity +error InvalidParentGame(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidParentGame; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidParentGame) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidParentGame { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidParentGame { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidParentGame()"; + const SELECTOR: [u8; 4] = [52u8, 97u8, 25u8, 247u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `InvalidProposalStatus()` and selector `0x7492a269`. +```solidity +error InvalidProposalStatus(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InvalidProposalStatus; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InvalidProposalStatus) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InvalidProposalStatus { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for InvalidProposalStatus { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "InvalidProposalStatus()"; + const SELECTOR: [u8; 4] = [116u8, 146u8, 162u8, 105u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `NoCreditToClaim()` and selector `0x17bfe5f7`. +```solidity +error NoCreditToClaim(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct NoCreditToClaim; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: NoCreditToClaim) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for NoCreditToClaim { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for NoCreditToClaim { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "NoCreditToClaim()"; + const SELECTOR: [u8; 4] = [23u8, 191u8, 229u8, 247u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ParentGameNotResolved()` and selector `0x92c506ae`. +```solidity +error ParentGameNotResolved(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ParentGameNotResolved; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ParentGameNotResolved) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ParentGameNotResolved { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ParentGameNotResolved { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ParentGameNotResolved()"; + const SELECTOR: [u8; 4] = [146u8, 197u8, 6u8, 174u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `UnexpectedRootClaim(bytes32)` and selector `0xf40239db`. +```solidity +error UnexpectedRootClaim(Claim rootClaim); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct UnexpectedRootClaim { + #[allow(missing_docs)] + pub rootClaim: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Claim,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (::RustType,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: UnexpectedRootClaim) -> Self { + (value.rootClaim,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for UnexpectedRootClaim { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { rootClaim: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for UnexpectedRootClaim { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "UnexpectedRootClaim(bytes32)"; + const SELECTOR: [u8; 4] = [244u8, 2u8, 57u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self.rootClaim),) + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Event with signature `Challenged(address)` and selector `0x98027b38153f995c4b802a5c7e6365bee3addb25af6b29818c0c304684d8052c`. +```solidity +event Challenged(address indexed challenger); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Challenged { + #[allow(missing_docs)] + pub challenger: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Challenged { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "Challenged(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 152u8, 2u8, 123u8, 56u8, 21u8, 63u8, 153u8, 92u8, 75u8, 128u8, 42u8, + 92u8, 126u8, 99u8, 101u8, 190u8, 227u8, 173u8, 219u8, 37u8, 175u8, 107u8, + 41u8, 129u8, 140u8, 12u8, 48u8, 70u8, 132u8, 216u8, 5u8, 44u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { challenger: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.challenger.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.challenger, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Challenged { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Challenged> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Challenged) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `GameClosed(uint8)` and selector `0x9908eaac0645df9d0704d06adc9e07337c951de2f06b5f2836151d48d5e4722f`. +```solidity +event GameClosed(BondDistributionMode bondDistributionMode); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct GameClosed { + #[allow(missing_docs)] + pub bondDistributionMode: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for GameClosed { + type DataTuple<'a> = (BondDistributionMode,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "GameClosed(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 153u8, 8u8, 234u8, 172u8, 6u8, 69u8, 223u8, 157u8, 7u8, 4u8, 208u8, + 106u8, 220u8, 158u8, 7u8, 51u8, 124u8, 149u8, 29u8, 226u8, 240u8, 107u8, + 95u8, 40u8, 54u8, 21u8, 29u8, 72u8, 213u8, 228u8, 114u8, 47u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + bondDistributionMode: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.bondDistributionMode, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for GameClosed { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&GameClosed> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &GameClosed) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Proved(address)` and selector `0x5e6565d9ca2f5c8501d6418bf563322a7243ba7ace266d75eac99f4adbb30ba7`. +```solidity +event Proved(address indexed prover); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Proved { + #[allow(missing_docs)] + pub prover: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Proved { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "Proved(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 94u8, 101u8, 101u8, 217u8, 202u8, 47u8, 92u8, 133u8, 1u8, 214u8, 65u8, + 139u8, 245u8, 99u8, 50u8, 42u8, 114u8, 67u8, 186u8, 122u8, 206u8, 38u8, + 109u8, 117u8, 234u8, 201u8, 159u8, 74u8, 219u8, 179u8, 11u8, 167u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { prover: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.prover.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.prover, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Proved { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Proved> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Proved) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Resolved(uint8)` and selector `0x5e186f09b9c93491f14e277eea7faa5de6a2d4bda75a79af7a3684fbfb42da60`. +```solidity +event Resolved(GameStatus indexed status); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Resolved { + #[allow(missing_docs)] + pub status: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Resolved { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>, GameStatus); + const SIGNATURE: &'static str = "Resolved(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { status: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.status.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.status, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Resolved { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Resolved> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Resolved) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(Duration _maxChallengeDuration, Duration _maxProveDuration, address _disputeGameFactory, address _sp1Verifier, bytes32 _rollupConfigHash, bytes32 _aggregationVkey, bytes32 _rangeVkeyCommitment, uint256 _challengerBond, address _anchorStateRegistry, address _accessManager); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _maxChallengeDuration: ::RustType, + #[allow(missing_docs)] + pub _maxProveDuration: ::RustType, + #[allow(missing_docs)] + pub _disputeGameFactory: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _sp1Verifier: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _challengerBond: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _anchorStateRegistry: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _accessManager: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + Duration, + Duration, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + ( + value._maxChallengeDuration, + value._maxProveDuration, + value._disputeGameFactory, + value._sp1Verifier, + value._rollupConfigHash, + value._aggregationVkey, + value._rangeVkeyCommitment, + value._challengerBond, + value._anchorStateRegistry, + value._accessManager, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _maxChallengeDuration: tuple.0, + _maxProveDuration: tuple.1, + _disputeGameFactory: tuple.2, + _sp1Verifier: tuple.3, + _rollupConfigHash: tuple.4, + _aggregationVkey: tuple.5, + _rangeVkeyCommitment: tuple.6, + _challengerBond: tuple.7, + _anchorStateRegistry: tuple.8, + _accessManager: tuple.9, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = ( + Duration, + Duration, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._maxChallengeDuration, + ), + ::tokenize( + &self._maxProveDuration, + ), + ::tokenize( + &self._disputeGameFactory, + ), + ::tokenize( + &self._sp1Verifier, + ), + as alloy_sol_types::SolType>::tokenize(&self._rollupConfigHash), + as alloy_sol_types::SolType>::tokenize(&self._aggregationVkey), + as alloy_sol_types::SolType>::tokenize(&self._rangeVkeyCommitment), + as alloy_sol_types::SolType>::tokenize(&self._challengerBond), + ::tokenize( + &self._anchorStateRegistry, + ), + ::tokenize( + &self._accessManager, + ), + ) + } + } + }; + /**Function with signature `accessManager()` and selector `0xfdcb6068`. +```solidity +function accessManager() external view returns (address accessManager_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct accessManagerCall; + ///Container type for the return parameters of the [`accessManager()`](accessManagerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct accessManagerReturn { + #[allow(missing_docs)] + pub accessManager_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: accessManagerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for accessManagerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: accessManagerReturn) -> Self { + (value.accessManager_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for accessManagerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { accessManager_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for accessManagerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "accessManager()"; + const SELECTOR: [u8; 4] = [253u8, 203u8, 96u8, 104u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: accessManagerReturn = r.into(); + r.accessManager_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: accessManagerReturn = r.into(); + r.accessManager_ + }) + } + } + }; + /**Function with signature `aggregationVkey()` and selector `0xc32e4e3e`. +```solidity +function aggregationVkey() external view returns (bytes32 aggregationVkey_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct aggregationVkeyCall; + ///Container type for the return parameters of the [`aggregationVkey()`](aggregationVkeyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct aggregationVkeyReturn { + #[allow(missing_docs)] + pub aggregationVkey_: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: aggregationVkeyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for aggregationVkeyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: aggregationVkeyReturn) -> Self { + (value.aggregationVkey_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for aggregationVkeyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { aggregationVkey_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for aggregationVkeyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "aggregationVkey()"; + const SELECTOR: [u8; 4] = [195u8, 46u8, 78u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: aggregationVkeyReturn = r.into(); + r.aggregationVkey_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: aggregationVkeyReturn = r.into(); + r.aggregationVkey_ + }) + } + } + }; + /**Function with signature `anchorStateRegistry()` and selector `0x5c0cba33`. +```solidity +function anchorStateRegistry() external view returns (address registry_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorStateRegistryCall; + ///Container type for the return parameters of the [`anchorStateRegistry()`](anchorStateRegistryCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct anchorStateRegistryReturn { + #[allow(missing_docs)] + pub registry_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: anchorStateRegistryCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for anchorStateRegistryCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: anchorStateRegistryReturn) -> Self { + (value.registry_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for anchorStateRegistryReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { registry_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for anchorStateRegistryCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "anchorStateRegistry()"; + const SELECTOR: [u8; 4] = [92u8, 12u8, 186u8, 51u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: anchorStateRegistryReturn = r.into(); + r.registry_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: anchorStateRegistryReturn = r.into(); + r.registry_ + }) + } + } + }; + /**Function with signature `bondDistributionMode()` and selector `0x378dd48c`. +```solidity +function bondDistributionMode() external view returns (BondDistributionMode); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct bondDistributionModeCall; + ///Container type for the return parameters of the [`bondDistributionMode()`](bondDistributionModeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct bondDistributionModeReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: bondDistributionModeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for bondDistributionModeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (BondDistributionMode,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: bondDistributionModeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for bondDistributionModeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for bondDistributionModeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (BondDistributionMode,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "bondDistributionMode()"; + const SELECTOR: [u8; 4] = [55u8, 141u8, 212u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: bondDistributionModeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: bondDistributionModeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `challenge()` and selector `0xd2ef7398`. +```solidity +function challenge() external payable returns (ProposalStatus); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengeCall; + ///Container type for the return parameters of the [`challenge()`](challengeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengeReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: challengeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for challengeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (ProposalStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: challengeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for challengeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for challengeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (ProposalStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "challenge()"; + const SELECTOR: [u8; 4] = [210u8, 239u8, 115u8, 152u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: challengeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: challengeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `challengerBond()` and selector `0x68ccdc86`. +```solidity +function challengerBond() external view returns (uint256 challengerBond_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengerBondCall; + ///Container type for the return parameters of the [`challengerBond()`](challengerBondCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengerBondReturn { + #[allow(missing_docs)] + pub challengerBond_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: challengerBondCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for challengerBondCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: challengerBondReturn) -> Self { + (value.challengerBond_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for challengerBondReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { challengerBond_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for challengerBondCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "challengerBond()"; + const SELECTOR: [u8; 4] = [104u8, 204u8, 220u8, 134u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: challengerBondReturn = r.into(); + r.challengerBond_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: challengerBondReturn = r.into(); + r.challengerBond_ + }) + } + } + }; + /**Function with signature `claimCredit(address)` and selector `0x60e27464`. +```solidity +function claimCredit(address _recipient) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimCreditCall { + #[allow(missing_docs)] + pub _recipient: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`claimCredit(address)`](claimCreditCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimCreditReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimCreditCall) -> Self { + (value._recipient,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimCreditCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _recipient: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimCreditReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimCreditReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl claimCreditReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for claimCreditCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = claimCreditReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "claimCredit(address)"; + const SELECTOR: [u8; 4] = [96u8, 226u8, 116u8, 100u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._recipient, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + claimCreditReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `claimData()` and selector `0x3ec4d4d6`. +```solidity +function claimData() external view returns (uint32 parentIndex, address counteredBy, address prover, Claim claim, ProposalStatus status, Timestamp deadline); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimDataCall; + ///Container type for the return parameters of the [`claimData()`](claimDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct claimDataReturn { + #[allow(missing_docs)] + pub parentIndex: u32, + #[allow(missing_docs)] + pub counteredBy: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub prover: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub claim: ::RustType, + #[allow(missing_docs)] + pub status: ::RustType, + #[allow(missing_docs)] + pub deadline: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + Claim, + ProposalStatus, + Timestamp, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + u32, + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + ::RustType, + ::RustType, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: claimDataReturn) -> Self { + ( + value.parentIndex, + value.counteredBy, + value.prover, + value.claim, + value.status, + value.deadline, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for claimDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + parentIndex: tuple.0, + counteredBy: tuple.1, + prover: tuple.2, + claim: tuple.3, + status: tuple.4, + deadline: tuple.5, + } + } + } + } + impl claimDataReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.parentIndex), + ::tokenize( + &self.counteredBy, + ), + ::tokenize( + &self.prover, + ), + ::tokenize(&self.claim), + ::tokenize(&self.status), + ::tokenize(&self.deadline), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for claimDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = claimDataReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + Claim, + ProposalStatus, + Timestamp, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "claimData()"; + const SELECTOR: [u8; 4] = [62u8, 196u8, 212u8, 214u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + claimDataReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `closeGame()` and selector `0x786b844b`. +```solidity +function closeGame() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct closeGameCall; + ///Container type for the return parameters of the [`closeGame()`](closeGameCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct closeGameReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: closeGameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for closeGameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: closeGameReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for closeGameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl closeGameReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for closeGameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = closeGameReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "closeGame()"; + const SELECTOR: [u8; 4] = [120u8, 107u8, 132u8, 75u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + closeGameReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `createdAt()` and selector `0xcf09e0d0`. +```solidity +function createdAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtCall; + ///Container type for the return parameters of the [`createdAt()`](createdAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createdAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createdAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createdAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createdAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "createdAt()"; + const SELECTOR: [u8; 4] = [207u8, 9u8, 224u8, 208u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createdAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `credit(address)` and selector `0xd5d44d80`. +```solidity +function credit(address _recipient) external view returns (uint256 credit_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct creditCall { + #[allow(missing_docs)] + pub _recipient: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`credit(address)`](creditCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct creditReturn { + #[allow(missing_docs)] + pub credit_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: creditCall) -> Self { + (value._recipient,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for creditCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _recipient: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: creditReturn) -> Self { + (value.credit_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for creditReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { credit_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for creditCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "credit(address)"; + const SELECTOR: [u8; 4] = [213u8, 212u8, 77u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._recipient, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: creditReturn = r.into(); + r.credit_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: creditReturn = r.into(); + r.credit_ + }) + } + } + }; + /**Function with signature `disputeGameFactory()` and selector `0xf2b4e617`. +```solidity +function disputeGameFactory() external view returns (address disputeGameFactory_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFactoryCall; + ///Container type for the return parameters of the [`disputeGameFactory()`](disputeGameFactoryCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFactoryReturn { + #[allow(missing_docs)] + pub disputeGameFactory_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFactoryCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFactoryCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFactoryReturn) -> Self { + (value.disputeGameFactory_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFactoryReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + disputeGameFactory_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameFactoryCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameFactory()"; + const SELECTOR: [u8; 4] = [242u8, 180u8, 230u8, 23u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameFactoryReturn = r.into(); + r.disputeGameFactory_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameFactoryReturn = r.into(); + r.disputeGameFactory_ + }) + } + } + }; + /**Function with signature `extraData()` and selector `0x609d3334`. +```solidity +function extraData() external pure returns (bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataCall; + ///Container type for the return parameters of the [`extraData()`](extraDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extraDataReturn { + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extraDataReturn) -> Self { + (value.extraData_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extraDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { extraData_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for extraDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Bytes; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "extraData()"; + const SELECTOR: [u8; 4] = [96u8, 157u8, 51u8, 52u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: extraDataReturn = r.into(); + r.extraData_ + }) + } + } + }; + /**Function with signature `gameCreator()` and selector `0x37b1b229`. +```solidity +function gameCreator() external pure returns (address creator_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorCall; + ///Container type for the return parameters of the [`gameCreator()`](gameCreatorCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameCreatorReturn { + #[allow(missing_docs)] + pub creator_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameCreatorReturn) -> Self { + (value.creator_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameCreatorReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { creator_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameCreatorCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameCreator()"; + const SELECTOR: [u8; 4] = [55u8, 177u8, 178u8, 41u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r.creator_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameCreatorReturn = r.into(); + r.creator_ + }) + } + } + }; + /**Function with signature `gameData()` and selector `0xfa24f743`. +```solidity +function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataCall; + ///Container type for the return parameters of the [`gameData()`](gameDataCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameDataReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + #[allow(missing_docs)] + pub rootClaim_: ::RustType, + #[allow(missing_docs)] + pub extraData_: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + GameType, + Claim, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::RustType, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameDataReturn) -> Self { + (value.gameType_, value.rootClaim_, value.extraData_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameDataReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + gameType_: tuple.0, + rootClaim_: tuple.1, + extraData_: tuple.2, + } + } + } + } + impl gameDataReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.gameType_), + ::tokenize(&self.rootClaim_), + ::tokenize( + &self.extraData_, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameDataCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = gameDataReturn; + type ReturnTuple<'a> = (GameType, Claim, alloy::sol_types::sol_data::Bytes); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameData()"; + const SELECTOR: [u8; 4] = [250u8, 36u8, 247u8, 67u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + gameDataReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `gameOver()` and selector `0xbdb337d1`. +```solidity +function gameOver() external view returns (bool gameOver_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameOverCall; + ///Container type for the return parameters of the [`gameOver()`](gameOverCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameOverReturn { + #[allow(missing_docs)] + pub gameOver_: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameOverCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameOverCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameOverReturn) -> Self { + (value.gameOver_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameOverReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { gameOver_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameOverCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameOver()"; + const SELECTOR: [u8; 4] = [189u8, 179u8, 55u8, 209u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameOverReturn = r.into(); + r.gameOver_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameOverReturn = r.into(); + r.gameOver_ + }) + } + } + }; + /**Function with signature `gameType()` and selector `0xbbdc02db`. +```solidity +function gameType() external view returns (GameType gameType_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeCall; + ///Container type for the return parameters of the [`gameType()`](gameTypeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct gameTypeReturn { + #[allow(missing_docs)] + pub gameType_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameType,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: gameTypeReturn) -> Self { + (value.gameType_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for gameTypeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { gameType_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for gameTypeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameType,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "gameType()"; + const SELECTOR: [u8; 4] = [187u8, 220u8, 2u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r.gameType_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: gameTypeReturn = r.into(); + r.gameType_ + }) + } + } + }; + /**Function with signature `initialize()` and selector `0x8129fc1c`. +```solidity +function initialize() external payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall; + ///Container type for the return parameters of the [`initialize()`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize()"; + const SELECTOR: [u8; 4] = [129u8, 41u8, 252u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `l1Head()` and selector `0x6361506d`. +```solidity +function l1Head() external pure returns (Hash l1Head_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadCall; + ///Container type for the return parameters of the [`l1Head()`](l1HeadCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l1HeadReturn { + #[allow(missing_docs)] + pub l1Head_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l1HeadReturn) -> Self { + (value.l1Head_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l1HeadReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l1Head_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l1HeadCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Hash,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l1Head()"; + const SELECTOR: [u8; 4] = [99u8, 97u8, 80u8, 109u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r.l1Head_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l1HeadReturn = r.into(); + r.l1Head_ + }) + } + } + }; + /**Function with signature `l2BlockNumber()` and selector `0x8b85902b`. +```solidity +function l2BlockNumber() external pure returns (uint256 l2BlockNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockNumberCall; + ///Container type for the return parameters of the [`l2BlockNumber()`](l2BlockNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockNumberReturn { + #[allow(missing_docs)] + pub l2BlockNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l2BlockNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l2BlockNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l2BlockNumberReturn) -> Self { + (value.l2BlockNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l2BlockNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l2BlockNumber_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2BlockNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2BlockNumber()"; + const SELECTOR: [u8; 4] = [139u8, 133u8, 144u8, 43u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2BlockNumberReturn = r.into(); + r.l2BlockNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2BlockNumberReturn = r.into(); + r.l2BlockNumber_ + }) + } + } + }; + /**Function with signature `l2SequenceNumber()` and selector `0x99735e32`. +```solidity +function l2SequenceNumber() external pure returns (uint256 l2SequenceNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberCall; + ///Container type for the return parameters of the [`l2SequenceNumber()`](l2SequenceNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2SequenceNumberReturn { + #[allow(missing_docs)] + pub l2SequenceNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: l2SequenceNumberReturn) -> Self { + (value.l2SequenceNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for l2SequenceNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { l2SequenceNumber_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2SequenceNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2SequenceNumber()"; + const SELECTOR: [u8; 4] = [153u8, 115u8, 94u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2SequenceNumberReturn = r.into(); + r.l2SequenceNumber_ + }) + } + } + }; + /**Function with signature `maxChallengeDuration()` and selector `0xd2177bdd`. +```solidity +function maxChallengeDuration() external view returns (Duration maxChallengeDuration_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct maxChallengeDurationCall; + ///Container type for the return parameters of the [`maxChallengeDuration()`](maxChallengeDurationCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct maxChallengeDurationReturn { + #[allow(missing_docs)] + pub maxChallengeDuration_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: maxChallengeDurationCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for maxChallengeDurationCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Duration,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: maxChallengeDurationReturn) -> Self { + (value.maxChallengeDuration_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for maxChallengeDurationReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + maxChallengeDuration_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for maxChallengeDurationCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Duration,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "maxChallengeDuration()"; + const SELECTOR: [u8; 4] = [210u8, 23u8, 123u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: maxChallengeDurationReturn = r.into(); + r.maxChallengeDuration_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: maxChallengeDurationReturn = r.into(); + r.maxChallengeDuration_ + }) + } + } + }; + /**Function with signature `maxProveDuration()` and selector `0xbcbe5094`. +```solidity +function maxProveDuration() external view returns (Duration maxProveDuration_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct maxProveDurationCall; + ///Container type for the return parameters of the [`maxProveDuration()`](maxProveDurationCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct maxProveDurationReturn { + #[allow(missing_docs)] + pub maxProveDuration_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: maxProveDurationCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for maxProveDurationCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Duration,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: maxProveDurationReturn) -> Self { + (value.maxProveDuration_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for maxProveDurationReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { maxProveDuration_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for maxProveDurationCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Duration,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "maxProveDuration()"; + const SELECTOR: [u8; 4] = [188u8, 190u8, 80u8, 148u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: maxProveDurationReturn = r.into(); + r.maxProveDuration_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: maxProveDurationReturn = r.into(); + r.maxProveDuration_ + }) + } + } + }; + /**Function with signature `normalModeCredit(address)` and selector `0x529d6a8c`. +```solidity +function normalModeCredit(address) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct normalModeCreditCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`normalModeCredit(address)`](normalModeCreditCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct normalModeCreditReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: normalModeCreditCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for normalModeCreditCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: normalModeCreditReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for normalModeCreditReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for normalModeCreditCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "normalModeCredit(address)"; + const SELECTOR: [u8; 4] = [82u8, 157u8, 106u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: normalModeCreditReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: normalModeCreditReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `parentIndex()` and selector `0x7948690a`. +```solidity +function parentIndex() external pure returns (uint32 parentIndex_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct parentIndexCall; + ///Container type for the return parameters of the [`parentIndex()`](parentIndexCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct parentIndexReturn { + #[allow(missing_docs)] + pub parentIndex_: u32, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: parentIndexCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for parentIndexCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u32,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: parentIndexReturn) -> Self { + (value.parentIndex_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for parentIndexReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { parentIndex_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for parentIndexCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u32; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "parentIndex()"; + const SELECTOR: [u8; 4] = [121u8, 72u8, 105u8, 10u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: parentIndexReturn = r.into(); + r.parentIndex_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: parentIndexReturn = r.into(); + r.parentIndex_ + }) + } + } + }; + /**Function with signature `prove(bytes)` and selector `0x375bfa5d`. +```solidity +function prove(bytes memory proofBytes) external returns (ProposalStatus); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proveCall { + #[allow(missing_docs)] + pub proofBytes: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`prove(bytes)`](proveCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proveReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proveCall) -> Self { + (value.proofBytes,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { proofBytes: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (ProposalStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proveReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proveReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proveCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (ProposalStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "prove(bytes)"; + const SELECTOR: [u8; 4] = [55u8, 91u8, 250u8, 93u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.proofBytes, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proveReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proveReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `rangeVkeyCommitment()` and selector `0x2b31841e`. +```solidity +function rangeVkeyCommitment() external view returns (bytes32 rangeVkeyCommitment_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rangeVkeyCommitmentCall; + ///Container type for the return parameters of the [`rangeVkeyCommitment()`](rangeVkeyCommitmentCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rangeVkeyCommitmentReturn { + #[allow(missing_docs)] + pub rangeVkeyCommitment_: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: rangeVkeyCommitmentCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for rangeVkeyCommitmentCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: rangeVkeyCommitmentReturn) -> Self { + (value.rangeVkeyCommitment_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for rangeVkeyCommitmentReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + rangeVkeyCommitment_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for rangeVkeyCommitmentCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "rangeVkeyCommitment()"; + const SELECTOR: [u8; 4] = [43u8, 49u8, 132u8, 30u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: rangeVkeyCommitmentReturn = r.into(); + r.rangeVkeyCommitment_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: rangeVkeyCommitmentReturn = r.into(); + r.rangeVkeyCommitment_ + }) + } + } + }; + /**Function with signature `refundModeCredit(address)` and selector `0xc0d8bb74`. +```solidity +function refundModeCredit(address) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct refundModeCreditCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`refundModeCredit(address)`](refundModeCreditCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct refundModeCreditReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: refundModeCreditCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for refundModeCreditCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: refundModeCreditReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for refundModeCreditReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for refundModeCreditCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "refundModeCredit(address)"; + const SELECTOR: [u8; 4] = [192u8, 216u8, 187u8, 116u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: refundModeCreditReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: refundModeCreditReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `resolve()` and selector `0x2810e1d6`. +```solidity +function resolve() external returns (GameStatus); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveCall; + ///Container type for the return parameters of the [`resolve()`](resolveCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolveReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolveReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolveReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolveCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolve()"; + const SELECTOR: [u8; 4] = [40u8, 16u8, 225u8, 214u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolveReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolveReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `resolvedAt()` and selector `0x19effeb4`. +```solidity +function resolvedAt() external view returns (Timestamp); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtCall; + ///Container type for the return parameters of the [`resolvedAt()`](resolvedAtCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct resolvedAtReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Timestamp,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: resolvedAtReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for resolvedAtReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for resolvedAtCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Timestamp,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "resolvedAt()"; + const SELECTOR: [u8; 4] = [25u8, 239u8, 254u8, 180u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: resolvedAtReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `rollupConfigHash()` and selector `0x6d9a1c8b`. +```solidity +function rollupConfigHash() external view returns (bytes32 rollupConfigHash_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rollupConfigHashCall; + ///Container type for the return parameters of the [`rollupConfigHash()`](rollupConfigHashCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rollupConfigHashReturn { + #[allow(missing_docs)] + pub rollupConfigHash_: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: rollupConfigHashCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for rollupConfigHashCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: rollupConfigHashReturn) -> Self { + (value.rollupConfigHash_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for rollupConfigHashReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { rollupConfigHash_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for rollupConfigHashCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "rollupConfigHash()"; + const SELECTOR: [u8; 4] = [109u8, 154u8, 28u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: rollupConfigHashReturn = r.into(); + r.rollupConfigHash_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: rollupConfigHashReturn = r.into(); + r.rollupConfigHash_ + }) + } + } + }; + /**Function with signature `rootClaim()` and selector `0xbcef3b55`. +```solidity +function rootClaim() external pure returns (Claim rootClaim_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimCall; + ///Container type for the return parameters of the [`rootClaim()`](rootClaimCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rootClaimReturn { + #[allow(missing_docs)] + pub rootClaim_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Claim,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: rootClaimReturn) -> Self { + (value.rootClaim_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for rootClaimReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { rootClaim_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for rootClaimCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Claim,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "rootClaim()"; + const SELECTOR: [u8; 4] = [188u8, 239u8, 59u8, 85u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r.rootClaim_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: rootClaimReturn = r.into(); + r.rootClaim_ + }) + } + } + }; + /**Function with signature `sp1Verifier()` and selector `0x52a07fa3`. +```solidity +function sp1Verifier() external view returns (address verifier_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sp1VerifierCall; + ///Container type for the return parameters of the [`sp1Verifier()`](sp1VerifierCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sp1VerifierReturn { + #[allow(missing_docs)] + pub verifier_: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sp1VerifierCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sp1VerifierCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sp1VerifierReturn) -> Self { + (value.verifier_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sp1VerifierReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { verifier_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for sp1VerifierCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "sp1Verifier()"; + const SELECTOR: [u8; 4] = [82u8, 160u8, 127u8, 163u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: sp1VerifierReturn = r.into(); + r.verifier_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: sp1VerifierReturn = r.into(); + r.verifier_ + }) + } + } + }; + /**Function with signature `startingBlockNumber()` and selector `0x70872aa5`. +```solidity +function startingBlockNumber() external view returns (uint256 startingBlockNumber_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingBlockNumberCall; + ///Container type for the return parameters of the [`startingBlockNumber()`](startingBlockNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingBlockNumberReturn { + #[allow(missing_docs)] + pub startingBlockNumber_: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingBlockNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingBlockNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingBlockNumberReturn) -> Self { + (value.startingBlockNumber_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingBlockNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + startingBlockNumber_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for startingBlockNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "startingBlockNumber()"; + const SELECTOR: [u8; 4] = [112u8, 135u8, 42u8, 165u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: startingBlockNumberReturn = r.into(); + r.startingBlockNumber_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: startingBlockNumberReturn = r.into(); + r.startingBlockNumber_ + }) + } + } + }; + /**Function with signature `startingOutputRoot()` and selector `0x57da950e`. +```solidity +function startingOutputRoot() external view returns (Hash root, uint256 l2SequenceNumber); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingOutputRootCall; + ///Container type for the return parameters of the [`startingOutputRoot()`](startingOutputRootCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingOutputRootReturn { + #[allow(missing_docs)] + pub root: ::RustType, + #[allow(missing_docs)] + pub l2SequenceNumber: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingOutputRootCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingOutputRootCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingOutputRootReturn) -> Self { + (value.root, value.l2SequenceNumber) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingOutputRootReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + root: tuple.0, + l2SequenceNumber: tuple.1, + } + } + } + } + impl startingOutputRootReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.root), + as alloy_sol_types::SolType>::tokenize(&self.l2SequenceNumber), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for startingOutputRootCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = startingOutputRootReturn; + type ReturnTuple<'a> = (Hash, alloy::sol_types::sol_data::Uint<256>); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "startingOutputRoot()"; + const SELECTOR: [u8; 4] = [87u8, 218u8, 149u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + startingOutputRootReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `startingRootHash()` and selector `0x25fc2ace`. +```solidity +function startingRootHash() external view returns (Hash startingRootHash_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingRootHashCall; + ///Container type for the return parameters of the [`startingRootHash()`](startingRootHashCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingRootHashReturn { + #[allow(missing_docs)] + pub startingRootHash_: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingRootHashCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingRootHashCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Hash,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingRootHashReturn) -> Self { + (value.startingRootHash_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingRootHashReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { startingRootHash_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for startingRootHashCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Hash,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "startingRootHash()"; + const SELECTOR: [u8; 4] = [37u8, 252u8, 42u8, 206u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: startingRootHashReturn = r.into(); + r.startingRootHash_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: startingRootHashReturn = r.into(); + r.startingRootHash_ + }) + } + } + }; + /**Function with signature `status()` and selector `0x200d2ed2`. +```solidity +function status() external view returns (GameStatus); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusCall; + ///Container type for the return parameters of the [`status()`](statusCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct statusReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (GameStatus,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: statusReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for statusReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for statusCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (GameStatus,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "status()"; + const SELECTOR: [u8; 4] = [32u8, 13u8, 46u8, 210u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: statusReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `version()` and selector `0x54fd4d50`. +```solidity +function version() external view returns (string memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionCall; + ///Container type for the return parameters of the [`version()`](versionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for versionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "version()"; + const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `wasRespectedGameTypeWhenCreated()` and selector `0x250e69bd`. +```solidity +function wasRespectedGameTypeWhenCreated() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedCall; + ///Container type for the return parameters of the [`wasRespectedGameTypeWhenCreated()`](wasRespectedGameTypeWhenCreatedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct wasRespectedGameTypeWhenCreatedReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: wasRespectedGameTypeWhenCreatedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for wasRespectedGameTypeWhenCreatedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for wasRespectedGameTypeWhenCreatedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "wasRespectedGameTypeWhenCreated()"; + const SELECTOR: [u8; 4] = [37u8, 14u8, 105u8, 189u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: wasRespectedGameTypeWhenCreatedReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`OPSuccinctFaultDisputeGame`](self) function calls. + #[derive(Clone)] + pub enum OPSuccinctFaultDisputeGameCalls { + #[allow(missing_docs)] + accessManager(accessManagerCall), + #[allow(missing_docs)] + aggregationVkey(aggregationVkeyCall), + #[allow(missing_docs)] + anchorStateRegistry(anchorStateRegistryCall), + #[allow(missing_docs)] + bondDistributionMode(bondDistributionModeCall), + #[allow(missing_docs)] + challenge(challengeCall), + #[allow(missing_docs)] + challengerBond(challengerBondCall), + #[allow(missing_docs)] + claimCredit(claimCreditCall), + #[allow(missing_docs)] + claimData(claimDataCall), + #[allow(missing_docs)] + closeGame(closeGameCall), + #[allow(missing_docs)] + createdAt(createdAtCall), + #[allow(missing_docs)] + credit(creditCall), + #[allow(missing_docs)] + disputeGameFactory(disputeGameFactoryCall), + #[allow(missing_docs)] + extraData(extraDataCall), + #[allow(missing_docs)] + gameCreator(gameCreatorCall), + #[allow(missing_docs)] + gameData(gameDataCall), + #[allow(missing_docs)] + gameOver(gameOverCall), + #[allow(missing_docs)] + gameType(gameTypeCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + l1Head(l1HeadCall), + #[allow(missing_docs)] + l2BlockNumber(l2BlockNumberCall), + #[allow(missing_docs)] + l2SequenceNumber(l2SequenceNumberCall), + #[allow(missing_docs)] + maxChallengeDuration(maxChallengeDurationCall), + #[allow(missing_docs)] + maxProveDuration(maxProveDurationCall), + #[allow(missing_docs)] + normalModeCredit(normalModeCreditCall), + #[allow(missing_docs)] + parentIndex(parentIndexCall), + #[allow(missing_docs)] + prove(proveCall), + #[allow(missing_docs)] + rangeVkeyCommitment(rangeVkeyCommitmentCall), + #[allow(missing_docs)] + refundModeCredit(refundModeCreditCall), + #[allow(missing_docs)] + resolve(resolveCall), + #[allow(missing_docs)] + resolvedAt(resolvedAtCall), + #[allow(missing_docs)] + rollupConfigHash(rollupConfigHashCall), + #[allow(missing_docs)] + rootClaim(rootClaimCall), + #[allow(missing_docs)] + sp1Verifier(sp1VerifierCall), + #[allow(missing_docs)] + startingBlockNumber(startingBlockNumberCall), + #[allow(missing_docs)] + startingOutputRoot(startingOutputRootCall), + #[allow(missing_docs)] + startingRootHash(startingRootHashCall), + #[allow(missing_docs)] + status(statusCall), + #[allow(missing_docs)] + version(versionCall), + #[allow(missing_docs)] + wasRespectedGameTypeWhenCreated(wasRespectedGameTypeWhenCreatedCall), + } + impl OPSuccinctFaultDisputeGameCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [25u8, 239u8, 254u8, 180u8], + [32u8, 13u8, 46u8, 210u8], + [37u8, 14u8, 105u8, 189u8], + [37u8, 252u8, 42u8, 206u8], + [40u8, 16u8, 225u8, 214u8], + [43u8, 49u8, 132u8, 30u8], + [55u8, 91u8, 250u8, 93u8], + [55u8, 141u8, 212u8, 140u8], + [55u8, 177u8, 178u8, 41u8], + [62u8, 196u8, 212u8, 214u8], + [82u8, 157u8, 106u8, 140u8], + [82u8, 160u8, 127u8, 163u8], + [84u8, 253u8, 77u8, 80u8], + [87u8, 218u8, 149u8, 14u8], + [92u8, 12u8, 186u8, 51u8], + [96u8, 157u8, 51u8, 52u8], + [96u8, 226u8, 116u8, 100u8], + [99u8, 97u8, 80u8, 109u8], + [104u8, 204u8, 220u8, 134u8], + [109u8, 154u8, 28u8, 139u8], + [112u8, 135u8, 42u8, 165u8], + [120u8, 107u8, 132u8, 75u8], + [121u8, 72u8, 105u8, 10u8], + [129u8, 41u8, 252u8, 28u8], + [139u8, 133u8, 144u8, 43u8], + [153u8, 115u8, 94u8, 50u8], + [187u8, 220u8, 2u8, 219u8], + [188u8, 190u8, 80u8, 148u8], + [188u8, 239u8, 59u8, 85u8], + [189u8, 179u8, 55u8, 209u8], + [192u8, 216u8, 187u8, 116u8], + [195u8, 46u8, 78u8, 62u8], + [207u8, 9u8, 224u8, 208u8], + [210u8, 23u8, 123u8, 221u8], + [210u8, 239u8, 115u8, 152u8], + [213u8, 212u8, 77u8, 128u8], + [242u8, 180u8, 230u8, 23u8], + [250u8, 36u8, 247u8, 67u8], + [253u8, 203u8, 96u8, 104u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(resolvedAt), + ::core::stringify!(status), + ::core::stringify!(wasRespectedGameTypeWhenCreated), + ::core::stringify!(startingRootHash), + ::core::stringify!(resolve), + ::core::stringify!(rangeVkeyCommitment), + ::core::stringify!(prove), + ::core::stringify!(bondDistributionMode), + ::core::stringify!(gameCreator), + ::core::stringify!(claimData), + ::core::stringify!(normalModeCredit), + ::core::stringify!(sp1Verifier), + ::core::stringify!(version), + ::core::stringify!(startingOutputRoot), + ::core::stringify!(anchorStateRegistry), + ::core::stringify!(extraData), + ::core::stringify!(claimCredit), + ::core::stringify!(l1Head), + ::core::stringify!(challengerBond), + ::core::stringify!(rollupConfigHash), + ::core::stringify!(startingBlockNumber), + ::core::stringify!(closeGame), + ::core::stringify!(parentIndex), + ::core::stringify!(initialize), + ::core::stringify!(l2BlockNumber), + ::core::stringify!(l2SequenceNumber), + ::core::stringify!(gameType), + ::core::stringify!(maxProveDuration), + ::core::stringify!(rootClaim), + ::core::stringify!(gameOver), + ::core::stringify!(refundModeCredit), + ::core::stringify!(aggregationVkey), + ::core::stringify!(createdAt), + ::core::stringify!(maxChallengeDuration), + ::core::stringify!(challenge), + ::core::stringify!(credit), + ::core::stringify!(disputeGameFactory), + ::core::stringify!(gameData), + ::core::stringify!(accessManager), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for OPSuccinctFaultDisputeGameCalls { + const NAME: &'static str = "OPSuccinctFaultDisputeGameCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 39usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::accessManager(_) => { + ::SELECTOR + } + Self::aggregationVkey(_) => { + ::SELECTOR + } + Self::anchorStateRegistry(_) => { + ::SELECTOR + } + Self::bondDistributionMode(_) => { + ::SELECTOR + } + Self::challenge(_) => { + ::SELECTOR + } + Self::challengerBond(_) => { + ::SELECTOR + } + Self::claimCredit(_) => { + ::SELECTOR + } + Self::claimData(_) => { + ::SELECTOR + } + Self::closeGame(_) => { + ::SELECTOR + } + Self::createdAt(_) => { + ::SELECTOR + } + Self::credit(_) => ::SELECTOR, + Self::disputeGameFactory(_) => { + ::SELECTOR + } + Self::extraData(_) => { + ::SELECTOR + } + Self::gameCreator(_) => { + ::SELECTOR + } + Self::gameData(_) => ::SELECTOR, + Self::gameOver(_) => ::SELECTOR, + Self::gameType(_) => ::SELECTOR, + Self::initialize(_) => { + ::SELECTOR + } + Self::l1Head(_) => ::SELECTOR, + Self::l2BlockNumber(_) => { + ::SELECTOR + } + Self::l2SequenceNumber(_) => { + ::SELECTOR + } + Self::maxChallengeDuration(_) => { + ::SELECTOR + } + Self::maxProveDuration(_) => { + ::SELECTOR + } + Self::normalModeCredit(_) => { + ::SELECTOR + } + Self::parentIndex(_) => { + ::SELECTOR + } + Self::prove(_) => ::SELECTOR, + Self::rangeVkeyCommitment(_) => { + ::SELECTOR + } + Self::refundModeCredit(_) => { + ::SELECTOR + } + Self::resolve(_) => ::SELECTOR, + Self::resolvedAt(_) => { + ::SELECTOR + } + Self::rollupConfigHash(_) => { + ::SELECTOR + } + Self::rootClaim(_) => { + ::SELECTOR + } + Self::sp1Verifier(_) => { + ::SELECTOR + } + Self::startingBlockNumber(_) => { + ::SELECTOR + } + Self::startingOutputRoot(_) => { + ::SELECTOR + } + Self::startingRootHash(_) => { + ::SELECTOR + } + Self::status(_) => ::SELECTOR, + Self::version(_) => ::SELECTOR, + Self::wasRespectedGameTypeWhenCreated(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::status) + } + status + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + OPSuccinctFaultDisputeGameCalls::wasRespectedGameTypeWhenCreated, + ) + } + wasRespectedGameTypeWhenCreated + }, + { + fn startingRootHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::startingRootHash) + } + startingRootHash + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::resolve) + } + resolve + }, + { + fn rangeVkeyCommitment( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::rangeVkeyCommitment) + } + rangeVkeyCommitment + }, + { + fn prove( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::prove) + } + prove + }, + { + fn bondDistributionMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::bondDistributionMode) + } + bondDistributionMode + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn claimData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::claimData) + } + claimData + }, + { + fn normalModeCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::normalModeCredit) + } + normalModeCredit + }, + { + fn sp1Verifier( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::sp1Verifier) + } + sp1Verifier + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::version) + } + version + }, + { + fn startingOutputRoot( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::startingOutputRoot) + } + startingOutputRoot + }, + { + fn anchorStateRegistry( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::anchorStateRegistry) + } + anchorStateRegistry + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::extraData) + } + extraData + }, + { + fn claimCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::claimCredit) + } + claimCredit + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn challengerBond( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::challengerBond) + } + challengerBond + }, + { + fn rollupConfigHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::rollupConfigHash) + } + rollupConfigHash + }, + { + fn startingBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::startingBlockNumber) + } + startingBlockNumber + }, + { + fn closeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::closeGame) + } + closeGame + }, + { + fn parentIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::parentIndex) + } + parentIndex + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::initialize) + } + initialize + }, + { + fn l2BlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::l2BlockNumber) + } + l2BlockNumber + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::gameType) + } + gameType + }, + { + fn maxProveDuration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::maxProveDuration) + } + maxProveDuration + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn gameOver( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::gameOver) + } + gameOver + }, + { + fn refundModeCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::refundModeCredit) + } + refundModeCredit + }, + { + fn aggregationVkey( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::aggregationVkey) + } + aggregationVkey + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn maxChallengeDuration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::maxChallengeDuration) + } + maxChallengeDuration + }, + { + fn challenge( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::challenge) + } + challenge + }, + { + fn credit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::credit) + } + credit + }, + { + fn disputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::disputeGameFactory) + } + disputeGameFactory + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameCalls::gameData) + } + gameData + }, + { + fn accessManager( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::accessManager) + } + accessManager + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn resolvedAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::resolvedAt) + } + resolvedAt + }, + { + fn status( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::status) + } + status + }, + { + fn wasRespectedGameTypeWhenCreated( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + OPSuccinctFaultDisputeGameCalls::wasRespectedGameTypeWhenCreated, + ) + } + wasRespectedGameTypeWhenCreated + }, + { + fn startingRootHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::startingRootHash) + } + startingRootHash + }, + { + fn resolve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::resolve) + } + resolve + }, + { + fn rangeVkeyCommitment( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::rangeVkeyCommitment) + } + rangeVkeyCommitment + }, + { + fn prove( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::prove) + } + prove + }, + { + fn bondDistributionMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::bondDistributionMode) + } + bondDistributionMode + }, + { + fn gameCreator( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::gameCreator) + } + gameCreator + }, + { + fn claimData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::claimData) + } + claimData + }, + { + fn normalModeCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::normalModeCredit) + } + normalModeCredit + }, + { + fn sp1Verifier( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::sp1Verifier) + } + sp1Verifier + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::version) + } + version + }, + { + fn startingOutputRoot( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::startingOutputRoot) + } + startingOutputRoot + }, + { + fn anchorStateRegistry( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::anchorStateRegistry) + } + anchorStateRegistry + }, + { + fn extraData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::extraData) + } + extraData + }, + { + fn claimCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::claimCredit) + } + claimCredit + }, + { + fn l1Head( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::l1Head) + } + l1Head + }, + { + fn challengerBond( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::challengerBond) + } + challengerBond + }, + { + fn rollupConfigHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::rollupConfigHash) + } + rollupConfigHash + }, + { + fn startingBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::startingBlockNumber) + } + startingBlockNumber + }, + { + fn closeGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::closeGame) + } + closeGame + }, + { + fn parentIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::parentIndex) + } + parentIndex + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::initialize) + } + initialize + }, + { + fn l2BlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::l2BlockNumber) + } + l2BlockNumber + }, + { + fn l2SequenceNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::l2SequenceNumber) + } + l2SequenceNumber + }, + { + fn gameType( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::gameType) + } + gameType + }, + { + fn maxProveDuration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::maxProveDuration) + } + maxProveDuration + }, + { + fn rootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::rootClaim) + } + rootClaim + }, + { + fn gameOver( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::gameOver) + } + gameOver + }, + { + fn refundModeCredit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::refundModeCredit) + } + refundModeCredit + }, + { + fn aggregationVkey( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::aggregationVkey) + } + aggregationVkey + }, + { + fn createdAt( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::createdAt) + } + createdAt + }, + { + fn maxChallengeDuration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::maxChallengeDuration) + } + maxChallengeDuration + }, + { + fn challenge( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::challenge) + } + challenge + }, + { + fn credit( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::credit) + } + credit + }, + { + fn disputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::disputeGameFactory) + } + disputeGameFactory + }, + { + fn gameData( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::gameData) + } + gameData + }, + { + fn accessManager( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameCalls::accessManager) + } + accessManager + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::accessManager(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::aggregationVkey(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::anchorStateRegistry(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::bondDistributionMode(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::challenge(inner) => { + ::abi_encoded_size(inner) + } + Self::challengerBond(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::claimCredit(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::claimData(inner) => { + ::abi_encoded_size(inner) + } + Self::closeGame(inner) => { + ::abi_encoded_size(inner) + } + Self::createdAt(inner) => { + ::abi_encoded_size(inner) + } + Self::credit(inner) => { + ::abi_encoded_size(inner) + } + Self::disputeGameFactory(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::extraData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameCreator(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::gameData(inner) => { + ::abi_encoded_size(inner) + } + Self::gameOver(inner) => { + ::abi_encoded_size(inner) + } + Self::gameType(inner) => { + ::abi_encoded_size(inner) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::l1Head(inner) => { + ::abi_encoded_size(inner) + } + Self::l2BlockNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::l2SequenceNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::maxChallengeDuration(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::maxProveDuration(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::normalModeCredit(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::parentIndex(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::prove(inner) => { + ::abi_encoded_size(inner) + } + Self::rangeVkeyCommitment(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::refundModeCredit(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::resolve(inner) => { + ::abi_encoded_size(inner) + } + Self::resolvedAt(inner) => { + ::abi_encoded_size(inner) + } + Self::rollupConfigHash(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::rootClaim(inner) => { + ::abi_encoded_size(inner) + } + Self::sp1Verifier(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::startingBlockNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::startingOutputRoot(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::startingRootHash(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::status(inner) => { + ::abi_encoded_size(inner) + } + Self::version(inner) => { + ::abi_encoded_size(inner) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::accessManager(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::aggregationVkey(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::anchorStateRegistry(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::bondDistributionMode(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::challenge(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::challengerBond(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::claimCredit(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::claimData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::closeGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::createdAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::credit(inner) => { + ::abi_encode_raw(inner, out) + } + Self::disputeGameFactory(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::extraData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameCreator(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameData(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameOver(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::gameType(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l1Head(inner) => { + ::abi_encode_raw(inner, out) + } + Self::l2BlockNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l2SequenceNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::maxChallengeDuration(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::maxProveDuration(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::normalModeCredit(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::parentIndex(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::prove(inner) => { + ::abi_encode_raw(inner, out) + } + Self::rangeVkeyCommitment(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::refundModeCredit(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::resolve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::resolvedAt(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::rollupConfigHash(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::rootClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::sp1Verifier(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::startingBlockNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::startingOutputRoot(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::startingRootHash(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::status(inner) => { + ::abi_encode_raw(inner, out) + } + Self::version(inner) => { + ::abi_encode_raw(inner, out) + } + Self::wasRespectedGameTypeWhenCreated(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`OPSuccinctFaultDisputeGame`](self) custom errors. + #[derive(Clone)] + pub enum OPSuccinctFaultDisputeGameErrors { + #[allow(missing_docs)] + AlreadyInitialized(AlreadyInitialized), + #[allow(missing_docs)] + BadAuth(BadAuth), + #[allow(missing_docs)] + BondTransferFailed(BondTransferFailed), + #[allow(missing_docs)] + ClaimAlreadyChallenged(ClaimAlreadyChallenged), + #[allow(missing_docs)] + ClaimAlreadyResolved(ClaimAlreadyResolved), + #[allow(missing_docs)] + GameNotFinalized(GameNotFinalized), + #[allow(missing_docs)] + GameNotOver(GameNotOver), + #[allow(missing_docs)] + GameOver(GameOver), + #[allow(missing_docs)] + IncorrectBondAmount(IncorrectBondAmount), + #[allow(missing_docs)] + IncorrectDisputeGameFactory(IncorrectDisputeGameFactory), + #[allow(missing_docs)] + InvalidBondDistributionMode(InvalidBondDistributionMode), + #[allow(missing_docs)] + InvalidParentGame(InvalidParentGame), + #[allow(missing_docs)] + InvalidProposalStatus(InvalidProposalStatus), + #[allow(missing_docs)] + NoCreditToClaim(NoCreditToClaim), + #[allow(missing_docs)] + ParentGameNotResolved(ParentGameNotResolved), + #[allow(missing_docs)] + UnexpectedRootClaim(UnexpectedRootClaim), + } + impl OPSuccinctFaultDisputeGameErrors { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [4u8, 100u8, 60u8, 57u8], + [7u8, 138u8, 61u8, 244u8], + [13u8, 193u8, 73u8, 240u8], + [23u8, 191u8, 229u8, 247u8], + [52u8, 97u8, 25u8, 247u8], + [72u8, 81u8, 189u8, 155u8], + [116u8, 146u8, 162u8, 105u8], + [131u8, 230u8, 204u8, 107u8], + [133u8, 195u8, 69u8, 176u8], + [134u8, 32u8, 170u8, 25u8], + [146u8, 197u8, 6u8, 174u8], + [148u8, 13u8, 56u8, 199u8], + [211u8, 134u8, 239u8, 62u8], + [223u8, 70u8, 156u8, 203u8], + [241u8, 169u8, 69u8, 129u8], + [244u8, 2u8, 57u8, 219u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(GameNotOver), + ::core::stringify!(InvalidBondDistributionMode), + ::core::stringify!(AlreadyInitialized), + ::core::stringify!(NoCreditToClaim), + ::core::stringify!(InvalidParentGame), + ::core::stringify!(GameNotFinalized), + ::core::stringify!(InvalidProposalStatus), + ::core::stringify!(BondTransferFailed), + ::core::stringify!(ClaimAlreadyChallenged), + ::core::stringify!(IncorrectBondAmount), + ::core::stringify!(ParentGameNotResolved), + ::core::stringify!(IncorrectDisputeGameFactory), + ::core::stringify!(BadAuth), + ::core::stringify!(GameOver), + ::core::stringify!(ClaimAlreadyResolved), + ::core::stringify!(UnexpectedRootClaim), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for OPSuccinctFaultDisputeGameErrors { + const NAME: &'static str = "OPSuccinctFaultDisputeGameErrors"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 16usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::AlreadyInitialized(_) => { + ::SELECTOR + } + Self::BadAuth(_) => ::SELECTOR, + Self::BondTransferFailed(_) => { + ::SELECTOR + } + Self::ClaimAlreadyChallenged(_) => { + ::SELECTOR + } + Self::ClaimAlreadyResolved(_) => { + ::SELECTOR + } + Self::GameNotFinalized(_) => { + ::SELECTOR + } + Self::GameNotOver(_) => { + ::SELECTOR + } + Self::GameOver(_) => ::SELECTOR, + Self::IncorrectBondAmount(_) => { + ::SELECTOR + } + Self::IncorrectDisputeGameFactory(_) => { + ::SELECTOR + } + Self::InvalidBondDistributionMode(_) => { + ::SELECTOR + } + Self::InvalidParentGame(_) => { + ::SELECTOR + } + Self::InvalidProposalStatus(_) => { + ::SELECTOR + } + Self::NoCreditToClaim(_) => { + ::SELECTOR + } + Self::ParentGameNotResolved(_) => { + ::SELECTOR + } + Self::UnexpectedRootClaim(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn GameNotOver( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameErrors::GameNotOver) + } + GameNotOver + }, + { + fn InvalidBondDistributionMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + OPSuccinctFaultDisputeGameErrors::InvalidBondDistributionMode, + ) + } + InvalidBondDistributionMode + }, + { + fn AlreadyInitialized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::AlreadyInitialized) + } + AlreadyInitialized + }, + { + fn NoCreditToClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::NoCreditToClaim) + } + NoCreditToClaim + }, + { + fn InvalidParentGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::InvalidParentGame) + } + InvalidParentGame + }, + { + fn GameNotFinalized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::GameNotFinalized) + } + GameNotFinalized + }, + { + fn InvalidProposalStatus( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::InvalidProposalStatus) + } + InvalidProposalStatus + }, + { + fn BondTransferFailed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::BondTransferFailed) + } + BondTransferFailed + }, + { + fn ClaimAlreadyChallenged( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + OPSuccinctFaultDisputeGameErrors::ClaimAlreadyChallenged, + ) + } + ClaimAlreadyChallenged + }, + { + fn IncorrectBondAmount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::IncorrectBondAmount) + } + IncorrectBondAmount + }, + { + fn ParentGameNotResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::ParentGameNotResolved) + } + ParentGameNotResolved + }, + { + fn IncorrectDisputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + OPSuccinctFaultDisputeGameErrors::IncorrectDisputeGameFactory, + ) + } + IncorrectDisputeGameFactory + }, + { + fn BadAuth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameErrors::BadAuth) + } + BadAuth + }, + { + fn GameOver( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctFaultDisputeGameErrors::GameOver) + } + GameOver + }, + { + fn ClaimAlreadyResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::ClaimAlreadyResolved) + } + ClaimAlreadyResolved + }, + { + fn UnexpectedRootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::UnexpectedRootClaim) + } + UnexpectedRootClaim + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn GameNotOver( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::GameNotOver) + } + GameNotOver + }, + { + fn InvalidBondDistributionMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + OPSuccinctFaultDisputeGameErrors::InvalidBondDistributionMode, + ) + } + InvalidBondDistributionMode + }, + { + fn AlreadyInitialized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::AlreadyInitialized) + } + AlreadyInitialized + }, + { + fn NoCreditToClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::NoCreditToClaim) + } + NoCreditToClaim + }, + { + fn InvalidParentGame( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::InvalidParentGame) + } + InvalidParentGame + }, + { + fn GameNotFinalized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::GameNotFinalized) + } + GameNotFinalized + }, + { + fn InvalidProposalStatus( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::InvalidProposalStatus) + } + InvalidProposalStatus + }, + { + fn BondTransferFailed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::BondTransferFailed) + } + BondTransferFailed + }, + { + fn ClaimAlreadyChallenged( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + OPSuccinctFaultDisputeGameErrors::ClaimAlreadyChallenged, + ) + } + ClaimAlreadyChallenged + }, + { + fn IncorrectBondAmount( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::IncorrectBondAmount) + } + IncorrectBondAmount + }, + { + fn ParentGameNotResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::ParentGameNotResolved) + } + ParentGameNotResolved + }, + { + fn IncorrectDisputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + OPSuccinctFaultDisputeGameErrors::IncorrectDisputeGameFactory, + ) + } + IncorrectDisputeGameFactory + }, + { + fn BadAuth( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::BadAuth) + } + BadAuth + }, + { + fn GameOver( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::GameOver) + } + GameOver + }, + { + fn ClaimAlreadyResolved( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::ClaimAlreadyResolved) + } + ClaimAlreadyResolved + }, + { + fn UnexpectedRootClaim( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctFaultDisputeGameErrors::UnexpectedRootClaim) + } + UnexpectedRootClaim + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::AlreadyInitialized(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::BadAuth(inner) => { + ::abi_encoded_size(inner) + } + Self::BondTransferFailed(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ClaimAlreadyChallenged(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ClaimAlreadyResolved(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::GameNotFinalized(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::GameNotOver(inner) => { + ::abi_encoded_size(inner) + } + Self::GameOver(inner) => { + ::abi_encoded_size(inner) + } + Self::IncorrectBondAmount(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::IncorrectDisputeGameFactory(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidBondDistributionMode(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidParentGame(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::InvalidProposalStatus(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::NoCreditToClaim(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ParentGameNotResolved(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::UnexpectedRootClaim(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::AlreadyInitialized(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::BadAuth(inner) => { + ::abi_encode_raw(inner, out) + } + Self::BondTransferFailed(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ClaimAlreadyChallenged(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ClaimAlreadyResolved(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::GameNotFinalized(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::GameNotOver(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::GameOver(inner) => { + ::abi_encode_raw(inner, out) + } + Self::IncorrectBondAmount(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::IncorrectDisputeGameFactory(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidBondDistributionMode(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidParentGame(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::InvalidProposalStatus(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::NoCreditToClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ParentGameNotResolved(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::UnexpectedRootClaim(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`OPSuccinctFaultDisputeGame`](self) events. + #[derive(Clone)] + pub enum OPSuccinctFaultDisputeGameEvents { + #[allow(missing_docs)] + Challenged(Challenged), + #[allow(missing_docs)] + GameClosed(GameClosed), + #[allow(missing_docs)] + Proved(Proved), + #[allow(missing_docs)] + Resolved(Resolved), + } + impl OPSuccinctFaultDisputeGameEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 94u8, 24u8, 111u8, 9u8, 185u8, 201u8, 52u8, 145u8, 241u8, 78u8, 39u8, + 126u8, 234u8, 127u8, 170u8, 93u8, 230u8, 162u8, 212u8, 189u8, 167u8, + 90u8, 121u8, 175u8, 122u8, 54u8, 132u8, 251u8, 251u8, 66u8, 218u8, 96u8, + ], + [ + 94u8, 101u8, 101u8, 217u8, 202u8, 47u8, 92u8, 133u8, 1u8, 214u8, 65u8, + 139u8, 245u8, 99u8, 50u8, 42u8, 114u8, 67u8, 186u8, 122u8, 206u8, 38u8, + 109u8, 117u8, 234u8, 201u8, 159u8, 74u8, 219u8, 179u8, 11u8, 167u8, + ], + [ + 152u8, 2u8, 123u8, 56u8, 21u8, 63u8, 153u8, 92u8, 75u8, 128u8, 42u8, + 92u8, 126u8, 99u8, 101u8, 190u8, 227u8, 173u8, 219u8, 37u8, 175u8, 107u8, + 41u8, 129u8, 140u8, 12u8, 48u8, 70u8, 132u8, 216u8, 5u8, 44u8, + ], + [ + 153u8, 8u8, 234u8, 172u8, 6u8, 69u8, 223u8, 157u8, 7u8, 4u8, 208u8, + 106u8, 220u8, 158u8, 7u8, 51u8, 124u8, 149u8, 29u8, 226u8, 240u8, 107u8, + 95u8, 40u8, 54u8, 21u8, 29u8, 72u8, 213u8, 228u8, 114u8, 47u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(Resolved), + ::core::stringify!(Proved), + ::core::stringify!(Challenged), + ::core::stringify!(GameClosed), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for OPSuccinctFaultDisputeGameEvents { + const NAME: &'static str = "OPSuccinctFaultDisputeGameEvents"; + const COUNT: usize = 4usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::Challenged) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::GameClosed) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Proved) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Resolved) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OPSuccinctFaultDisputeGameEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::Challenged(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::GameClosed(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Proved(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::Challenged(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::GameClosed(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Proved(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Resolved(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`OPSuccinctFaultDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`OPSuccinctFaultDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> OPSuccinctFaultDisputeGameInstance { + OPSuccinctFaultDisputeGameInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _maxChallengeDuration: ::RustType, + _maxProveDuration: ::RustType, + _disputeGameFactory: alloy::sol_types::private::Address, + _sp1Verifier: alloy::sol_types::private::Address, + _rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + _aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + _rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + _challengerBond: alloy::sol_types::private::primitives::aliases::U256, + _anchorStateRegistry: alloy::sol_types::private::Address, + _accessManager: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + OPSuccinctFaultDisputeGameInstance::< + P, + N, + >::deploy( + __provider, + _maxChallengeDuration, + _maxProveDuration, + _disputeGameFactory, + _sp1Verifier, + _rollupConfigHash, + _aggregationVkey, + _rangeVkeyCommitment, + _challengerBond, + _anchorStateRegistry, + _accessManager, + ) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + _maxChallengeDuration: ::RustType, + _maxProveDuration: ::RustType, + _disputeGameFactory: alloy::sol_types::private::Address, + _sp1Verifier: alloy::sol_types::private::Address, + _rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + _aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + _rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + _challengerBond: alloy::sol_types::private::primitives::aliases::U256, + _anchorStateRegistry: alloy::sol_types::private::Address, + _accessManager: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + OPSuccinctFaultDisputeGameInstance::< + P, + N, + >::deploy_builder( + __provider, + _maxChallengeDuration, + _maxProveDuration, + _disputeGameFactory, + _sp1Verifier, + _rollupConfigHash, + _aggregationVkey, + _rangeVkeyCommitment, + _challengerBond, + _anchorStateRegistry, + _accessManager, + ) + } + /**A [`OPSuccinctFaultDisputeGame`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`OPSuccinctFaultDisputeGame`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct OPSuccinctFaultDisputeGameInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for OPSuccinctFaultDisputeGameInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("OPSuccinctFaultDisputeGameInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OPSuccinctFaultDisputeGameInstance { + /**Creates a new wrapper around an on-chain [`OPSuccinctFaultDisputeGame`](self) contract instance. + +See the [wrapper's documentation](`OPSuccinctFaultDisputeGameInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + _maxChallengeDuration: ::RustType, + _maxProveDuration: ::RustType, + _disputeGameFactory: alloy::sol_types::private::Address, + _sp1Verifier: alloy::sol_types::private::Address, + _rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + _aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + _rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + _challengerBond: alloy::sol_types::private::primitives::aliases::U256, + _anchorStateRegistry: alloy::sol_types::private::Address, + _accessManager: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + __provider, + _maxChallengeDuration, + _maxProveDuration, + _disputeGameFactory, + _sp1Verifier, + _rollupConfigHash, + _aggregationVkey, + _rangeVkeyCommitment, + _challengerBond, + _anchorStateRegistry, + _accessManager, + ); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder( + __provider: P, + _maxChallengeDuration: ::RustType, + _maxProveDuration: ::RustType, + _disputeGameFactory: alloy::sol_types::private::Address, + _sp1Verifier: alloy::sol_types::private::Address, + _rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + _aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + _rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + _challengerBond: alloy::sol_types::private::primitives::aliases::U256, + _anchorStateRegistry: alloy::sol_types::private::Address, + _accessManager: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _maxChallengeDuration, + _maxProveDuration, + _disputeGameFactory, + _sp1Verifier, + _rollupConfigHash, + _aggregationVkey, + _rangeVkeyCommitment, + _challengerBond, + _anchorStateRegistry, + _accessManager, + }, + )[..], + ] + .concat() + .into(), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl OPSuccinctFaultDisputeGameInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> OPSuccinctFaultDisputeGameInstance { + OPSuccinctFaultDisputeGameInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OPSuccinctFaultDisputeGameInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`accessManager`] function. + pub fn accessManager( + &self, + ) -> alloy_contract::SolCallBuilder<&P, accessManagerCall, N> { + self.call_builder(&accessManagerCall) + } + ///Creates a new call builder for the [`aggregationVkey`] function. + pub fn aggregationVkey( + &self, + ) -> alloy_contract::SolCallBuilder<&P, aggregationVkeyCall, N> { + self.call_builder(&aggregationVkeyCall) + } + ///Creates a new call builder for the [`anchorStateRegistry`] function. + pub fn anchorStateRegistry( + &self, + ) -> alloy_contract::SolCallBuilder<&P, anchorStateRegistryCall, N> { + self.call_builder(&anchorStateRegistryCall) + } + ///Creates a new call builder for the [`bondDistributionMode`] function. + pub fn bondDistributionMode( + &self, + ) -> alloy_contract::SolCallBuilder<&P, bondDistributionModeCall, N> { + self.call_builder(&bondDistributionModeCall) + } + ///Creates a new call builder for the [`challenge`] function. + pub fn challenge(&self) -> alloy_contract::SolCallBuilder<&P, challengeCall, N> { + self.call_builder(&challengeCall) + } + ///Creates a new call builder for the [`challengerBond`] function. + pub fn challengerBond( + &self, + ) -> alloy_contract::SolCallBuilder<&P, challengerBondCall, N> { + self.call_builder(&challengerBondCall) + } + ///Creates a new call builder for the [`claimCredit`] function. + pub fn claimCredit( + &self, + _recipient: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, claimCreditCall, N> { + self.call_builder(&claimCreditCall { _recipient }) + } + ///Creates a new call builder for the [`claimData`] function. + pub fn claimData(&self) -> alloy_contract::SolCallBuilder<&P, claimDataCall, N> { + self.call_builder(&claimDataCall) + } + ///Creates a new call builder for the [`closeGame`] function. + pub fn closeGame(&self) -> alloy_contract::SolCallBuilder<&P, closeGameCall, N> { + self.call_builder(&closeGameCall) + } + ///Creates a new call builder for the [`createdAt`] function. + pub fn createdAt(&self) -> alloy_contract::SolCallBuilder<&P, createdAtCall, N> { + self.call_builder(&createdAtCall) + } + ///Creates a new call builder for the [`credit`] function. + pub fn credit( + &self, + _recipient: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, creditCall, N> { + self.call_builder(&creditCall { _recipient }) + } + ///Creates a new call builder for the [`disputeGameFactory`] function. + pub fn disputeGameFactory( + &self, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameFactoryCall, N> { + self.call_builder(&disputeGameFactoryCall) + } + ///Creates a new call builder for the [`extraData`] function. + pub fn extraData(&self) -> alloy_contract::SolCallBuilder<&P, extraDataCall, N> { + self.call_builder(&extraDataCall) + } + ///Creates a new call builder for the [`gameCreator`] function. + pub fn gameCreator( + &self, + ) -> alloy_contract::SolCallBuilder<&P, gameCreatorCall, N> { + self.call_builder(&gameCreatorCall) + } + ///Creates a new call builder for the [`gameData`] function. + pub fn gameData(&self) -> alloy_contract::SolCallBuilder<&P, gameDataCall, N> { + self.call_builder(&gameDataCall) + } + ///Creates a new call builder for the [`gameOver`] function. + pub fn gameOver(&self) -> alloy_contract::SolCallBuilder<&P, gameOverCall, N> { + self.call_builder(&gameOverCall) + } + ///Creates a new call builder for the [`gameType`] function. + pub fn gameType(&self) -> alloy_contract::SolCallBuilder<&P, gameTypeCall, N> { + self.call_builder(&gameTypeCall) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder(&initializeCall) + } + ///Creates a new call builder for the [`l1Head`] function. + pub fn l1Head(&self) -> alloy_contract::SolCallBuilder<&P, l1HeadCall, N> { + self.call_builder(&l1HeadCall) + } + ///Creates a new call builder for the [`l2BlockNumber`] function. + pub fn l2BlockNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2BlockNumberCall, N> { + self.call_builder(&l2BlockNumberCall) + } + ///Creates a new call builder for the [`l2SequenceNumber`] function. + pub fn l2SequenceNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2SequenceNumberCall, N> { + self.call_builder(&l2SequenceNumberCall) + } + ///Creates a new call builder for the [`maxChallengeDuration`] function. + pub fn maxChallengeDuration( + &self, + ) -> alloy_contract::SolCallBuilder<&P, maxChallengeDurationCall, N> { + self.call_builder(&maxChallengeDurationCall) + } + ///Creates a new call builder for the [`maxProveDuration`] function. + pub fn maxProveDuration( + &self, + ) -> alloy_contract::SolCallBuilder<&P, maxProveDurationCall, N> { + self.call_builder(&maxProveDurationCall) + } + ///Creates a new call builder for the [`normalModeCredit`] function. + pub fn normalModeCredit( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, normalModeCreditCall, N> { + self.call_builder(&normalModeCreditCall(_0)) + } + ///Creates a new call builder for the [`parentIndex`] function. + pub fn parentIndex( + &self, + ) -> alloy_contract::SolCallBuilder<&P, parentIndexCall, N> { + self.call_builder(&parentIndexCall) + } + ///Creates a new call builder for the [`prove`] function. + pub fn prove( + &self, + proofBytes: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, proveCall, N> { + self.call_builder(&proveCall { proofBytes }) + } + ///Creates a new call builder for the [`rangeVkeyCommitment`] function. + pub fn rangeVkeyCommitment( + &self, + ) -> alloy_contract::SolCallBuilder<&P, rangeVkeyCommitmentCall, N> { + self.call_builder(&rangeVkeyCommitmentCall) + } + ///Creates a new call builder for the [`refundModeCredit`] function. + pub fn refundModeCredit( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, refundModeCreditCall, N> { + self.call_builder(&refundModeCreditCall(_0)) + } + ///Creates a new call builder for the [`resolve`] function. + pub fn resolve(&self) -> alloy_contract::SolCallBuilder<&P, resolveCall, N> { + self.call_builder(&resolveCall) + } + ///Creates a new call builder for the [`resolvedAt`] function. + pub fn resolvedAt( + &self, + ) -> alloy_contract::SolCallBuilder<&P, resolvedAtCall, N> { + self.call_builder(&resolvedAtCall) + } + ///Creates a new call builder for the [`rollupConfigHash`] function. + pub fn rollupConfigHash( + &self, + ) -> alloy_contract::SolCallBuilder<&P, rollupConfigHashCall, N> { + self.call_builder(&rollupConfigHashCall) + } + ///Creates a new call builder for the [`rootClaim`] function. + pub fn rootClaim(&self) -> alloy_contract::SolCallBuilder<&P, rootClaimCall, N> { + self.call_builder(&rootClaimCall) + } + ///Creates a new call builder for the [`sp1Verifier`] function. + pub fn sp1Verifier( + &self, + ) -> alloy_contract::SolCallBuilder<&P, sp1VerifierCall, N> { + self.call_builder(&sp1VerifierCall) + } + ///Creates a new call builder for the [`startingBlockNumber`] function. + pub fn startingBlockNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, startingBlockNumberCall, N> { + self.call_builder(&startingBlockNumberCall) + } + ///Creates a new call builder for the [`startingOutputRoot`] function. + pub fn startingOutputRoot( + &self, + ) -> alloy_contract::SolCallBuilder<&P, startingOutputRootCall, N> { + self.call_builder(&startingOutputRootCall) + } + ///Creates a new call builder for the [`startingRootHash`] function. + pub fn startingRootHash( + &self, + ) -> alloy_contract::SolCallBuilder<&P, startingRootHashCall, N> { + self.call_builder(&startingRootHashCall) + } + ///Creates a new call builder for the [`status`] function. + pub fn status(&self) -> alloy_contract::SolCallBuilder<&P, statusCall, N> { + self.call_builder(&statusCall) + } + ///Creates a new call builder for the [`version`] function. + pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> { + self.call_builder(&versionCall) + } + ///Creates a new call builder for the [`wasRespectedGameTypeWhenCreated`] function. + pub fn wasRespectedGameTypeWhenCreated( + &self, + ) -> alloy_contract::SolCallBuilder<&P, wasRespectedGameTypeWhenCreatedCall, N> { + self.call_builder(&wasRespectedGameTypeWhenCreatedCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OPSuccinctFaultDisputeGameInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`Challenged`] event. + pub fn Challenged_filter(&self) -> alloy_contract::Event<&P, Challenged, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`GameClosed`] event. + pub fn GameClosed_filter(&self) -> alloy_contract::Event<&P, GameClosed, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Proved`] event. + pub fn Proved_filter(&self) -> alloy_contract::Event<&P, Proved, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Resolved`] event. + pub fn Resolved_filter(&self) -> alloy_contract::Event<&P, Resolved, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/op_succinct_l2_output_oracle.rs b/bindings/src/codegen/op_succinct_l2_output_oracle.rs new file mode 100644 index 000000000..2bcf9f373 --- /dev/null +++ b/bindings/src/codegen/op_succinct_l2_output_oracle.rs @@ -0,0 +1,14201 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library Types { + struct OutputProposal { bytes32 outputRoot; uint128 timestamp; uint128 l2BlockNumber; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod Types { + use super::*; + use alloy::sol_types as alloy_sol_types; + /**```solidity +struct OutputProposal { bytes32 outputRoot; uint128 timestamp; uint128 l2BlockNumber; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct OutputProposal { + #[allow(missing_docs)] + pub outputRoot: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub timestamp: u128, + #[allow(missing_docs)] + pub l2BlockNumber: u128, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<128>, + alloy::sol_types::sol_data::Uint<128>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + u128, + u128, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: OutputProposal) -> Self { + (value.outputRoot, value.timestamp, value.l2BlockNumber) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for OutputProposal { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + outputRoot: tuple.0, + timestamp: tuple.1, + l2BlockNumber: tuple.2, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for OutputProposal { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for OutputProposal { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.outputRoot), + as alloy_sol_types::SolType>::tokenize(&self.timestamp), + as alloy_sol_types::SolType>::tokenize(&self.l2BlockNumber), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for OutputProposal { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for OutputProposal { + const NAME: &'static str = "OutputProposal"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "OutputProposal(bytes32 outputRoot,uint128 timestamp,uint128 l2BlockNumber)", + ) + } + #[inline] + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { + alloy_sol_types::private::Vec::new() + } + #[inline] + fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.outputRoot) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.timestamp) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.l2BlockNumber) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for OutputProposal { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.outputRoot, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.timestamp, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.l2BlockNumber, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.outputRoot, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.timestamp, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.l2BlockNumber, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`Types`](self) contract instance. + +See the [wrapper's documentation](`TypesInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, __provider: P) -> TypesInstance { + TypesInstance::::new(address, __provider) + } + /**A [`Types`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`Types`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct TypesInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for TypesInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("TypesInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > TypesInstance { + /**Creates a new wrapper around an on-chain [`Types`](self) contract instance. + +See the [wrapper's documentation](`TypesInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl TypesInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> TypesInstance { + TypesInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > TypesInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > TypesInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library Types { + struct OutputProposal { + bytes32 outputRoot; + uint128 timestamp; + uint128 l2BlockNumber; + } +} + +interface OPSuccinctL2OutputOracle { + struct InitParams { + address challenger; + address proposer; + address owner; + uint256 finalizationPeriodSeconds; + uint256 l2BlockTime; + bytes32 aggregationVkey; + bytes32 rangeVkeyCommitment; + bytes32 rollupConfigHash; + bytes32 startingOutputRoot; + uint256 startingBlockNumber; + uint256 startingTimestamp; + uint256 submissionInterval; + address verifier; + uint256 fallbackTimeout; + } + struct OpSuccinctConfig { + bytes32 aggregationVkey; + bytes32 rangeVkeyCommitment; + bytes32 rollupConfigHash; + } + + error L1BlockHashNotAvailable(); + error L1BlockHashNotCheckpointed(); + + event DisputeGameFactorySet(address indexed disputeGameFactory); + event Initialized(uint8 version); + event OpSuccinctConfigDeleted(bytes32 indexed configName); + event OpSuccinctConfigUpdated(bytes32 indexed configName, bytes32 aggregationVkey, bytes32 rangeVkeyCommitment, bytes32 rollupConfigHash); + event OptimisticModeToggled(bool indexed enabled, uint256 finalizationPeriodSeconds); + event OutputProposed(bytes32 indexed outputRoot, uint256 indexed l2OutputIndex, uint256 indexed l2BlockNumber, uint256 l1Timestamp); + event OutputsDeleted(uint256 indexed prevNextOutputIndex, uint256 indexed newNextOutputIndex); + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + event ProposerUpdated(address indexed proposer, bool added); + event SubmissionIntervalUpdated(uint256 oldSubmissionInterval, uint256 newSubmissionInterval); + event VerifierUpdated(address indexed oldVerifier, address indexed newVerifier); + + constructor(); + + function GENESIS_CONFIG_NAME() external view returns (bytes32); + function addOpSuccinctConfig(bytes32 _configName, bytes32 _rollupConfigHash, bytes32 _aggregationVkey, bytes32 _rangeVkeyCommitment) external; + function addProposer(address _proposer) external; + function aggregationVkey() external view returns (bytes32); + function approvedProposers(address) external view returns (bool); + function challenger() external view returns (address); + function checkpointBlockHash(uint256 _blockNumber) external; + function computeL2Timestamp(uint256 _l2BlockNumber) external view returns (uint256); + function deleteL2Outputs(uint256 _l2OutputIndex) external; + function deleteOpSuccinctConfig(bytes32 _configName) external; + function dgfProposeL2Output(bytes32 _configName, bytes32 _outputRoot, uint256 _l2BlockNumber, uint256 _l1BlockNumber, bytes memory _proof, address _proverAddress) external payable returns (address _game); + function disableOptimisticMode(uint256 _finalizationPeriodSeconds) external; + function disputeGameFactory() external view returns (address); + function enableOptimisticMode(uint256 _finalizationPeriodSeconds) external; + function fallbackTimeout() external view returns (uint256); + function finalizationPeriodSeconds() external view returns (uint256); + function getL2Output(uint256 _l2OutputIndex) external view returns (Types.OutputProposal memory); + function getL2OutputAfter(uint256 _l2BlockNumber) external view returns (Types.OutputProposal memory); + function getL2OutputIndexAfter(uint256 _l2BlockNumber) external view returns (uint256); + function historicBlockHashes(uint256) external view returns (bytes32); + function initialize(InitParams memory _initParams) external; + function initializerVersion() external view returns (uint8); + function isValidOpSuccinctConfig(OpSuccinctConfig memory _config) external pure returns (bool); + function l2BlockTime() external view returns (uint256); + function lastProposalTimestamp() external view returns (uint256); + function latestBlockNumber() external view returns (uint256); + function latestOutputIndex() external view returns (uint256); + function nextBlockNumber() external view returns (uint256); + function nextOutputIndex() external view returns (uint256); + function opSuccinctConfigs(bytes32) external view returns (bytes32 aggregationVkey, bytes32 rangeVkeyCommitment, bytes32 rollupConfigHash); + function optimisticMode() external view returns (bool); + function owner() external view returns (address); + function proposeL2Output(bytes32 _outputRoot, uint256 _l2BlockNumber, bytes32 _l1BlockHash, uint256 _l1BlockNumber) external payable; + function proposeL2Output(bytes32 _configName, bytes32 _outputRoot, uint256 _l2BlockNumber, uint256 _l1BlockNumber, bytes memory _proof, address _proverAddress) external; + function proposer() external view returns (address); + function rangeVkeyCommitment() external view returns (bytes32); + function removeProposer(address _proposer) external; + function rollupConfigHash() external view returns (bytes32); + function setDisputeGameFactory(address _disputeGameFactory) external; + function startingBlockNumber() external view returns (uint256); + function startingTimestamp() external view returns (uint256); + function submissionInterval() external view returns (uint256); + function transferOwnership(address _owner) external; + function updateSubmissionInterval(uint256 _submissionInterval) external; + function updateVerifier(address _verifier) external; + function verifier() external view returns (address); + function version() external view returns (string memory); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "GENESIS_CONFIG_NAME", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "addOpSuccinctConfig", + "inputs": [ + { + "name": "_configName", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_rollupConfigHash", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_aggregationVkey", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_rangeVkeyCommitment", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "addProposer", + "inputs": [ + { + "name": "_proposer", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "aggregationVkey", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "approvedProposers", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "challenger", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "checkpointBlockHash", + "inputs": [ + { + "name": "_blockNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "computeL2Timestamp", + "inputs": [ + { + "name": "_l2BlockNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "deleteL2Outputs", + "inputs": [ + { + "name": "_l2OutputIndex", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "deleteOpSuccinctConfig", + "inputs": [ + { + "name": "_configName", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "dgfProposeL2Output", + "inputs": [ + { + "name": "_configName", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_outputRoot", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_l2BlockNumber", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_l1BlockNumber", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_proof", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "_proverAddress", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "_game", + "type": "address", + "internalType": "contract IDisputeGame" + } + ], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "disableOptimisticMode", + "inputs": [ + { + "name": "_finalizationPeriodSeconds", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "disputeGameFactory", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "enableOptimisticMode", + "inputs": [ + { + "name": "_finalizationPeriodSeconds", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "fallbackTimeout", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "finalizationPeriodSeconds", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getL2Output", + "inputs": [ + { + "name": "_l2OutputIndex", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct Types.OutputProposal", + "components": [ + { + "name": "outputRoot", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "timestamp", + "type": "uint128", + "internalType": "uint128" + }, + { + "name": "l2BlockNumber", + "type": "uint128", + "internalType": "uint128" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getL2OutputAfter", + "inputs": [ + { + "name": "_l2BlockNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct Types.OutputProposal", + "components": [ + { + "name": "outputRoot", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "timestamp", + "type": "uint128", + "internalType": "uint128" + }, + { + "name": "l2BlockNumber", + "type": "uint128", + "internalType": "uint128" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getL2OutputIndexAfter", + "inputs": [ + { + "name": "_l2BlockNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "historicBlockHashes", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [ + { + "name": "_initParams", + "type": "tuple", + "internalType": "struct OPSuccinctL2OutputOracle.InitParams", + "components": [ + { + "name": "challenger", + "type": "address", + "internalType": "address" + }, + { + "name": "proposer", + "type": "address", + "internalType": "address" + }, + { + "name": "owner", + "type": "address", + "internalType": "address" + }, + { + "name": "finalizationPeriodSeconds", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "l2BlockTime", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "aggregationVkey", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "rangeVkeyCommitment", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "rollupConfigHash", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "startingOutputRoot", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "startingBlockNumber", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "startingTimestamp", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "submissionInterval", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "verifier", + "type": "address", + "internalType": "address" + }, + { + "name": "fallbackTimeout", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "initializerVersion", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isValidOpSuccinctConfig", + "inputs": [ + { + "name": "_config", + "type": "tuple", + "internalType": "struct OPSuccinctL2OutputOracle.OpSuccinctConfig", + "components": [ + { + "name": "aggregationVkey", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "rangeVkeyCommitment", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "rollupConfigHash", + "type": "bytes32", + "internalType": "bytes32" + } + ] + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "l2BlockTime", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "lastProposalTimestamp", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "latestBlockNumber", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "latestOutputIndex", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "nextBlockNumber", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "nextOutputIndex", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "opSuccinctConfigs", + "inputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "outputs": [ + { + "name": "aggregationVkey", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "rangeVkeyCommitment", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "rollupConfigHash", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "optimisticMode", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proposeL2Output", + "inputs": [ + { + "name": "_outputRoot", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_l2BlockNumber", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_l1BlockHash", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_l1BlockNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "proposeL2Output", + "inputs": [ + { + "name": "_configName", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_outputRoot", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_l2BlockNumber", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_l1BlockNumber", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_proof", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "_proverAddress", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "proposer", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "rangeVkeyCommitment", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "removeProposer", + "inputs": [ + { + "name": "_proposer", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "rollupConfigHash", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setDisputeGameFactory", + "inputs": [ + { + "name": "_disputeGameFactory", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "startingBlockNumber", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "startingTimestamp", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "submissionInterval", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "_owner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "updateSubmissionInterval", + "inputs": [ + { + "name": "_submissionInterval", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "updateVerifier", + "inputs": [ + { + "name": "_verifier", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "verifier", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "DisputeGameFactorySet", + "inputs": [ + { + "name": "disputeGameFactory", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Initialized", + "inputs": [ + { + "name": "version", + "type": "uint8", + "indexed": false, + "internalType": "uint8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OpSuccinctConfigDeleted", + "inputs": [ + { + "name": "configName", + "type": "bytes32", + "indexed": true, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OpSuccinctConfigUpdated", + "inputs": [ + { + "name": "configName", + "type": "bytes32", + "indexed": true, + "internalType": "bytes32" + }, + { + "name": "aggregationVkey", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + }, + { + "name": "rangeVkeyCommitment", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + }, + { + "name": "rollupConfigHash", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OptimisticModeToggled", + "inputs": [ + { + "name": "enabled", + "type": "bool", + "indexed": true, + "internalType": "bool" + }, + { + "name": "finalizationPeriodSeconds", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OutputProposed", + "inputs": [ + { + "name": "outputRoot", + "type": "bytes32", + "indexed": true, + "internalType": "bytes32" + }, + { + "name": "l2OutputIndex", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "l2BlockNumber", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "l1Timestamp", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OutputsDeleted", + "inputs": [ + { + "name": "prevNextOutputIndex", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "newNextOutputIndex", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ProposerUpdated", + "inputs": [ + { + "name": "proposer", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "added", + "type": "bool", + "indexed": false, + "internalType": "bool" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "SubmissionIntervalUpdated", + "inputs": [ + { + "name": "oldSubmissionInterval", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "newSubmissionInterval", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "VerifierUpdated", + "inputs": [ + { + "name": "oldVerifier", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newVerifier", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "L1BlockHashNotAvailable", + "inputs": [] + }, + { + "type": "error", + "name": "L1BlockHashNotCheckpointed", + "inputs": [] + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod OPSuccinctL2OutputOracle { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[Pb\0\0\"b\0\0(` \x1B` \x1CV[b\0\x01\xD3V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15b\0\0{W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01b\0\0r\x90b\0\x01vV[`@Q\x80\x91\x03\x90\xFD[`\xFF\x80\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10\x15b\0\0\xEDW`\xFF`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98`\xFF`@Qb\0\0\xE4\x91\x90b\0\x01\xB6V[`@Q\x80\x91\x03\x90\xA1[V[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[\x7FInitializable: contract is initi`\0\x82\x01R\x7Falizing\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0b\0\x01^`'\x83b\0\0\xEFV[\x91Pb\0\x01k\x82b\0\x01\0V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Rb\0\x01\x91\x81b\0\x01OV[\x90P\x91\x90PV[`\0`\xFF\x82\x16\x90P\x91\x90PV[b\0\x01\xB0\x81b\0\x01\x98V[\x82RPPV[`\0` \x82\x01\x90Pb\0\x01\xCD`\0\x83\x01\x84b\0\x01\xA5V[\x92\x91PPV[aQ?\x80b\0\x01\xE3`\09`\0\xF3\xFE`\x80`@R`\x046\x10a\x02\x88W`\x005`\xE0\x1C\x80c\x88xbr\x11a\x01ZW\x80c\xCE]\xB8\xD6\x11a\0\xC1W\x80c\xE1\xA4\x1B\xCF\x11a\0zW\x80c\xE1\xA4\x1B\xCF\x14a\t\xE2W\x80c\xE4\x0Bz\x12\x14a\n\rW\x80c\xEC[.:\x14a\n6W\x80c\xF2\xB4\xE6\x17\x14a\n_W\x80c\xF2\xFD\xE3\x8B\x14a\n\x8AW\x80c\xF7/`m\x14a\n\xB3Wa\x02\x88V[\x80c\xCE]\xB8\xD6\x14a\x08\xAAW\x80c\xCF\x8E\\\xF0\x14a\x08\xD5W\x80c\xD1\xDE\x85l\x14a\t\x12W\x80c\xD4e\x12v\x14a\tOW\x80c\xDC\xEC3H\x14a\t\x8CW\x80c\xE0\xC2\xF95\x14a\t\xB7Wa\x02\x88V[\x80c\xA1\x96\xB5%\x11a\x01\x13W\x80c\xA1\x96\xB5%\x14a\x07\x88W\x80c\xA2Z\xE5W\x14a\x07\xC5W\x80c\xA4\xEE\x9D{\x14a\x08\x02W\x80c\xA8\xE4\xFB\x90\x14a\x08+W\x80c\xB0<\xD4\x18\x14a\x08VW\x80c\xC3.N>\x14a\x08\x7FWa\x02\x88V[\x80c\x88xbr\x14a\x06\x99W\x80c\x89\xC4L\xBB\x14a\x06\xC4W\x80c\x8D\xA5\xCB[\x14a\x06\xEDW\x80c\x93\x99\x1A\xF3\x14a\x07\x18W\x80c\x97\xFC\0|\x14a\x07CW\x80c\x9A\xAA\xB6H\x14a\x07lWa\x02\x88V[\x80cJ\xB3\t\xAC\x11a\x01\xFEW\x80cj\xBC\xF5c\x11a\x01\xB7W\x80cj\xBC\xF5c\x14a\x05\x80W\x80cm\x9A\x1C\x8B\x14a\x05\xABW\x80cp\x87*\xA5\x14a\x05\xD6W\x80czA\xA05\x14a\x06\x01W\x80c\x7F\0d \x14a\x061W\x80c\x7F\x01\xEAh\x14a\x06nWa\x02\x88V[\x80cJ\xB3\t\xAC\x14a\x04lW\x80cSM\xB0\xE2\x14a\x04\x95W\x80cT\xFDMP\x14a\x04\xC0W\x80c`\xCA\xF7\xA0\x14a\x04\xEBW\x80ci\xF1n\xEC\x14a\x05\x16W\x80cjVb\x0B\x14a\x05AWa\x02\x88V[\x80c3l\x9E\x81\x11a\x02PW\x80c3l\x9E\x81\x14a\x03^W\x80c4\x19\xD2\xC2\x14a\x03\x87W\x80cBw\xBC\x06\x14a\x03\xB0W\x80cE\x99\xC7\x88\x14a\x03\xDBW\x80cG\xC3~\x9C\x14a\x04\x06W\x80cI\x18^\x06\x14a\x04/Wa\x02\x88V[\x80c\t\xD62\xD3\x14a\x02\x8DW\x80c\x1E\x85h\0\x14a\x02\xB6W\x80c+1\x84\x1E\x14a\x02\xDFW\x80c+z\xC3\xF3\x14a\x03\nW\x80c,iya\x14a\x035W[`\0\x80\xFD[4\x80\x15a\x02\x99W`\0\x80\xFD[Pa\x02\xB4`\x04\x806\x03\x81\x01\x90a\x02\xAF\x91\x90a2vV[a\n\xDEV[\0[4\x80\x15a\x02\xC2W`\0\x80\xFD[Pa\x02\xDD`\x04\x806\x03\x81\x01\x90a\x02\xD8\x91\x90a2\xD9V[a\x0C\x18V[\0[4\x80\x15a\x02\xEBW`\0\x80\xFD[Pa\x02\xF4a\x0CvV[`@Qa\x03\x01\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x16W`\0\x80\xFD[Pa\x03\x1Fa\x0C|V[`@Qa\x03,\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03AW`\0\x80\xFD[Pa\x03\\`\x04\x806\x03\x81\x01\x90a\x03W\x91\x90a2\xD9V[a\x0C\xA2V[\0[4\x80\x15a\x03jW`\0\x80\xFD[Pa\x03\x85`\x04\x806\x03\x81\x01\x90a\x03\x80\x91\x90a2\xD9V[a\r\xE2V[\0[4\x80\x15a\x03\x93W`\0\x80\xFD[Pa\x03\xAE`\x04\x806\x03\x81\x01\x90a\x03\xA9\x91\x90a2vV[a\x0E\xFAV[\0[4\x80\x15a\x03\xBCW`\0\x80\xFD[Pa\x03\xC5a\x10\x11V[`@Qa\x03\xD2\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xE7W`\0\x80\xFD[Pa\x03\xF0a\x10\x17V[`@Qa\x03\xFD\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x12W`\0\x80\xFD[Pa\x04-`\x04\x806\x03\x81\x01\x90a\x04(\x91\x90a3\xBAV[a\x10\x98V[\0[4\x80\x15a\x04;W`\0\x80\xFD[Pa\x04V`\x04\x806\x03\x81\x01\x90a\x04Q\x91\x90a5\x16V[a\x12\xD0V[`@Qa\x04c\x91\x90a5^V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04xW`\0\x80\xFD[Pa\x04\x93`\x04\x806\x03\x81\x01\x90a\x04\x8E\x91\x90a2\xD9V[a\x13\nV[\0[4\x80\x15a\x04\xA1W`\0\x80\xFD[Pa\x04\xAAa\x14IV[`@Qa\x04\xB7\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xCCW`\0\x80\xFD[Pa\x04\xD5a\x14oV[`@Qa\x04\xE2\x91\x90a6\x01V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xF7W`\0\x80\xFD[Pa\x05\0a\x14\xA8V[`@Qa\x05\r\x91\x90a5^V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\"W`\0\x80\xFD[Pa\x05+a\x14\xBBV[`@Qa\x058\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05MW`\0\x80\xFD[Pa\x05h`\x04\x806\x03\x81\x01\x90a\x05c\x91\x90a6#V[a\x14\xD4V[`@Qa\x05w\x93\x92\x91\x90a6PV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\x8CW`\0\x80\xFD[Pa\x05\x95a\x14\xFEV[`@Qa\x05\xA2\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\xB7W`\0\x80\xFD[Pa\x05\xC0a\x15\x0BV[`@Qa\x05\xCD\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\xE2W`\0\x80\xFD[Pa\x05\xEBa\x15\x11V[`@Qa\x05\xF8\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[a\x06\x1B`\x04\x806\x03\x81\x01\x90a\x06\x16\x91\x90a7AV[a\x15\x17V[`@Qa\x06(\x91\x90a8IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06=W`\0\x80\xFD[Pa\x06X`\x04\x806\x03\x81\x01\x90a\x06S\x91\x90a2\xD9V[a\x17\x07V[`@Qa\x06e\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06zW`\0\x80\xFD[Pa\x06\x83a\x18NV[`@Qa\x06\x90\x91\x90a8\x80V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06\xA5W`\0\x80\xFD[Pa\x06\xAEa\x18SV[`@Qa\x06\xBB\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06\xD0W`\0\x80\xFD[Pa\x06\xEB`\x04\x806\x03\x81\x01\x90a\x06\xE6\x91\x90a2\xD9V[a\x18YV[\0[4\x80\x15a\x06\xF9W`\0\x80\xFD[Pa\x07\x02a\x1AWV[`@Qa\x07\x0F\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07$W`\0\x80\xFD[Pa\x07-a\x1A}V[`@Qa\x07:\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07OW`\0\x80\xFD[Pa\x07j`\x04\x806\x03\x81\x01\x90a\x07e\x91\x90a2vV[a\x1A\x83V[\0[a\x07\x86`\x04\x806\x03\x81\x01\x90a\x07\x81\x91\x90a8\x9BV[a\x1B\xD3V[\0[4\x80\x15a\x07\x94W`\0\x80\xFD[Pa\x07\xAF`\x04\x806\x03\x81\x01\x90a\x07\xAA\x91\x90a2\xD9V[a\x1FcV[`@Qa\x07\xBC\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07\xD1W`\0\x80\xFD[Pa\x07\xEC`\x04\x806\x03\x81\x01\x90a\x07\xE7\x91\x90a2\xD9V[a\x1F{V[`@Qa\x07\xF9\x91\x90a9~V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\x0EW`\0\x80\xFD[Pa\x08)`\x04\x806\x03\x81\x01\x90a\x08$\x91\x90a7AV[a UV[\0[4\x80\x15a\x087W`\0\x80\xFD[Pa\x08@a&\xC6V[`@Qa\x08M\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08bW`\0\x80\xFD[Pa\x08}`\x04\x806\x03\x81\x01\x90a\x08x\x91\x90a2vV[a&\xECV[\0[4\x80\x15a\x08\x8BW`\0\x80\xFD[Pa\x08\x94a(&V[`@Qa\x08\xA1\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\xB6W`\0\x80\xFD[Pa\x08\xBFa(,V[`@Qa\x08\xCC\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\xE1W`\0\x80\xFD[Pa\x08\xFC`\x04\x806\x03\x81\x01\x90a\x08\xF7\x91\x90a2\xD9V[a(2V[`@Qa\t\t\x91\x90a9~V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\x1EW`\0\x80\xFD[Pa\t9`\x04\x806\x03\x81\x01\x90a\t4\x91\x90a2\xD9V[a)\x14V[`@Qa\tF\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t[W`\0\x80\xFD[Pa\tv`\x04\x806\x03\x81\x01\x90a\tq\x91\x90a2vV[a)EV[`@Qa\t\x83\x91\x90a5^V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\x98W`\0\x80\xFD[Pa\t\xA1a)eV[`@Qa\t\xAE\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\xC3W`\0\x80\xFD[Pa\t\xCCa)\x81V[`@Qa\t\xD9\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\xEEW`\0\x80\xFD[Pa\t\xF7a*\x02V[`@Qa\n\x04\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\n\x19W`\0\x80\xFD[Pa\n4`\x04\x806\x03\x81\x01\x90a\n/\x91\x90a:\xE7V[a*\x08V[\0[4\x80\x15a\nBW`\0\x80\xFD[Pa\n]`\x04\x806\x03\x81\x01\x90a\nX\x91\x90a6#V[a/4V[\0[4\x80\x15a\nkW`\0\x80\xFD[Pa\nta0\"V[`@Qa\n\x81\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\n\x96W`\0\x80\xFD[Pa\n\xB1`\x04\x806\x03\x81\x01\x90a\n\xAC\x91\x90a2vV[a0HV[\0[4\x80\x15a\n\xBFW`\0\x80\xFD[Pa\n\xC8a1\x98V[`@Qa\n\xD5\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x0BnW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x0Be\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[`\0`\x0E`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F]\xF3\x8D9^\xDC\x15\xB6i\xD6FV\x9B\xD0\x15Q3\x95\x07\x0B[M\xEB\x8A\x160\n\xBB\x06\r\x1BZ`\0`@Qa\x0C\r\x91\x90a5^V[`@Q\x80\x91\x03\x90\xA2PV[`\0\x81@\x90P`\0\x80\x1B\x81\x03a\x0CZW`@Q\x7F\x84\xC0hd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80`\x0F`\0\x84\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPPPV[`\nT\x81V[`\x0B`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\r2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\r)\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a\r\x82W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\ry\x90a<\x19V[`@Q\x80\x91\x03\x90\xFD[\x80`\x08\x81\x90UP`\x01`\x10`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\x01\x15\x15\x7F\x1F\\\x87/\x1E\xA9\x8AV[`@Q\x80\x91\x03\x90\xFD[`\0`@Q\x80``\x01`@R\x80\x84\x81R` \x01\x83\x81R` \x01\x85\x81RP\x90Pa\x12\x19\x81a\x12\xD0V[a\x12XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x12O\x90a?\x1CV[`@Q\x80\x91\x03\x90\xFD[\x80`\x12`\0\x87\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U`@\x82\x01Q\x81`\x02\x01U\x90PP\x84\x7F\xEA\x01#\xC7&\xA6e\xCB\n\xB5i\x14D\xF9)\xA7\x05lzw\t\xC6\x0C\x05\x87\x82\x9E\x80F\xB8\xD5\x14\x84\x84\x87`@Qa\x12\xC1\x93\x92\x91\x90a6PV[`@Q\x80\x91\x03\x90\xA2PPPPPV[`\0\x80`\0\x1B\x82`\0\x01Q\x14\x15\x80\x15a\x12\xF0WP`\0\x80\x1B\x82` \x01Q\x14\x15[\x80\x15a\x13\x03WP`\0\x80\x1B\x82`@\x01Q\x14\x15[\x90P\x91\x90PV[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x13\x9AW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x13\x91\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\x13\xE9W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x13\xE0\x90a?\xAEV[`@Q\x80\x91\x03\x90\xFD[\x80`\x08\x81\x90UP`\0`\x10`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\0\x15\x15\x7F\x1F\\\x87/\x1E\xA9\x91\x90a3sV[`@Q\x80\x91\x03\x90\xA2PV[`\x06`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fv3.0.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0`\x01`\x03\x80T\x90Pa\x14\xCF\x91\x90a=#V[\x90P\x90V[`\x12` R\x80`\0R`@`\0 `\0\x91P\x90P\x80`\0\x01T\x90\x80`\x01\x01T\x90\x80`\x02\x01T\x90P\x83V[`\0`\x03\x80T\x90P\x90P\x90V[`\x0CT\x81V[`\x01T\x81V[`\0`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a\x15iW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x15`\x90a<\x19V[`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x13`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x15\xFAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x15\xF1\x90a@@V[`@Q\x80\x91\x03\x90\xFD[`\x01`\x13`\x14a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\x13`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x82\xEC\xF2\xF64`\x06\x89\x89\x89\x88\x8E\x8B`@Q` \x01a\x16p\x95\x94\x93\x92\x91\x90aA1V[`@Q` \x81\x83\x03\x03\x81R\x90`@R`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x16\x9D\x93\x92\x91\x90aB8V[` `@Q\x80\x83\x03\x81\x85\x88Z\xF1\x15\x80\x15a\x16\xBBW=`\0\x80>=`\0\xFD[PPPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16\xE0\x91\x90aB\xB4V[\x90P`\0`\x13`\x14a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x96\x95PPPPPPV[`\0a\x17\x11a\x10\x17V[\x82\x11\x15a\x17SW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x17J\x90aCyV[`@Q\x80\x91\x03\x90\xFD[`\0`\x03\x80T\x90P\x11a\x17\x9BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x17\x92\x90aD1V[`@Q\x80\x91\x03\x90\xFD[`\0\x80`\x03\x80T\x90P\x90P[\x80\x82\x10\x15a\x18DW`\0`\x02\x82\x84a\x17\xBF\x91\x90aDQV[a\x17\xC9\x91\x90aD\xD6V[\x90P\x84`\x03\x82\x81T\x81\x10a\x17\xE0Wa\x17\xDFa=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`\x01\x01`\x10\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10\x15a\x18:W`\x01\x81a\x183\x91\x90aDQV[\x92Pa\x18>V[\x80\x91P[Pa\x17\xA7V[\x81\x92PPP\x91\x90PV[`\x03\x81V[`\x02T\x81V[`\x06`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x18\xE9W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x18\xE0\x90aEyV[`@Q\x80\x91\x03\x90\xFD[`\0\x81\x11a\x19,W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x19#\x90aF\x0BV[`@Q\x80\x91\x03\x90\xFD[`\x03\x80T\x90P\x81\x10a\x19sW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x19j\x90aF\xC3V[`@Q\x80\x91\x03\x90\xFD[`\x08T`\x03\x82\x81T\x81\x10a\x19\x8AWa\x19\x89a=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`\x01\x01`\0\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16Ba\x19\xD5\x91\x90a=#V[\x10a\x1A\x15W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1A\x0C\x90aG{V[`@Q\x80\x91\x03\x90\xFD[`\0a\x1A\x1Fa\x14\xFEV[\x90P\x81`\x03U\x81\x81\x7FN\xE3z\xC2\xC7\x86\xEC\x85\xE8u\x92\xD3\xC5\xC8\xA1\xDDf\xF8Im\xDA?\x12]\x9E\xA8\xCA_ev)\xB6`@Q`@Q\x80\x91\x03\x90\xA3PPV[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x05T\x81V[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x1B\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1B\n\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x0B`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x02CT\x9A\x92\xB2A/z<\xAFz.V\xD6[\x88!\xB9\x13E6?\xAA_W\x19S\x84\x06_\xCC`@Q`@Q\x80\x91\x03\x90\xA3\x80`\x0B`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPV[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\x1C\"W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1C\x19\x90a?\xAEV[`@Q\x80\x91\x03\x90\xFD[`\x0E`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x80a\x1C\xC3WP`\x0E`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16[a\x1D\x02W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1C\xF9\x90aH\rV[`@Q\x80\x91\x03\x90\xFD[a\x1D\na)eV[\x83\x14a\x1DKW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1DB\x90aH\xC5V[`@Q\x80\x91\x03\x90\xFD[Ba\x1DU\x84a)\x14V[\x10a\x1D\x95W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1D\x8C\x90aIWV[`@Q\x80\x91\x03\x90\xFD[`\0\x80\x1B\x84\x03a\x1D\xDAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1D\xD1\x90aI\xE9V[`@Q\x80\x91\x03\x90\xFD[`\0\x80\x1B\x82\x14a\x1E(W\x81\x81@\x14a\x1E'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1E\x1E\x90aJ\xA1V[`@Q\x80\x91\x03\x90\xFD[[\x82a\x1E1a\x14\xFEV[\x85\x7F\xA7\xAA\xF2Q'i\xDANDN=\xE2G\xBE%d\"\\.z\x8Ft\xCF\xE5(\xE4n\x17\xD2Hh\xE2B`@Qa\x1Ea\x91\x90a3sV[`@Q\x80\x91\x03\x90\xA4`\x03`@Q\x80``\x01`@R\x80\x86\x81R` \x01Bo\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90\x80`\x01\x81T\x01\x80\x82U\x80\x91PP`\x01\x90\x03\x90`\0R` `\0 \x90`\x02\x02\x01`\0\x90\x91\x90\x91\x90\x91P`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01`\0a\x01\0\n\x81T\x81o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`@\x82\x01Q\x81`\x01\x01`\x10a\x01\0\n\x81T\x81o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPPPPPPV[`\x0F` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[a\x1F\x83a1\xBCV[`\x03\x82\x81T\x81\x10a\x1F\x97Wa\x1F\x96a=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`@Q\x80``\x01`@R\x90\x81`\0\x82\x01T\x81R` \x01`\x01\x82\x01`\0\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01`\x01\x82\x01`\x10\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x90P\x91\x90PV[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a \xA5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a \x9C\x90a<\x19V[`@Q\x80\x91\x03\x90\xFD[`\x0E`\x002s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x80a!FWP`\x0E`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16[\x80a!dWP`\x11Ta!Wa)\x81V[Ba!b\x91\x90a=#V[\x11[a!\xA3W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a!\x9A\x90aH\rV[`@Q\x80\x91\x03\x90\xFD[a!\xABa)eV[\x84\x10\x15a!\xEDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a!\xE4\x90aKYV[`@Q\x80\x91\x03\x90\xFD[Ba!\xF7\x85a)\x14V[\x10a\"7W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\".\x90aIWV[`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x13`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\"\xE1W`\x13`\x14\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\"\xDCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\"\xD3\x90aL7V[`@Q\x80\x91\x03\x90\xFD[a#2V[`\x13`\x14\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a#1W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a#(\x90aM\x15V[`@Q\x80\x91\x03\x90\xFD[[`\0\x80\x1B\x85\x03a#wW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a#n\x90aI\xE9V[`@Q\x80\x91\x03\x90\xFD[`\0`\x12`\0\x88\x81R` \x01\x90\x81R` \x01`\0 `@Q\x80``\x01`@R\x90\x81`\0\x82\x01T\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01T\x81RPP\x90Pa#\xC0\x81a\x12\xD0V[a#\xFFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a#\xF6\x90aM\xA7V[`@Q\x80\x91\x03\x90\xFD[`\0`\x0F`\0\x86\x81R` \x01\x90\x81R` \x01`\0 T\x90P`\0\x80\x1B\x81\x03a$SW`@Q\x7F\"\xAA:\x98\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`@Q\x80`\xE0\x01`@R\x80\x83\x81R` \x01`\x03a$pa\x14\xBBV[\x81T\x81\x10a$\x81Wa$\x80a=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`\0\x01T\x81R` \x01\x89\x81R` \x01\x88\x81R` \x01\x84`@\x01Q\x81R` \x01\x84` \x01Q\x81R` \x01\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90P`\x0B`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cAI<`\x84`\0\x01Q\x83`@Q` \x01a%(\x91\x90aNsV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x88`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a%V\x93\x92\x91\x90aN\x8EV[`\0`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a%nW`\0\x80\xFD[PZ\xFA\x15\x80\x15a%\x82W=`\0\x80>=`\0\xFD[PPPP\x86a%\x8Fa\x14\xFEV[\x89\x7F\xA7\xAA\xF2Q'i\xDANDN=\xE2G\xBE%d\"\\.z\x8Ft\xCF\xE5(\xE4n\x17\xD2Hh\xE2B`@Qa%\xBF\x91\x90a3sV[`@Q\x80\x91\x03\x90\xA4`\x03`@Q\x80``\x01`@R\x80\x8A\x81R` \x01Bo\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x89o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90\x80`\x01\x81T\x01\x80\x82U\x80\x91PP`\x01\x90\x03\x90`\0R` `\0 \x90`\x02\x02\x01`\0\x90\x91\x90\x91\x90\x91P`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01`\0a\x01\0\n\x81T\x81o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`@\x82\x01Q\x81`\x01\x01`\x10a\x01\0\n\x81T\x81o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPPPPPPPPPPPV[`\x07`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a'|W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a's\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[`\x01`\x0E`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F]\xF3\x8D9^\xDC\x15\xB6i\xD6FV\x9B\xD0\x15Q3\x95\x07\x0B[M\xEB\x8A\x160\n\xBB\x06\r\x1BZ`\x01`@Qa(\x1B\x91\x90a5^V[`@Q\x80\x91\x03\x90\xA2PV[`\tT\x81V[`\x08T\x81V[a(:a1\xBCV[`\x03a(E\x83a\x17\x07V[\x81T\x81\x10a(VWa(Ua=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`@Q\x80``\x01`@R\x90\x81`\0\x82\x01T\x81R` \x01`\x01\x82\x01`\0\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01`\x01\x82\x01`\x10\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x90P\x91\x90PV[`\0`\x05T`\x01T\x83a)'\x91\x90a=#V[a)1\x91\x90aN\xD3V[`\x02Ta)>\x91\x90aDQV[\x90P\x91\x90PV[`\x0E` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0`\x04Ta)ra\x10\x17V[a)|\x91\x90aDQV[\x90P\x90V[`\0\x80`\x03\x80T\x90P\x14a)\xF9W`\x03`\x01`\x03\x80T\x90Pa)\xA3\x91\x90a=#V[\x81T\x81\x10a)\xB4Wa)\xB3a=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`\x01\x01`\0\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a)\xFDV[`\x02T[\x90P\x90V[`\x04T\x81V[`\x03`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15\x80\x15a*9WP\x80`\xFF\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10[a*xW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a*o\x90aO\x9FV[`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP`\x01`\0`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\0\x82a\x01`\x01Q\x11a*\xF5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a*\xEC\x90a<\xABV[`@Q\x80\x91\x03\x90\xFD[`\0\x82`\x80\x01Q\x11a+\x15\\f\x90\xE4\xB7\xF3\x9A\xFAA\xA2\xA8\xFF\x8C\n\xA4%\xDA`@Q`@Q\x80\x91\x03\x90\xA2PV[`\x13`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a0\xD8W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a0\xCF\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0`@Q`@Q\x80\x91\x03\x90\xA3\x80`\r`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPV[\x7F\xAE\x83\x04\xF4\x0Fq#\xE0\xC8{\x97\xF8\xA6\0\xE9O\xF3\xA3\xA2[\xE5\x88\xFCf\xB8\xA3q|\x89Y\xCEw\x81V[`@Q\x80``\x01`@R\x80`\0\x80\x19\x16\x81R` \x01`\0o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01`\0o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90V[`\0`@Q\x90P\x90V[`\0\x80\xFD[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a2C\x82a2\x18V[\x90P\x91\x90PV[a2S\x81a28V[\x81\x14a2^W`\0\x80\xFD[PV[`\0\x815\x90Pa2p\x81a2JV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a2\x8CWa2\x8Ba2\x0EV[[`\0a2\x9A\x84\x82\x85\x01a2aV[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a2\xB6\x81a2\xA3V[\x81\x14a2\xC1W`\0\x80\xFD[PV[`\0\x815\x90Pa2\xD3\x81a2\xADV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a2\xEFWa2\xEEa2\x0EV[[`\0a2\xFD\x84\x82\x85\x01a2\xC4V[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a3\x19\x81a3\x06V[\x82RPPV[`\0` \x82\x01\x90Pa34`\0\x83\x01\x84a3\x10V[\x92\x91PPV[a3C\x81a28V[\x82RPPV[`\0` \x82\x01\x90Pa3^`\0\x83\x01\x84a3:V[\x92\x91PPV[a3m\x81a2\xA3V[\x82RPPV[`\0` \x82\x01\x90Pa3\x88`\0\x83\x01\x84a3dV[\x92\x91PPV[a3\x97\x81a3\x06V[\x81\x14a3\xA2W`\0\x80\xFD[PV[`\0\x815\x90Pa3\xB4\x81a3\x8EV[\x92\x91PPV[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15a3\xD4Wa3\xD3a2\x0EV[[`\0a3\xE2\x87\x82\x88\x01a3\xA5V[\x94PP` a3\xF3\x87\x82\x88\x01a3\xA5V[\x93PP`@a4\x04\x87\x82\x88\x01a3\xA5V[\x92PP``a4\x15\x87\x82\x88\x01a3\xA5V[\x91PP\x92\x95\x91\x94P\x92PV[`\0\x80\xFD[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`A`\x04R`$`\0\xFD[a4o\x82a4&V[\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a4\x8EWa4\x8Da47V[[\x80`@RPPPV[`\0a4\xA1a2\x04V[\x90Pa4\xAD\x82\x82a4fV[\x91\x90PV[`\0``\x82\x84\x03\x12\x15a4\xC8Wa4\xC7a4!V[[a4\xD2``a4\x97V[\x90P`\0a4\xE2\x84\x82\x85\x01a3\xA5V[`\0\x83\x01RP` a4\xF6\x84\x82\x85\x01a3\xA5V[` \x83\x01RP`@a5\n\x84\x82\x85\x01a3\xA5V[`@\x83\x01RP\x92\x91PPV[`\0``\x82\x84\x03\x12\x15a5,Wa5+a2\x0EV[[`\0a5:\x84\x82\x85\x01a4\xB2V[\x91PP\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a5X\x81a5CV[\x82RPPV[`\0` \x82\x01\x90Pa5s`\0\x83\x01\x84a5OV[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a5\xB3W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa5\x98V[\x83\x81\x11\x15a5\xC2W`\0\x84\x84\x01R[PPPPV[`\0a5\xD3\x82a5yV[a5\xDD\x81\x85a5\x84V[\x93Pa5\xED\x81\x85` \x86\x01a5\x95V[a5\xF6\x81a4&V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra6\x1B\x81\x84a5\xC8V[\x90P\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a69Wa68a2\x0EV[[`\0a6G\x84\x82\x85\x01a3\xA5V[\x91PP\x92\x91PPV[`\0``\x82\x01\x90Pa6e`\0\x83\x01\x86a3\x10V[a6r` \x83\x01\x85a3\x10V[a6\x7F`@\x83\x01\x84a3\x10V[\x94\x93PPPPV[`\0\x80\xFD[`\0\x80\xFD[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a6\xACWa6\xABa47V[[a6\xB5\x82a4&V[\x90P` \x81\x01\x90P\x91\x90PV[\x82\x81\x837`\0\x83\x83\x01RPPPV[`\0a6\xE4a6\xDF\x84a6\x91V[a4\x97V[\x90P\x82\x81R` \x81\x01\x84\x84\x84\x01\x11\x15a7\0Wa6\xFFa6\x8CV[[a7\x0B\x84\x82\x85a6\xC2V[P\x93\x92PPPV[`\0\x82`\x1F\x83\x01\x12a7(Wa7'a6\x87V[[\x815a78\x84\x82` \x86\x01a6\xD1V[\x91PP\x92\x91PPV[`\0\x80`\0\x80`\0\x80`\xC0\x87\x89\x03\x12\x15a7^Wa7]a2\x0EV[[`\0a7l\x89\x82\x8A\x01a3\xA5V[\x96PP` a7}\x89\x82\x8A\x01a3\xA5V[\x95PP`@a7\x8E\x89\x82\x8A\x01a2\xC4V[\x94PP``a7\x9F\x89\x82\x8A\x01a2\xC4V[\x93PP`\x80\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xC0Wa7\xBFa2\x13V[[a7\xCC\x89\x82\x8A\x01a7\x13V[\x92PP`\xA0a7\xDD\x89\x82\x8A\x01a2aV[\x91PP\x92\x95P\x92\x95P\x92\x95V[`\0\x81\x90P\x91\x90PV[`\0a8\x0Fa8\na8\x05\x84a2\x18V[a7\xEAV[a2\x18V[\x90P\x91\x90PV[`\0a8!\x82a7\xF4V[\x90P\x91\x90PV[`\0a83\x82a8\x16V[\x90P\x91\x90PV[a8C\x81a8(V[\x82RPPV[`\0` \x82\x01\x90Pa8^`\0\x83\x01\x84a8:V[\x92\x91PPV[`\0`\xFF\x82\x16\x90P\x91\x90PV[a8z\x81a8dV[\x82RPPV[`\0` \x82\x01\x90Pa8\x95`\0\x83\x01\x84a8qV[\x92\x91PPV[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15a8\xB5Wa8\xB4a2\x0EV[[`\0a8\xC3\x87\x82\x88\x01a3\xA5V[\x94PP` a8\xD4\x87\x82\x88\x01a2\xC4V[\x93PP`@a8\xE5\x87\x82\x88\x01a3\xA5V[\x92PP``a8\xF6\x87\x82\x88\x01a2\xC4V[\x91PP\x92\x95\x91\x94P\x92PV[a9\x0B\x81a3\x06V[\x82RPPV[`\0o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a96\x81a9\x11V[\x82RPPV[``\x82\x01`\0\x82\x01Qa9R`\0\x85\x01\x82a9\x02V[P` \x82\x01Qa9e` \x85\x01\x82a9-V[P`@\x82\x01Qa9x`@\x85\x01\x82a9-V[PPPPV[`\0``\x82\x01\x90Pa9\x93`\0\x83\x01\x84a9\x11\x81a=\xD5V[\x90P\x91\x90PV[\x7FL2OutputOracle: config already e`\0\x82\x01R\x7Fxists\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a>t`%\x83a5\x84V[\x91Pa>\x7F\x82a>\x18V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra>\xA3\x81a>gV[\x90P\x91\x90PV[\x7FL2OutputOracle: invalid OP Succi`\0\x82\x01R\x7Fnct configuration parameters\0\0\0\0` \x82\x01RPV[`\0a?\x06`<\x83a5\x84V[\x91Pa?\x11\x82a>\xAAV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra?5\x81a>\xF9V[\x90P\x91\x90PV[\x7FL2OutputOracle: optimistic mode `\0\x82\x01R\x7Fis not enabled\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a?\x98`.\x83a5\x84V[\x91Pa?\xA3\x82a?\x83a5\x84V[\x91PaEn\x82aE\x07V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaE\x92\x81aEVV[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot delete ge`\0\x82\x01R\x7Fnesis output\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aE\xF5`,\x83a5\x84V[\x91PaF\0\x82aE\x99V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaF$\x81aE\xE8V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot delete ou`\0\x82\x01R\x7Ftputs after the latest output in` \x82\x01R\x7Fdex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aF\xAD`C\x83a5\x84V[\x91PaF\xB8\x82aF+V[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaF\xDC\x81aF\xA0V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot delete ou`\0\x82\x01R\x7Ftputs that have already been fin` \x82\x01R\x7Falized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aGe`F\x83a5\x84V[\x91PaGp\x82aF\xE3V[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaG\x94\x81aGXV[\x90P\x91\x90PV[\x7FL2OutputOracle: only approved pr`\0\x82\x01R\x7Foposers can propose new outputs\0` \x82\x01RPV[`\0aG\xF7`?\x83a5\x84V[\x91PaH\x02\x82aG\x9BV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaH&\x81aG\xEAV[\x90P\x91\x90PV[\x7FL2OutputOracle: block number mus`\0\x82\x01R\x7Ft be equal to next expected bloc` \x82\x01R\x7Fk number\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aH\xAF`H\x83a5\x84V[\x91PaH\xBA\x82aH-V[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaH\xDE\x81aH\xA2V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot propose L`\0\x82\x01R\x7F2 output in the future\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aIA`6\x83a5\x84V[\x91PaIL\x82aH\xE5V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaIp\x81aI4V[\x90P\x91\x90PV[\x7FL2OutputOracle: L2 output propos`\0\x82\x01R\x7Fal cannot be the zero hash\0\0\0\0\0\0` \x82\x01RPV[`\0aI\xD3`:\x83a5\x84V[\x91PaI\xDE\x82aIwV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaJ\x02\x81aI\xC6V[\x90P\x91\x90PV[\x7FL2OutputOracle: block hash does `\0\x82\x01R\x7Fnot match the hash at the expect` \x82\x01R\x7Fed height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aJ\x8B`I\x83a5\x84V[\x91PaJ\x96\x82aJ\tV[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaJ\xBA\x81aJ~V[\x90P\x91\x90PV[\x7FL2OutputOracle: block number mus`\0\x82\x01R\x7Ft be greater than or equal to ne` \x82\x01R\x7Fxt expected block number\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aKC`X\x83a5\x84V[\x91PaKN\x82aJ\xC1V[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaKr\x81aK6V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot propose L`\0\x82\x01R\x7F2 output from outside DisputeGam` \x82\x01R\x7FeFactory.create while disputeGam`@\x82\x01R\x7FeFactory is set\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0``\x82\x01RPV[`\0aL!`o\x83a5\x84V[\x91PaL,\x82aKyV[`\x80\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaLP\x81aL\x14V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot propose L`\0\x82\x01R\x7F2 output from inside DisputeGame` \x82\x01R\x7FFactory.create without setting d`@\x82\x01R\x7FisputeGameFactory\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0``\x82\x01RPV[`\0aL\xFF`q\x83a5\x84V[\x91PaM\n\x82aLWV[`\x80\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaM.\x81aL\xF2V[\x90P\x91\x90PV[\x7FL2OutputOracle: invalid OP Succi`\0\x82\x01R\x7Fnct configuration\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aM\x91`1\x83a5\x84V[\x91PaM\x9C\x82aM5V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaM\xC0\x81aM\x84V[\x90P\x91\x90PV[aM\xD0\x81a2\xA3V[\x82RPPV[aM\xDF\x81a28V[\x82RPPV[`\xE0\x82\x01`\0\x82\x01QaM\xFB`\0\x85\x01\x82a9\x02V[P` \x82\x01QaN\x0E` \x85\x01\x82a9\x02V[P`@\x82\x01QaN!`@\x85\x01\x82a9\x02V[P``\x82\x01QaN4``\x85\x01\x82aM\xC7V[P`\x80\x82\x01QaNG`\x80\x85\x01\x82a9\x02V[P`\xA0\x82\x01QaNZ`\xA0\x85\x01\x82a9\x02V[P`\xC0\x82\x01QaNm`\xC0\x85\x01\x82aM\xD6V[PPPPV[`\0`\xE0\x82\x01\x90PaN\x88`\0\x83\x01\x84aM\xE5V[\x92\x91PPV[`\0``\x82\x01\x90PaN\xA3`\0\x83\x01\x86a3\x10V[\x81\x81\x03` \x83\x01RaN\xB5\x81\x85aA\xFFV[\x90P\x81\x81\x03`@\x83\x01RaN\xC9\x81\x84aA\xFFV[\x90P\x94\x93PPPPV[`\0aN\xDE\x82a2\xA3V[\x91PaN\xE9\x83a2\xA3V[\x92P\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x04\x83\x11\x82\x15\x15\x16\x15aO\"WaO!a<\xF4V[[\x82\x82\x02\x90P\x92\x91PPV[\x7FInitializable: contract is alrea`\0\x82\x01R\x7Fdy initialized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aO\x89`.\x83a5\x84V[\x91PaO\x94\x82aO-V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaO\xB8\x81aO|V[\x90P\x91\x90PV[\x7FL2OutputOracle: L2 block time mu`\0\x82\x01R\x7Fst be greater than 0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aP\x1B`4\x83a5\x84V[\x91PaP&\x82aO\xBFV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaPJ\x81aP\x0EV[\x90P\x91\x90PV[\x7FL2OutputOracle: starting L2 time`\0\x82\x01R\x7Fstamp must be less than current ` \x82\x01R\x7Ftime\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aP\xD3`D\x83a5\x84V[\x91PaP\xDE\x82aPQV[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaQ\x02\x81aP\xC6V[\x90P\x91\x90PV\xFE\xA2dipfsX\"\x12 \xF1\xB1\xFC\x13\x06\xAF\x82\xA7`\xD2\xC9\xE4\x0E\x19\xB4\xCB\xA6\xFB\x04v\0\x8A+\x85=\xA27\xA3\xE6\xC0r\xADdsolcC\0\x08\x0F\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R`\x046\x10a\x02\x88W`\x005`\xE0\x1C\x80c\x88xbr\x11a\x01ZW\x80c\xCE]\xB8\xD6\x11a\0\xC1W\x80c\xE1\xA4\x1B\xCF\x11a\0zW\x80c\xE1\xA4\x1B\xCF\x14a\t\xE2W\x80c\xE4\x0Bz\x12\x14a\n\rW\x80c\xEC[.:\x14a\n6W\x80c\xF2\xB4\xE6\x17\x14a\n_W\x80c\xF2\xFD\xE3\x8B\x14a\n\x8AW\x80c\xF7/`m\x14a\n\xB3Wa\x02\x88V[\x80c\xCE]\xB8\xD6\x14a\x08\xAAW\x80c\xCF\x8E\\\xF0\x14a\x08\xD5W\x80c\xD1\xDE\x85l\x14a\t\x12W\x80c\xD4e\x12v\x14a\tOW\x80c\xDC\xEC3H\x14a\t\x8CW\x80c\xE0\xC2\xF95\x14a\t\xB7Wa\x02\x88V[\x80c\xA1\x96\xB5%\x11a\x01\x13W\x80c\xA1\x96\xB5%\x14a\x07\x88W\x80c\xA2Z\xE5W\x14a\x07\xC5W\x80c\xA4\xEE\x9D{\x14a\x08\x02W\x80c\xA8\xE4\xFB\x90\x14a\x08+W\x80c\xB0<\xD4\x18\x14a\x08VW\x80c\xC3.N>\x14a\x08\x7FWa\x02\x88V[\x80c\x88xbr\x14a\x06\x99W\x80c\x89\xC4L\xBB\x14a\x06\xC4W\x80c\x8D\xA5\xCB[\x14a\x06\xEDW\x80c\x93\x99\x1A\xF3\x14a\x07\x18W\x80c\x97\xFC\0|\x14a\x07CW\x80c\x9A\xAA\xB6H\x14a\x07lWa\x02\x88V[\x80cJ\xB3\t\xAC\x11a\x01\xFEW\x80cj\xBC\xF5c\x11a\x01\xB7W\x80cj\xBC\xF5c\x14a\x05\x80W\x80cm\x9A\x1C\x8B\x14a\x05\xABW\x80cp\x87*\xA5\x14a\x05\xD6W\x80czA\xA05\x14a\x06\x01W\x80c\x7F\0d \x14a\x061W\x80c\x7F\x01\xEAh\x14a\x06nWa\x02\x88V[\x80cJ\xB3\t\xAC\x14a\x04lW\x80cSM\xB0\xE2\x14a\x04\x95W\x80cT\xFDMP\x14a\x04\xC0W\x80c`\xCA\xF7\xA0\x14a\x04\xEBW\x80ci\xF1n\xEC\x14a\x05\x16W\x80cjVb\x0B\x14a\x05AWa\x02\x88V[\x80c3l\x9E\x81\x11a\x02PW\x80c3l\x9E\x81\x14a\x03^W\x80c4\x19\xD2\xC2\x14a\x03\x87W\x80cBw\xBC\x06\x14a\x03\xB0W\x80cE\x99\xC7\x88\x14a\x03\xDBW\x80cG\xC3~\x9C\x14a\x04\x06W\x80cI\x18^\x06\x14a\x04/Wa\x02\x88V[\x80c\t\xD62\xD3\x14a\x02\x8DW\x80c\x1E\x85h\0\x14a\x02\xB6W\x80c+1\x84\x1E\x14a\x02\xDFW\x80c+z\xC3\xF3\x14a\x03\nW\x80c,iya\x14a\x035W[`\0\x80\xFD[4\x80\x15a\x02\x99W`\0\x80\xFD[Pa\x02\xB4`\x04\x806\x03\x81\x01\x90a\x02\xAF\x91\x90a2vV[a\n\xDEV[\0[4\x80\x15a\x02\xC2W`\0\x80\xFD[Pa\x02\xDD`\x04\x806\x03\x81\x01\x90a\x02\xD8\x91\x90a2\xD9V[a\x0C\x18V[\0[4\x80\x15a\x02\xEBW`\0\x80\xFD[Pa\x02\xF4a\x0CvV[`@Qa\x03\x01\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\x16W`\0\x80\xFD[Pa\x03\x1Fa\x0C|V[`@Qa\x03,\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03AW`\0\x80\xFD[Pa\x03\\`\x04\x806\x03\x81\x01\x90a\x03W\x91\x90a2\xD9V[a\x0C\xA2V[\0[4\x80\x15a\x03jW`\0\x80\xFD[Pa\x03\x85`\x04\x806\x03\x81\x01\x90a\x03\x80\x91\x90a2\xD9V[a\r\xE2V[\0[4\x80\x15a\x03\x93W`\0\x80\xFD[Pa\x03\xAE`\x04\x806\x03\x81\x01\x90a\x03\xA9\x91\x90a2vV[a\x0E\xFAV[\0[4\x80\x15a\x03\xBCW`\0\x80\xFD[Pa\x03\xC5a\x10\x11V[`@Qa\x03\xD2\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x03\xE7W`\0\x80\xFD[Pa\x03\xF0a\x10\x17V[`@Qa\x03\xFD\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\x12W`\0\x80\xFD[Pa\x04-`\x04\x806\x03\x81\x01\x90a\x04(\x91\x90a3\xBAV[a\x10\x98V[\0[4\x80\x15a\x04;W`\0\x80\xFD[Pa\x04V`\x04\x806\x03\x81\x01\x90a\x04Q\x91\x90a5\x16V[a\x12\xD0V[`@Qa\x04c\x91\x90a5^V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04xW`\0\x80\xFD[Pa\x04\x93`\x04\x806\x03\x81\x01\x90a\x04\x8E\x91\x90a2\xD9V[a\x13\nV[\0[4\x80\x15a\x04\xA1W`\0\x80\xFD[Pa\x04\xAAa\x14IV[`@Qa\x04\xB7\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xCCW`\0\x80\xFD[Pa\x04\xD5a\x14oV[`@Qa\x04\xE2\x91\x90a6\x01V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x04\xF7W`\0\x80\xFD[Pa\x05\0a\x14\xA8V[`@Qa\x05\r\x91\x90a5^V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\"W`\0\x80\xFD[Pa\x05+a\x14\xBBV[`@Qa\x058\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05MW`\0\x80\xFD[Pa\x05h`\x04\x806\x03\x81\x01\x90a\x05c\x91\x90a6#V[a\x14\xD4V[`@Qa\x05w\x93\x92\x91\x90a6PV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\x8CW`\0\x80\xFD[Pa\x05\x95a\x14\xFEV[`@Qa\x05\xA2\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\xB7W`\0\x80\xFD[Pa\x05\xC0a\x15\x0BV[`@Qa\x05\xCD\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x05\xE2W`\0\x80\xFD[Pa\x05\xEBa\x15\x11V[`@Qa\x05\xF8\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[a\x06\x1B`\x04\x806\x03\x81\x01\x90a\x06\x16\x91\x90a7AV[a\x15\x17V[`@Qa\x06(\x91\x90a8IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06=W`\0\x80\xFD[Pa\x06X`\x04\x806\x03\x81\x01\x90a\x06S\x91\x90a2\xD9V[a\x17\x07V[`@Qa\x06e\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06zW`\0\x80\xFD[Pa\x06\x83a\x18NV[`@Qa\x06\x90\x91\x90a8\x80V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06\xA5W`\0\x80\xFD[Pa\x06\xAEa\x18SV[`@Qa\x06\xBB\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x06\xD0W`\0\x80\xFD[Pa\x06\xEB`\x04\x806\x03\x81\x01\x90a\x06\xE6\x91\x90a2\xD9V[a\x18YV[\0[4\x80\x15a\x06\xF9W`\0\x80\xFD[Pa\x07\x02a\x1AWV[`@Qa\x07\x0F\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07$W`\0\x80\xFD[Pa\x07-a\x1A}V[`@Qa\x07:\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07OW`\0\x80\xFD[Pa\x07j`\x04\x806\x03\x81\x01\x90a\x07e\x91\x90a2vV[a\x1A\x83V[\0[a\x07\x86`\x04\x806\x03\x81\x01\x90a\x07\x81\x91\x90a8\x9BV[a\x1B\xD3V[\0[4\x80\x15a\x07\x94W`\0\x80\xFD[Pa\x07\xAF`\x04\x806\x03\x81\x01\x90a\x07\xAA\x91\x90a2\xD9V[a\x1FcV[`@Qa\x07\xBC\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x07\xD1W`\0\x80\xFD[Pa\x07\xEC`\x04\x806\x03\x81\x01\x90a\x07\xE7\x91\x90a2\xD9V[a\x1F{V[`@Qa\x07\xF9\x91\x90a9~V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\x0EW`\0\x80\xFD[Pa\x08)`\x04\x806\x03\x81\x01\x90a\x08$\x91\x90a7AV[a UV[\0[4\x80\x15a\x087W`\0\x80\xFD[Pa\x08@a&\xC6V[`@Qa\x08M\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08bW`\0\x80\xFD[Pa\x08}`\x04\x806\x03\x81\x01\x90a\x08x\x91\x90a2vV[a&\xECV[\0[4\x80\x15a\x08\x8BW`\0\x80\xFD[Pa\x08\x94a(&V[`@Qa\x08\xA1\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\xB6W`\0\x80\xFD[Pa\x08\xBFa(,V[`@Qa\x08\xCC\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x08\xE1W`\0\x80\xFD[Pa\x08\xFC`\x04\x806\x03\x81\x01\x90a\x08\xF7\x91\x90a2\xD9V[a(2V[`@Qa\t\t\x91\x90a9~V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\x1EW`\0\x80\xFD[Pa\t9`\x04\x806\x03\x81\x01\x90a\t4\x91\x90a2\xD9V[a)\x14V[`@Qa\tF\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t[W`\0\x80\xFD[Pa\tv`\x04\x806\x03\x81\x01\x90a\tq\x91\x90a2vV[a)EV[`@Qa\t\x83\x91\x90a5^V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\x98W`\0\x80\xFD[Pa\t\xA1a)eV[`@Qa\t\xAE\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\xC3W`\0\x80\xFD[Pa\t\xCCa)\x81V[`@Qa\t\xD9\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\t\xEEW`\0\x80\xFD[Pa\t\xF7a*\x02V[`@Qa\n\x04\x91\x90a3sV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\n\x19W`\0\x80\xFD[Pa\n4`\x04\x806\x03\x81\x01\x90a\n/\x91\x90a:\xE7V[a*\x08V[\0[4\x80\x15a\nBW`\0\x80\xFD[Pa\n]`\x04\x806\x03\x81\x01\x90a\nX\x91\x90a6#V[a/4V[\0[4\x80\x15a\nkW`\0\x80\xFD[Pa\nta0\"V[`@Qa\n\x81\x91\x90a3IV[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\n\x96W`\0\x80\xFD[Pa\n\xB1`\x04\x806\x03\x81\x01\x90a\n\xAC\x91\x90a2vV[a0HV[\0[4\x80\x15a\n\xBFW`\0\x80\xFD[Pa\n\xC8a1\x98V[`@Qa\n\xD5\x91\x90a3\x1FV[`@Q\x80\x91\x03\x90\xF3[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x0BnW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x0Be\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[`\0`\x0E`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F]\xF3\x8D9^\xDC\x15\xB6i\xD6FV\x9B\xD0\x15Q3\x95\x07\x0B[M\xEB\x8A\x160\n\xBB\x06\r\x1BZ`\0`@Qa\x0C\r\x91\x90a5^V[`@Q\x80\x91\x03\x90\xA2PV[`\0\x81@\x90P`\0\x80\x1B\x81\x03a\x0CZW`@Q\x7F\x84\xC0hd\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80`\x0F`\0\x84\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UPPPV[`\nT\x81V[`\x0B`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\r2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\r)\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a\r\x82W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\ry\x90a<\x19V[`@Q\x80\x91\x03\x90\xFD[\x80`\x08\x81\x90UP`\x01`\x10`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\x01\x15\x15\x7F\x1F\\\x87/\x1E\xA9\x8AV[`@Q\x80\x91\x03\x90\xFD[`\0`@Q\x80``\x01`@R\x80\x84\x81R` \x01\x83\x81R` \x01\x85\x81RP\x90Pa\x12\x19\x81a\x12\xD0V[a\x12XW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x12O\x90a?\x1CV[`@Q\x80\x91\x03\x90\xFD[\x80`\x12`\0\x87\x81R` \x01\x90\x81R` \x01`\0 `\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01U`@\x82\x01Q\x81`\x02\x01U\x90PP\x84\x7F\xEA\x01#\xC7&\xA6e\xCB\n\xB5i\x14D\xF9)\xA7\x05lzw\t\xC6\x0C\x05\x87\x82\x9E\x80F\xB8\xD5\x14\x84\x84\x87`@Qa\x12\xC1\x93\x92\x91\x90a6PV[`@Q\x80\x91\x03\x90\xA2PPPPPV[`\0\x80`\0\x1B\x82`\0\x01Q\x14\x15\x80\x15a\x12\xF0WP`\0\x80\x1B\x82` \x01Q\x14\x15[\x80\x15a\x13\x03WP`\0\x80\x1B\x82`@\x01Q\x14\x15[\x90P\x91\x90PV[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x13\x9AW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x13\x91\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\x13\xE9W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x13\xE0\x90a?\xAEV[`@Q\x80\x91\x03\x90\xFD[\x80`\x08\x81\x90UP`\0`\x10`\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\0\x15\x15\x7F\x1F\\\x87/\x1E\xA9\x91\x90a3sV[`@Q\x80\x91\x03\x90\xA2PV[`\x06`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fv3.0.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0`\x01`\x03\x80T\x90Pa\x14\xCF\x91\x90a=#V[\x90P\x90V[`\x12` R\x80`\0R`@`\0 `\0\x91P\x90P\x80`\0\x01T\x90\x80`\x01\x01T\x90\x80`\x02\x01T\x90P\x83V[`\0`\x03\x80T\x90P\x90P\x90V[`\x0CT\x81V[`\x01T\x81V[`\0`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a\x15iW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x15`\x90a<\x19V[`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x13`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x03a\x15\xFAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x15\xF1\x90a@@V[`@Q\x80\x91\x03\x90\xFD[`\x01`\x13`\x14a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\x13`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x82\xEC\xF2\xF64`\x06\x89\x89\x89\x88\x8E\x8B`@Q` \x01a\x16p\x95\x94\x93\x92\x91\x90aA1V[`@Q` \x81\x83\x03\x03\x81R\x90`@R`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x16\x9D\x93\x92\x91\x90aB8V[` `@Q\x80\x83\x03\x81\x85\x88Z\xF1\x15\x80\x15a\x16\xBBW=`\0\x80>=`\0\xFD[PPPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16\xE0\x91\x90aB\xB4V[\x90P`\0`\x13`\x14a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x96\x95PPPPPPV[`\0a\x17\x11a\x10\x17V[\x82\x11\x15a\x17SW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x17J\x90aCyV[`@Q\x80\x91\x03\x90\xFD[`\0`\x03\x80T\x90P\x11a\x17\x9BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x17\x92\x90aD1V[`@Q\x80\x91\x03\x90\xFD[`\0\x80`\x03\x80T\x90P\x90P[\x80\x82\x10\x15a\x18DW`\0`\x02\x82\x84a\x17\xBF\x91\x90aDQV[a\x17\xC9\x91\x90aD\xD6V[\x90P\x84`\x03\x82\x81T\x81\x10a\x17\xE0Wa\x17\xDFa=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`\x01\x01`\x10\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10\x15a\x18:W`\x01\x81a\x183\x91\x90aDQV[\x92Pa\x18>V[\x80\x91P[Pa\x17\xA7V[\x81\x92PPP\x91\x90PV[`\x03\x81V[`\x02T\x81V[`\x06`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x18\xE9W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x18\xE0\x90aEyV[`@Q\x80\x91\x03\x90\xFD[`\0\x81\x11a\x19,W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x19#\x90aF\x0BV[`@Q\x80\x91\x03\x90\xFD[`\x03\x80T\x90P\x81\x10a\x19sW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x19j\x90aF\xC3V[`@Q\x80\x91\x03\x90\xFD[`\x08T`\x03\x82\x81T\x81\x10a\x19\x8AWa\x19\x89a=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`\x01\x01`\0\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16Ba\x19\xD5\x91\x90a=#V[\x10a\x1A\x15W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1A\x0C\x90aG{V[`@Q\x80\x91\x03\x90\xFD[`\0a\x1A\x1Fa\x14\xFEV[\x90P\x81`\x03U\x81\x81\x7FN\xE3z\xC2\xC7\x86\xEC\x85\xE8u\x92\xD3\xC5\xC8\xA1\xDDf\xF8Im\xDA?\x12]\x9E\xA8\xCA_ev)\xB6`@Q`@Q\x80\x91\x03\x90\xA3PPV[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\x05T\x81V[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x1B\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1B\n\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x0B`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x02CT\x9A\x92\xB2A/z<\xAFz.V\xD6[\x88!\xB9\x13E6?\xAA_W\x19S\x84\x06_\xCC`@Q`@Q\x80\x91\x03\x90\xA3\x80`\x0B`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPV[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\x1C\"W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1C\x19\x90a?\xAEV[`@Q\x80\x91\x03\x90\xFD[`\x0E`\x003s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x80a\x1C\xC3WP`\x0E`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16[a\x1D\x02W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1C\xF9\x90aH\rV[`@Q\x80\x91\x03\x90\xFD[a\x1D\na)eV[\x83\x14a\x1DKW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1DB\x90aH\xC5V[`@Q\x80\x91\x03\x90\xFD[Ba\x1DU\x84a)\x14V[\x10a\x1D\x95W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1D\x8C\x90aIWV[`@Q\x80\x91\x03\x90\xFD[`\0\x80\x1B\x84\x03a\x1D\xDAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1D\xD1\x90aI\xE9V[`@Q\x80\x91\x03\x90\xFD[`\0\x80\x1B\x82\x14a\x1E(W\x81\x81@\x14a\x1E'W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x1E\x1E\x90aJ\xA1V[`@Q\x80\x91\x03\x90\xFD[[\x82a\x1E1a\x14\xFEV[\x85\x7F\xA7\xAA\xF2Q'i\xDANDN=\xE2G\xBE%d\"\\.z\x8Ft\xCF\xE5(\xE4n\x17\xD2Hh\xE2B`@Qa\x1Ea\x91\x90a3sV[`@Q\x80\x91\x03\x90\xA4`\x03`@Q\x80``\x01`@R\x80\x86\x81R` \x01Bo\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x85o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90\x80`\x01\x81T\x01\x80\x82U\x80\x91PP`\x01\x90\x03\x90`\0R` `\0 \x90`\x02\x02\x01`\0\x90\x91\x90\x91\x90\x91P`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01`\0a\x01\0\n\x81T\x81o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`@\x82\x01Q\x81`\x01\x01`\x10a\x01\0\n\x81T\x81o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPPPPPPV[`\x0F` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[a\x1F\x83a1\xBCV[`\x03\x82\x81T\x81\x10a\x1F\x97Wa\x1F\x96a=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`@Q\x80``\x01`@R\x90\x81`\0\x82\x01T\x81R` \x01`\x01\x82\x01`\0\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01`\x01\x82\x01`\x10\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x90P\x91\x90PV[`\x10`\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a \xA5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a \x9C\x90a<\x19V[`@Q\x80\x91\x03\x90\xFD[`\x0E`\x002s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x80a!FWP`\x0E`\0\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0\x90T\x90a\x01\0\n\x90\x04`\xFF\x16[\x80a!dWP`\x11Ta!Wa)\x81V[Ba!b\x91\x90a=#V[\x11[a!\xA3W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a!\x9A\x90aH\rV[`@Q\x80\x91\x03\x90\xFD[a!\xABa)eV[\x84\x10\x15a!\xEDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a!\xE4\x90aKYV[`@Q\x80\x91\x03\x90\xFD[Ba!\xF7\x85a)\x14V[\x10a\"7W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\".\x90aIWV[`@Q\x80\x91\x03\x90\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x13`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\"\xE1W`\x13`\x14\x90T\x90a\x01\0\n\x90\x04`\xFF\x16a\"\xDCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\"\xD3\x90aL7V[`@Q\x80\x91\x03\x90\xFD[a#2V[`\x13`\x14\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15a#1W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a#(\x90aM\x15V[`@Q\x80\x91\x03\x90\xFD[[`\0\x80\x1B\x85\x03a#wW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a#n\x90aI\xE9V[`@Q\x80\x91\x03\x90\xFD[`\0`\x12`\0\x88\x81R` \x01\x90\x81R` \x01`\0 `@Q\x80``\x01`@R\x90\x81`\0\x82\x01T\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01T\x81RPP\x90Pa#\xC0\x81a\x12\xD0V[a#\xFFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a#\xF6\x90aM\xA7V[`@Q\x80\x91\x03\x90\xFD[`\0`\x0F`\0\x86\x81R` \x01\x90\x81R` \x01`\0 T\x90P`\0\x80\x1B\x81\x03a$SW`@Q\x7F\"\xAA:\x98\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0`@Q\x80`\xE0\x01`@R\x80\x83\x81R` \x01`\x03a$pa\x14\xBBV[\x81T\x81\x10a$\x81Wa$\x80a=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`\0\x01T\x81R` \x01\x89\x81R` \x01\x88\x81R` \x01\x84`@\x01Q\x81R` \x01\x84` \x01Q\x81R` \x01\x85s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90P`\x0B`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cAI<`\x84`\0\x01Q\x83`@Q` \x01a%(\x91\x90aNsV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x88`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a%V\x93\x92\x91\x90aN\x8EV[`\0`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a%nW`\0\x80\xFD[PZ\xFA\x15\x80\x15a%\x82W=`\0\x80>=`\0\xFD[PPPP\x86a%\x8Fa\x14\xFEV[\x89\x7F\xA7\xAA\xF2Q'i\xDANDN=\xE2G\xBE%d\"\\.z\x8Ft\xCF\xE5(\xE4n\x17\xD2Hh\xE2B`@Qa%\xBF\x91\x90a3sV[`@Q\x80\x91\x03\x90\xA4`\x03`@Q\x80``\x01`@R\x80\x8A\x81R` \x01Bo\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x89o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90\x80`\x01\x81T\x01\x80\x82U\x80\x91PP`\x01\x90\x03\x90`\0R` `\0 \x90`\x02\x02\x01`\0\x90\x91\x90\x91\x90\x91P`\0\x82\x01Q\x81`\0\x01U` \x82\x01Q\x81`\x01\x01`\0a\x01\0\n\x81T\x81o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`@\x82\x01Q\x81`\x01\x01`\x10a\x01\0\n\x81T\x81o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPPPPPPPPPPPV[`\x07`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a'|W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a's\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[`\x01`\x0E`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 `\0a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F]\xF3\x8D9^\xDC\x15\xB6i\xD6FV\x9B\xD0\x15Q3\x95\x07\x0B[M\xEB\x8A\x160\n\xBB\x06\r\x1BZ`\x01`@Qa(\x1B\x91\x90a5^V[`@Q\x80\x91\x03\x90\xA2PV[`\tT\x81V[`\x08T\x81V[a(:a1\xBCV[`\x03a(E\x83a\x17\x07V[\x81T\x81\x10a(VWa(Ua=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`@Q\x80``\x01`@R\x90\x81`\0\x82\x01T\x81R` \x01`\x01\x82\x01`\0\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01`\x01\x82\x01`\x10\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RPP\x90P\x91\x90PV[`\0`\x05T`\x01T\x83a)'\x91\x90a=#V[a)1\x91\x90aN\xD3V[`\x02Ta)>\x91\x90aDQV[\x90P\x91\x90PV[`\x0E` R\x80`\0R`@`\0 `\0\x91PT\x90a\x01\0\n\x90\x04`\xFF\x16\x81V[`\0`\x04Ta)ra\x10\x17V[a)|\x91\x90aDQV[\x90P\x90V[`\0\x80`\x03\x80T\x90P\x14a)\xF9W`\x03`\x01`\x03\x80T\x90Pa)\xA3\x91\x90a=#V[\x81T\x81\x10a)\xB4Wa)\xB3a=WV[[\x90`\0R` `\0 \x90`\x02\x02\x01`\x01\x01`\0\x90T\x90a\x01\0\n\x90\x04o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a)\xFDV[`\x02T[\x90P\x90V[`\x04T\x81V[`\x03`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15\x80\x15a*9WP\x80`\xFF\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10[a*xW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a*o\x90aO\x9FV[`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP`\x01`\0`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP`\0\x82a\x01`\x01Q\x11a*\xF5W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a*\xEC\x90a<\xABV[`@Q\x80\x91\x03\x90\xFD[`\0\x82`\x80\x01Q\x11a+\x15\\f\x90\xE4\xB7\xF3\x9A\xFAA\xA2\xA8\xFF\x8C\n\xA4%\xDA`@Q`@Q\x80\x91\x03\x90\xA2PV[`\x13`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a0\xD8W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a0\xCF\x90a;\x87V[`@Q\x80\x91\x03\x90\xFD[\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\r`\0\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0`@Q`@Q\x80\x91\x03\x90\xA3\x80`\r`\0a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UPPV[\x7F\xAE\x83\x04\xF4\x0Fq#\xE0\xC8{\x97\xF8\xA6\0\xE9O\xF3\xA3\xA2[\xE5\x88\xFCf\xB8\xA3q|\x89Y\xCEw\x81V[`@Q\x80``\x01`@R\x80`\0\x80\x19\x16\x81R` \x01`\0o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01`\0o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81RP\x90V[`\0`@Q\x90P\x90V[`\0\x80\xFD[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a2C\x82a2\x18V[\x90P\x91\x90PV[a2S\x81a28V[\x81\x14a2^W`\0\x80\xFD[PV[`\0\x815\x90Pa2p\x81a2JV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a2\x8CWa2\x8Ba2\x0EV[[`\0a2\x9A\x84\x82\x85\x01a2aV[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a2\xB6\x81a2\xA3V[\x81\x14a2\xC1W`\0\x80\xFD[PV[`\0\x815\x90Pa2\xD3\x81a2\xADV[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a2\xEFWa2\xEEa2\x0EV[[`\0a2\xFD\x84\x82\x85\x01a2\xC4V[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a3\x19\x81a3\x06V[\x82RPPV[`\0` \x82\x01\x90Pa34`\0\x83\x01\x84a3\x10V[\x92\x91PPV[a3C\x81a28V[\x82RPPV[`\0` \x82\x01\x90Pa3^`\0\x83\x01\x84a3:V[\x92\x91PPV[a3m\x81a2\xA3V[\x82RPPV[`\0` \x82\x01\x90Pa3\x88`\0\x83\x01\x84a3dV[\x92\x91PPV[a3\x97\x81a3\x06V[\x81\x14a3\xA2W`\0\x80\xFD[PV[`\0\x815\x90Pa3\xB4\x81a3\x8EV[\x92\x91PPV[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15a3\xD4Wa3\xD3a2\x0EV[[`\0a3\xE2\x87\x82\x88\x01a3\xA5V[\x94PP` a3\xF3\x87\x82\x88\x01a3\xA5V[\x93PP`@a4\x04\x87\x82\x88\x01a3\xA5V[\x92PP``a4\x15\x87\x82\x88\x01a3\xA5V[\x91PP\x92\x95\x91\x94P\x92PV[`\0\x80\xFD[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`A`\x04R`$`\0\xFD[a4o\x82a4&V[\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a4\x8EWa4\x8Da47V[[\x80`@RPPPV[`\0a4\xA1a2\x04V[\x90Pa4\xAD\x82\x82a4fV[\x91\x90PV[`\0``\x82\x84\x03\x12\x15a4\xC8Wa4\xC7a4!V[[a4\xD2``a4\x97V[\x90P`\0a4\xE2\x84\x82\x85\x01a3\xA5V[`\0\x83\x01RP` a4\xF6\x84\x82\x85\x01a3\xA5V[` \x83\x01RP`@a5\n\x84\x82\x85\x01a3\xA5V[`@\x83\x01RP\x92\x91PPV[`\0``\x82\x84\x03\x12\x15a5,Wa5+a2\x0EV[[`\0a5:\x84\x82\x85\x01a4\xB2V[\x91PP\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a5X\x81a5CV[\x82RPPV[`\0` \x82\x01\x90Pa5s`\0\x83\x01\x84a5OV[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a5\xB3W\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa5\x98V[\x83\x81\x11\x15a5\xC2W`\0\x84\x84\x01R[PPPPV[`\0a5\xD3\x82a5yV[a5\xDD\x81\x85a5\x84V[\x93Pa5\xED\x81\x85` \x86\x01a5\x95V[a5\xF6\x81a4&V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra6\x1B\x81\x84a5\xC8V[\x90P\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a69Wa68a2\x0EV[[`\0a6G\x84\x82\x85\x01a3\xA5V[\x91PP\x92\x91PPV[`\0``\x82\x01\x90Pa6e`\0\x83\x01\x86a3\x10V[a6r` \x83\x01\x85a3\x10V[a6\x7F`@\x83\x01\x84a3\x10V[\x94\x93PPPPV[`\0\x80\xFD[`\0\x80\xFD[`\0g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a6\xACWa6\xABa47V[[a6\xB5\x82a4&V[\x90P` \x81\x01\x90P\x91\x90PV[\x82\x81\x837`\0\x83\x83\x01RPPPV[`\0a6\xE4a6\xDF\x84a6\x91V[a4\x97V[\x90P\x82\x81R` \x81\x01\x84\x84\x84\x01\x11\x15a7\0Wa6\xFFa6\x8CV[[a7\x0B\x84\x82\x85a6\xC2V[P\x93\x92PPPV[`\0\x82`\x1F\x83\x01\x12a7(Wa7'a6\x87V[[\x815a78\x84\x82` \x86\x01a6\xD1V[\x91PP\x92\x91PPV[`\0\x80`\0\x80`\0\x80`\xC0\x87\x89\x03\x12\x15a7^Wa7]a2\x0EV[[`\0a7l\x89\x82\x8A\x01a3\xA5V[\x96PP` a7}\x89\x82\x8A\x01a3\xA5V[\x95PP`@a7\x8E\x89\x82\x8A\x01a2\xC4V[\x94PP``a7\x9F\x89\x82\x8A\x01a2\xC4V[\x93PP`\x80\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xC0Wa7\xBFa2\x13V[[a7\xCC\x89\x82\x8A\x01a7\x13V[\x92PP`\xA0a7\xDD\x89\x82\x8A\x01a2aV[\x91PP\x92\x95P\x92\x95P\x92\x95V[`\0\x81\x90P\x91\x90PV[`\0a8\x0Fa8\na8\x05\x84a2\x18V[a7\xEAV[a2\x18V[\x90P\x91\x90PV[`\0a8!\x82a7\xF4V[\x90P\x91\x90PV[`\0a83\x82a8\x16V[\x90P\x91\x90PV[a8C\x81a8(V[\x82RPPV[`\0` \x82\x01\x90Pa8^`\0\x83\x01\x84a8:V[\x92\x91PPV[`\0`\xFF\x82\x16\x90P\x91\x90PV[a8z\x81a8dV[\x82RPPV[`\0` \x82\x01\x90Pa8\x95`\0\x83\x01\x84a8qV[\x92\x91PPV[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15a8\xB5Wa8\xB4a2\x0EV[[`\0a8\xC3\x87\x82\x88\x01a3\xA5V[\x94PP` a8\xD4\x87\x82\x88\x01a2\xC4V[\x93PP`@a8\xE5\x87\x82\x88\x01a3\xA5V[\x92PP``a8\xF6\x87\x82\x88\x01a2\xC4V[\x91PP\x92\x95\x91\x94P\x92PV[a9\x0B\x81a3\x06V[\x82RPPV[`\0o\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[a96\x81a9\x11V[\x82RPPV[``\x82\x01`\0\x82\x01Qa9R`\0\x85\x01\x82a9\x02V[P` \x82\x01Qa9e` \x85\x01\x82a9-V[P`@\x82\x01Qa9x`@\x85\x01\x82a9-V[PPPPV[`\0``\x82\x01\x90Pa9\x93`\0\x83\x01\x84a9\x11\x81a=\xD5V[\x90P\x91\x90PV[\x7FL2OutputOracle: config already e`\0\x82\x01R\x7Fxists\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a>t`%\x83a5\x84V[\x91Pa>\x7F\x82a>\x18V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra>\xA3\x81a>gV[\x90P\x91\x90PV[\x7FL2OutputOracle: invalid OP Succi`\0\x82\x01R\x7Fnct configuration parameters\0\0\0\0` \x82\x01RPV[`\0a?\x06`<\x83a5\x84V[\x91Pa?\x11\x82a>\xAAV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra?5\x81a>\xF9V[\x90P\x91\x90PV[\x7FL2OutputOracle: optimistic mode `\0\x82\x01R\x7Fis not enabled\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a?\x98`.\x83a5\x84V[\x91Pa?\xA3\x82a?\x83a5\x84V[\x91PaEn\x82aE\x07V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaE\x92\x81aEVV[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot delete ge`\0\x82\x01R\x7Fnesis output\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aE\xF5`,\x83a5\x84V[\x91PaF\0\x82aE\x99V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaF$\x81aE\xE8V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot delete ou`\0\x82\x01R\x7Ftputs after the latest output in` \x82\x01R\x7Fdex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aF\xAD`C\x83a5\x84V[\x91PaF\xB8\x82aF+V[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaF\xDC\x81aF\xA0V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot delete ou`\0\x82\x01R\x7Ftputs that have already been fin` \x82\x01R\x7Falized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aGe`F\x83a5\x84V[\x91PaGp\x82aF\xE3V[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaG\x94\x81aGXV[\x90P\x91\x90PV[\x7FL2OutputOracle: only approved pr`\0\x82\x01R\x7Foposers can propose new outputs\0` \x82\x01RPV[`\0aG\xF7`?\x83a5\x84V[\x91PaH\x02\x82aG\x9BV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaH&\x81aG\xEAV[\x90P\x91\x90PV[\x7FL2OutputOracle: block number mus`\0\x82\x01R\x7Ft be equal to next expected bloc` \x82\x01R\x7Fk number\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aH\xAF`H\x83a5\x84V[\x91PaH\xBA\x82aH-V[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaH\xDE\x81aH\xA2V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot propose L`\0\x82\x01R\x7F2 output in the future\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aIA`6\x83a5\x84V[\x91PaIL\x82aH\xE5V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaIp\x81aI4V[\x90P\x91\x90PV[\x7FL2OutputOracle: L2 output propos`\0\x82\x01R\x7Fal cannot be the zero hash\0\0\0\0\0\0` \x82\x01RPV[`\0aI\xD3`:\x83a5\x84V[\x91PaI\xDE\x82aIwV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaJ\x02\x81aI\xC6V[\x90P\x91\x90PV[\x7FL2OutputOracle: block hash does `\0\x82\x01R\x7Fnot match the hash at the expect` \x82\x01R\x7Fed height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aJ\x8B`I\x83a5\x84V[\x91PaJ\x96\x82aJ\tV[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaJ\xBA\x81aJ~V[\x90P\x91\x90PV[\x7FL2OutputOracle: block number mus`\0\x82\x01R\x7Ft be greater than or equal to ne` \x82\x01R\x7Fxt expected block number\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aKC`X\x83a5\x84V[\x91PaKN\x82aJ\xC1V[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaKr\x81aK6V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot propose L`\0\x82\x01R\x7F2 output from outside DisputeGam` \x82\x01R\x7FeFactory.create while disputeGam`@\x82\x01R\x7FeFactory is set\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0``\x82\x01RPV[`\0aL!`o\x83a5\x84V[\x91PaL,\x82aKyV[`\x80\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaLP\x81aL\x14V[\x90P\x91\x90PV[\x7FL2OutputOracle: cannot propose L`\0\x82\x01R\x7F2 output from inside DisputeGame` \x82\x01R\x7FFactory.create without setting d`@\x82\x01R\x7FisputeGameFactory\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0``\x82\x01RPV[`\0aL\xFF`q\x83a5\x84V[\x91PaM\n\x82aLWV[`\x80\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaM.\x81aL\xF2V[\x90P\x91\x90PV[\x7FL2OutputOracle: invalid OP Succi`\0\x82\x01R\x7Fnct configuration\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aM\x91`1\x83a5\x84V[\x91PaM\x9C\x82aM5V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaM\xC0\x81aM\x84V[\x90P\x91\x90PV[aM\xD0\x81a2\xA3V[\x82RPPV[aM\xDF\x81a28V[\x82RPPV[`\xE0\x82\x01`\0\x82\x01QaM\xFB`\0\x85\x01\x82a9\x02V[P` \x82\x01QaN\x0E` \x85\x01\x82a9\x02V[P`@\x82\x01QaN!`@\x85\x01\x82a9\x02V[P``\x82\x01QaN4``\x85\x01\x82aM\xC7V[P`\x80\x82\x01QaNG`\x80\x85\x01\x82a9\x02V[P`\xA0\x82\x01QaNZ`\xA0\x85\x01\x82a9\x02V[P`\xC0\x82\x01QaNm`\xC0\x85\x01\x82aM\xD6V[PPPPV[`\0`\xE0\x82\x01\x90PaN\x88`\0\x83\x01\x84aM\xE5V[\x92\x91PPV[`\0``\x82\x01\x90PaN\xA3`\0\x83\x01\x86a3\x10V[\x81\x81\x03` \x83\x01RaN\xB5\x81\x85aA\xFFV[\x90P\x81\x81\x03`@\x83\x01RaN\xC9\x81\x84aA\xFFV[\x90P\x94\x93PPPPV[`\0aN\xDE\x82a2\xA3V[\x91PaN\xE9\x83a2\xA3V[\x92P\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x04\x83\x11\x82\x15\x15\x16\x15aO\"WaO!a<\xF4V[[\x82\x82\x02\x90P\x92\x91PPV[\x7FInitializable: contract is alrea`\0\x82\x01R\x7Fdy initialized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aO\x89`.\x83a5\x84V[\x91PaO\x94\x82aO-V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaO\xB8\x81aO|V[\x90P\x91\x90PV[\x7FL2OutputOracle: L2 block time mu`\0\x82\x01R\x7Fst be greater than 0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0aP\x1B`4\x83a5\x84V[\x91PaP&\x82aO\xBFV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaPJ\x81aP\x0EV[\x90P\x91\x90PV[\x7FL2OutputOracle: starting L2 time`\0\x82\x01R\x7Fstamp must be less than current ` \x82\x01R\x7Ftime\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`@\x82\x01RPV[`\0aP\xD3`D\x83a5\x84V[\x91PaP\xDE\x82aPQV[``\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01RaQ\x02\x81aP\xC6V[\x90P\x91\x90PV\xFE\xA2dipfsX\"\x12 \xF1\xB1\xFC\x13\x06\xAF\x82\xA7`\xD2\xC9\xE4\x0E\x19\xB4\xCB\xA6\xFB\x04v\0\x8A+\x85=\xA27\xA3\xE6\xC0r\xADdsolcC\0\x08\x0F\x003", + ); + /**```solidity +struct InitParams { address challenger; address proposer; address owner; uint256 finalizationPeriodSeconds; uint256 l2BlockTime; bytes32 aggregationVkey; bytes32 rangeVkeyCommitment; bytes32 rollupConfigHash; bytes32 startingOutputRoot; uint256 startingBlockNumber; uint256 startingTimestamp; uint256 submissionInterval; address verifier; uint256 fallbackTimeout; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct InitParams { + #[allow(missing_docs)] + pub challenger: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub proposer: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub owner: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub finalizationPeriodSeconds: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub l2BlockTime: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub startingOutputRoot: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub startingBlockNumber: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub startingTimestamp: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub submissionInterval: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub verifier: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub fallbackTimeout: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: InitParams) -> Self { + ( + value.challenger, + value.proposer, + value.owner, + value.finalizationPeriodSeconds, + value.l2BlockTime, + value.aggregationVkey, + value.rangeVkeyCommitment, + value.rollupConfigHash, + value.startingOutputRoot, + value.startingBlockNumber, + value.startingTimestamp, + value.submissionInterval, + value.verifier, + value.fallbackTimeout, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for InitParams { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + challenger: tuple.0, + proposer: tuple.1, + owner: tuple.2, + finalizationPeriodSeconds: tuple.3, + l2BlockTime: tuple.4, + aggregationVkey: tuple.5, + rangeVkeyCommitment: tuple.6, + rollupConfigHash: tuple.7, + startingOutputRoot: tuple.8, + startingBlockNumber: tuple.9, + startingTimestamp: tuple.10, + submissionInterval: tuple.11, + verifier: tuple.12, + fallbackTimeout: tuple.13, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for InitParams { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for InitParams { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.challenger, + ), + ::tokenize( + &self.proposer, + ), + ::tokenize( + &self.owner, + ), + as alloy_sol_types::SolType>::tokenize( + &self.finalizationPeriodSeconds, + ), + as alloy_sol_types::SolType>::tokenize(&self.l2BlockTime), + as alloy_sol_types::SolType>::tokenize(&self.aggregationVkey), + as alloy_sol_types::SolType>::tokenize(&self.rangeVkeyCommitment), + as alloy_sol_types::SolType>::tokenize(&self.rollupConfigHash), + as alloy_sol_types::SolType>::tokenize(&self.startingOutputRoot), + as alloy_sol_types::SolType>::tokenize(&self.startingBlockNumber), + as alloy_sol_types::SolType>::tokenize(&self.startingTimestamp), + as alloy_sol_types::SolType>::tokenize(&self.submissionInterval), + ::tokenize( + &self.verifier, + ), + as alloy_sol_types::SolType>::tokenize(&self.fallbackTimeout), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for InitParams { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for InitParams { + const NAME: &'static str = "InitParams"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "InitParams(address challenger,address proposer,address owner,uint256 finalizationPeriodSeconds,uint256 l2BlockTime,bytes32 aggregationVkey,bytes32 rangeVkeyCommitment,bytes32 rollupConfigHash,bytes32 startingOutputRoot,uint256 startingBlockNumber,uint256 startingTimestamp,uint256 submissionInterval,address verifier,uint256 fallbackTimeout)", + ) + } + #[inline] + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { + alloy_sol_types::private::Vec::new() + } + #[inline] + fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.challenger, + ) + .0, + ::eip712_data_word( + &self.proposer, + ) + .0, + ::eip712_data_word( + &self.owner, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.finalizationPeriodSeconds, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.l2BlockTime) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.aggregationVkey, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.rangeVkeyCommitment, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.rollupConfigHash, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.startingOutputRoot, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.startingBlockNumber, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.startingTimestamp, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.submissionInterval, + ) + .0, + ::eip712_data_word( + &self.verifier, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.fallbackTimeout, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for InitParams { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.challenger, + ) + + ::topic_preimage_length( + &rust.proposer, + ) + + ::topic_preimage_length( + &rust.owner, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.finalizationPeriodSeconds, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.l2BlockTime, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.aggregationVkey, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.rangeVkeyCommitment, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.rollupConfigHash, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.startingOutputRoot, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.startingBlockNumber, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.startingTimestamp, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.submissionInterval, + ) + + ::topic_preimage_length( + &rust.verifier, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.fallbackTimeout, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.challenger, + out, + ); + ::encode_topic_preimage( + &rust.proposer, + out, + ); + ::encode_topic_preimage( + &rust.owner, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.finalizationPeriodSeconds, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.l2BlockTime, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.aggregationVkey, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.rangeVkeyCommitment, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.rollupConfigHash, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.startingOutputRoot, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.startingBlockNumber, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.startingTimestamp, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.submissionInterval, + out, + ); + ::encode_topic_preimage( + &rust.verifier, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.fallbackTimeout, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + /**```solidity +struct OpSuccinctConfig { bytes32 aggregationVkey; bytes32 rangeVkeyCommitment; bytes32 rollupConfigHash; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct OpSuccinctConfig { + #[allow(missing_docs)] + pub aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: OpSuccinctConfig) -> Self { + ( + value.aggregationVkey, + value.rangeVkeyCommitment, + value.rollupConfigHash, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for OpSuccinctConfig { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + aggregationVkey: tuple.0, + rangeVkeyCommitment: tuple.1, + rollupConfigHash: tuple.2, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for OpSuccinctConfig { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for OpSuccinctConfig { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.aggregationVkey), + as alloy_sol_types::SolType>::tokenize(&self.rangeVkeyCommitment), + as alloy_sol_types::SolType>::tokenize(&self.rollupConfigHash), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for OpSuccinctConfig { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for OpSuccinctConfig { + const NAME: &'static str = "OpSuccinctConfig"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "OpSuccinctConfig(bytes32 aggregationVkey,bytes32 rangeVkeyCommitment,bytes32 rollupConfigHash)", + ) + } + #[inline] + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { + alloy_sol_types::private::Vec::new() + } + #[inline] + fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word( + &self.aggregationVkey, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.rangeVkeyCommitment, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.rollupConfigHash, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for OpSuccinctConfig { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.aggregationVkey, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.rangeVkeyCommitment, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.rollupConfigHash, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.aggregationVkey, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.rangeVkeyCommitment, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.rollupConfigHash, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + /**Custom error with signature `L1BlockHashNotAvailable()` and selector `0x84c06864`. +```solidity +error L1BlockHashNotAvailable(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct L1BlockHashNotAvailable; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: L1BlockHashNotAvailable) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for L1BlockHashNotAvailable { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for L1BlockHashNotAvailable { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "L1BlockHashNotAvailable()"; + const SELECTOR: [u8; 4] = [132u8, 192u8, 104u8, 100u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `L1BlockHashNotCheckpointed()` and selector `0x22aa3a98`. +```solidity +error L1BlockHashNotCheckpointed(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct L1BlockHashNotCheckpointed; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: L1BlockHashNotCheckpointed) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for L1BlockHashNotCheckpointed { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for L1BlockHashNotCheckpointed { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "L1BlockHashNotCheckpointed()"; + const SELECTOR: [u8; 4] = [34u8, 170u8, 58u8, 152u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Event with signature `DisputeGameFactorySet(address)` and selector `0x73702180ce348e07b058846d1745c99987ae6c741ff97ec28d4539530ef1e8f1`. +```solidity +event DisputeGameFactorySet(address indexed disputeGameFactory); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct DisputeGameFactorySet { + #[allow(missing_docs)] + pub disputeGameFactory: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for DisputeGameFactorySet { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "DisputeGameFactorySet(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 115u8, 112u8, 33u8, 128u8, 206u8, 52u8, 142u8, 7u8, 176u8, 88u8, 132u8, + 109u8, 23u8, 69u8, 201u8, 153u8, 135u8, 174u8, 108u8, 116u8, 31u8, 249u8, + 126u8, 194u8, 141u8, 69u8, 57u8, 83u8, 14u8, 241u8, 232u8, 241u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + disputeGameFactory: topics.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.disputeGameFactory.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.disputeGameFactory, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for DisputeGameFactorySet { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&DisputeGameFactorySet> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &DisputeGameFactorySet) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`. +```solidity +event Initialized(uint8 version); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Initialized { + #[allow(missing_docs)] + pub version: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Initialized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Initialized(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { version: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Initialized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Initialized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Initialized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `OpSuccinctConfigDeleted(bytes32)` and selector `0x4432b02a2fcbed48d94e8d72723e155c6690e4b7f39afa41a2a8ff8c0aa425da`. +```solidity +event OpSuccinctConfigDeleted(bytes32 indexed configName); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct OpSuccinctConfigDeleted { + #[allow(missing_docs)] + pub configName: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OpSuccinctConfigDeleted { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + const SIGNATURE: &'static str = "OpSuccinctConfigDeleted(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 68u8, 50u8, 176u8, 42u8, 47u8, 203u8, 237u8, 72u8, 217u8, 78u8, 141u8, + 114u8, 114u8, 62u8, 21u8, 92u8, 102u8, 144u8, 228u8, 183u8, 243u8, 154u8, + 250u8, 65u8, 162u8, 168u8, 255u8, 140u8, 10u8, 164u8, 37u8, 218u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { configName: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.configName.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.configName); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OpSuccinctConfigDeleted { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&OpSuccinctConfigDeleted> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &OpSuccinctConfigDeleted, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `OpSuccinctConfigUpdated(bytes32,bytes32,bytes32,bytes32)` and selector `0xea0123c726a665cb0ab5691444f929a7056c7a7709c60c0587829e8046b8d514`. +```solidity +event OpSuccinctConfigUpdated(bytes32 indexed configName, bytes32 aggregationVkey, bytes32 rangeVkeyCommitment, bytes32 rollupConfigHash); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct OpSuccinctConfigUpdated { + #[allow(missing_docs)] + pub configName: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OpSuccinctConfigUpdated { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + const SIGNATURE: &'static str = "OpSuccinctConfigUpdated(bytes32,bytes32,bytes32,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 234u8, 1u8, 35u8, 199u8, 38u8, 166u8, 101u8, 203u8, 10u8, 181u8, 105u8, + 20u8, 68u8, 249u8, 41u8, 167u8, 5u8, 108u8, 122u8, 119u8, 9u8, 198u8, + 12u8, 5u8, 135u8, 130u8, 158u8, 128u8, 70u8, 184u8, 213u8, 20u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + configName: topics.1, + aggregationVkey: data.0, + rangeVkeyCommitment: data.1, + rollupConfigHash: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.aggregationVkey), + as alloy_sol_types::SolType>::tokenize(&self.rangeVkeyCommitment), + as alloy_sol_types::SolType>::tokenize(&self.rollupConfigHash), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.configName.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.configName); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OpSuccinctConfigUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&OpSuccinctConfigUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &OpSuccinctConfigUpdated, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `OptimisticModeToggled(bool,uint256)` and selector `0x1f5c872f1ea93c57e43112ea449ee19ef5754488b87627b4c52456b0e5a4109a`. +```solidity +event OptimisticModeToggled(bool indexed enabled, uint256 finalizationPeriodSeconds); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct OptimisticModeToggled { + #[allow(missing_docs)] + pub enabled: bool, + #[allow(missing_docs)] + pub finalizationPeriodSeconds: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OptimisticModeToggled { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Bool, + ); + const SIGNATURE: &'static str = "OptimisticModeToggled(bool,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 31u8, 92u8, 135u8, 47u8, 30u8, 169u8, 60u8, 87u8, 228u8, 49u8, 18u8, + 234u8, 68u8, 158u8, 225u8, 158u8, 245u8, 117u8, 68u8, 136u8, 184u8, + 118u8, 39u8, 180u8, 197u8, 36u8, 86u8, 176u8, 229u8, 164u8, 16u8, 154u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + enabled: topics.1, + finalizationPeriodSeconds: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize( + &self.finalizationPeriodSeconds, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.enabled.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.enabled, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OptimisticModeToggled { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&OptimisticModeToggled> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &OptimisticModeToggled) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `OutputProposed(bytes32,uint256,uint256,uint256)` and selector `0xa7aaf2512769da4e444e3de247be2564225c2e7a8f74cfe528e46e17d24868e2`. +```solidity +event OutputProposed(bytes32 indexed outputRoot, uint256 indexed l2OutputIndex, uint256 indexed l2BlockNumber, uint256 l1Timestamp); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct OutputProposed { + #[allow(missing_docs)] + pub outputRoot: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub l2OutputIndex: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub l1Timestamp: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OutputProposed { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "OutputProposed(bytes32,uint256,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 170u8, 242u8, 81u8, 39u8, 105u8, 218u8, 78u8, 68u8, 78u8, 61u8, + 226u8, 71u8, 190u8, 37u8, 100u8, 34u8, 92u8, 46u8, 122u8, 143u8, 116u8, + 207u8, 229u8, 40u8, 228u8, 110u8, 23u8, 210u8, 72u8, 104u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + outputRoot: topics.1, + l2OutputIndex: topics.2, + l2BlockNumber: topics.3, + l1Timestamp: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.l1Timestamp), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.outputRoot.clone(), + self.l2OutputIndex.clone(), + self.l2BlockNumber.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.outputRoot); + out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.l2OutputIndex); + out[3usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.l2BlockNumber); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OutputProposed { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&OutputProposed> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &OutputProposed) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `OutputsDeleted(uint256,uint256)` and selector `0x4ee37ac2c786ec85e87592d3c5c8a1dd66f8496dda3f125d9ea8ca5f657629b6`. +```solidity +event OutputsDeleted(uint256 indexed prevNextOutputIndex, uint256 indexed newNextOutputIndex); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct OutputsDeleted { + #[allow(missing_docs)] + pub prevNextOutputIndex: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub newNextOutputIndex: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OutputsDeleted { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "OutputsDeleted(uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 78u8, 227u8, 122u8, 194u8, 199u8, 134u8, 236u8, 133u8, 232u8, 117u8, + 146u8, 211u8, 197u8, 200u8, 161u8, 221u8, 102u8, 248u8, 73u8, 109u8, + 218u8, 63u8, 18u8, 93u8, 158u8, 168u8, 202u8, 95u8, 101u8, 118u8, 41u8, + 182u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + prevNextOutputIndex: topics.1, + newNextOutputIndex: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.prevNextOutputIndex.clone(), + self.newNextOutputIndex.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic( + &self.prevNextOutputIndex, + ); + out[2usize] = as alloy_sol_types::EventTopic>::encode_topic( + &self.newNextOutputIndex, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OutputsDeleted { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&OutputsDeleted> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &OutputsDeleted) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`. +```solidity +event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct OwnershipTransferred { + #[allow(missing_docs)] + pub previousOwner: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub newOwner: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "OwnershipTransferred(address,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, + 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, + 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.previousOwner.clone(), + self.newOwner.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::encode_topic( + &self.newOwner, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OwnershipTransferred { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `ProposerUpdated(address,bool)` and selector `0x5df38d395edc15b669d646569bd015513395070b5b4deb8a16300abb060d1b5a`. +```solidity +event ProposerUpdated(address indexed proposer, bool added); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct ProposerUpdated { + #[allow(missing_docs)] + pub proposer: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub added: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for ProposerUpdated { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "ProposerUpdated(address,bool)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 243u8, 141u8, 57u8, 94u8, 220u8, 21u8, 182u8, 105u8, 214u8, 70u8, + 86u8, 155u8, 208u8, 21u8, 81u8, 51u8, 149u8, 7u8, 11u8, 91u8, 77u8, + 235u8, 138u8, 22u8, 48u8, 10u8, 187u8, 6u8, 13u8, 27u8, 90u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + proposer: topics.1, + added: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.added, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.proposer.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.proposer, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for ProposerUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ProposerUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &ProposerUpdated) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `SubmissionIntervalUpdated(uint256,uint256)` and selector `0xc1bf9abfb57ea01ed9ecb4f45e9cefa7ba44b2e6778c3ce7281409999f1af1b2`. +```solidity +event SubmissionIntervalUpdated(uint256 oldSubmissionInterval, uint256 newSubmissionInterval); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct SubmissionIntervalUpdated { + #[allow(missing_docs)] + pub oldSubmissionInterval: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub newSubmissionInterval: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for SubmissionIntervalUpdated { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "SubmissionIntervalUpdated(uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 193u8, 191u8, 154u8, 191u8, 181u8, 126u8, 160u8, 30u8, 217u8, 236u8, + 180u8, 244u8, 94u8, 156u8, 239u8, 167u8, 186u8, 68u8, 178u8, 230u8, + 119u8, 140u8, 60u8, 231u8, 40u8, 20u8, 9u8, 153u8, 159u8, 26u8, 241u8, + 178u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + oldSubmissionInterval: data.0, + newSubmissionInterval: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize( + &self.oldSubmissionInterval, + ), + as alloy_sol_types::SolType>::tokenize(&self.newSubmissionInterval), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for SubmissionIntervalUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&SubmissionIntervalUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &SubmissionIntervalUpdated, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `VerifierUpdated(address,address)` and selector `0x0243549a92b2412f7a3caf7a2e56d65b8821b91345363faa5f57195384065fcc`. +```solidity +event VerifierUpdated(address indexed oldVerifier, address indexed newVerifier); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct VerifierUpdated { + #[allow(missing_docs)] + pub oldVerifier: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub newVerifier: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for VerifierUpdated { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "VerifierUpdated(address,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 2u8, 67u8, 84u8, 154u8, 146u8, 178u8, 65u8, 47u8, 122u8, 60u8, 175u8, + 122u8, 46u8, 86u8, 214u8, 91u8, 136u8, 33u8, 185u8, 19u8, 69u8, 54u8, + 63u8, 170u8, 95u8, 87u8, 25u8, 83u8, 132u8, 6u8, 95u8, 204u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + oldVerifier: topics.1, + newVerifier: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + () + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.oldVerifier.clone(), + self.newVerifier.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.oldVerifier, + ); + out[2usize] = ::encode_topic( + &self.newVerifier, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for VerifierUpdated { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&VerifierUpdated> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &VerifierUpdated) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall {} + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + } + }; + /**Function with signature `GENESIS_CONFIG_NAME()` and selector `0xf72f606d`. +```solidity +function GENESIS_CONFIG_NAME() external view returns (bytes32); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GENESIS_CONFIG_NAMECall; + ///Container type for the return parameters of the [`GENESIS_CONFIG_NAME()`](GENESIS_CONFIG_NAMECall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct GENESIS_CONFIG_NAMEReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: GENESIS_CONFIG_NAMECall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for GENESIS_CONFIG_NAMECall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: GENESIS_CONFIG_NAMEReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for GENESIS_CONFIG_NAMEReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for GENESIS_CONFIG_NAMECall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "GENESIS_CONFIG_NAME()"; + const SELECTOR: [u8; 4] = [247u8, 47u8, 96u8, 109u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: GENESIS_CONFIG_NAMEReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: GENESIS_CONFIG_NAMEReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `addOpSuccinctConfig(bytes32,bytes32,bytes32,bytes32)` and selector `0x47c37e9c`. +```solidity +function addOpSuccinctConfig(bytes32 _configName, bytes32 _rollupConfigHash, bytes32 _aggregationVkey, bytes32 _rangeVkeyCommitment) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct addOpSuccinctConfigCall { + #[allow(missing_docs)] + pub _configName: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + } + ///Container type for the return parameters of the [`addOpSuccinctConfig(bytes32,bytes32,bytes32,bytes32)`](addOpSuccinctConfigCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct addOpSuccinctConfigReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: addOpSuccinctConfigCall) -> Self { + ( + value._configName, + value._rollupConfigHash, + value._aggregationVkey, + value._rangeVkeyCommitment, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for addOpSuccinctConfigCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _configName: tuple.0, + _rollupConfigHash: tuple.1, + _aggregationVkey: tuple.2, + _rangeVkeyCommitment: tuple.3, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: addOpSuccinctConfigReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for addOpSuccinctConfigReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl addOpSuccinctConfigReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for addOpSuccinctConfigCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = addOpSuccinctConfigReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "addOpSuccinctConfig(bytes32,bytes32,bytes32,bytes32)"; + const SELECTOR: [u8; 4] = [71u8, 195u8, 126u8, 156u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._configName), + as alloy_sol_types::SolType>::tokenize(&self._rollupConfigHash), + as alloy_sol_types::SolType>::tokenize(&self._aggregationVkey), + as alloy_sol_types::SolType>::tokenize(&self._rangeVkeyCommitment), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + addOpSuccinctConfigReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `addProposer(address)` and selector `0xb03cd418`. +```solidity +function addProposer(address _proposer) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct addProposerCall { + #[allow(missing_docs)] + pub _proposer: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`addProposer(address)`](addProposerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct addProposerReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: addProposerCall) -> Self { + (value._proposer,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for addProposerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _proposer: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: addProposerReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for addProposerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl addProposerReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for addProposerCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = addProposerReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "addProposer(address)"; + const SELECTOR: [u8; 4] = [176u8, 60u8, 212u8, 24u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._proposer, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + addProposerReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `aggregationVkey()` and selector `0xc32e4e3e`. +```solidity +function aggregationVkey() external view returns (bytes32); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct aggregationVkeyCall; + ///Container type for the return parameters of the [`aggregationVkey()`](aggregationVkeyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct aggregationVkeyReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: aggregationVkeyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for aggregationVkeyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: aggregationVkeyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for aggregationVkeyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for aggregationVkeyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "aggregationVkey()"; + const SELECTOR: [u8; 4] = [195u8, 46u8, 78u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: aggregationVkeyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: aggregationVkeyReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `approvedProposers(address)` and selector `0xd4651276`. +```solidity +function approvedProposers(address) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct approvedProposersCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`approvedProposers(address)`](approvedProposersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct approvedProposersReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: approvedProposersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for approvedProposersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: approvedProposersReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for approvedProposersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for approvedProposersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "approvedProposers(address)"; + const SELECTOR: [u8; 4] = [212u8, 101u8, 18u8, 118u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: approvedProposersReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: approvedProposersReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `challenger()` and selector `0x534db0e2`. +```solidity +function challenger() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengerCall; + ///Container type for the return parameters of the [`challenger()`](challengerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct challengerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: challengerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for challengerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: challengerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for challengerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for challengerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "challenger()"; + const SELECTOR: [u8; 4] = [83u8, 77u8, 176u8, 226u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: challengerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: challengerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `checkpointBlockHash(uint256)` and selector `0x1e856800`. +```solidity +function checkpointBlockHash(uint256 _blockNumber) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct checkpointBlockHashCall { + #[allow(missing_docs)] + pub _blockNumber: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`checkpointBlockHash(uint256)`](checkpointBlockHashCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct checkpointBlockHashReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: checkpointBlockHashCall) -> Self { + (value._blockNumber,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for checkpointBlockHashCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _blockNumber: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: checkpointBlockHashReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for checkpointBlockHashReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl checkpointBlockHashReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for checkpointBlockHashCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = checkpointBlockHashReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "checkpointBlockHash(uint256)"; + const SELECTOR: [u8; 4] = [30u8, 133u8, 104u8, 0u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._blockNumber), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + checkpointBlockHashReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `computeL2Timestamp(uint256)` and selector `0xd1de856c`. +```solidity +function computeL2Timestamp(uint256 _l2BlockNumber) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct computeL2TimestampCall { + #[allow(missing_docs)] + pub _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`computeL2Timestamp(uint256)`](computeL2TimestampCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct computeL2TimestampReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: computeL2TimestampCall) -> Self { + (value._l2BlockNumber,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for computeL2TimestampCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _l2BlockNumber: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: computeL2TimestampReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for computeL2TimestampReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for computeL2TimestampCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "computeL2Timestamp(uint256)"; + const SELECTOR: [u8; 4] = [209u8, 222u8, 133u8, 108u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._l2BlockNumber), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: computeL2TimestampReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: computeL2TimestampReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `deleteL2Outputs(uint256)` and selector `0x89c44cbb`. +```solidity +function deleteL2Outputs(uint256 _l2OutputIndex) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct deleteL2OutputsCall { + #[allow(missing_docs)] + pub _l2OutputIndex: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`deleteL2Outputs(uint256)`](deleteL2OutputsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct deleteL2OutputsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: deleteL2OutputsCall) -> Self { + (value._l2OutputIndex,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for deleteL2OutputsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _l2OutputIndex: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: deleteL2OutputsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for deleteL2OutputsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl deleteL2OutputsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for deleteL2OutputsCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = deleteL2OutputsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "deleteL2Outputs(uint256)"; + const SELECTOR: [u8; 4] = [137u8, 196u8, 76u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._l2OutputIndex), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + deleteL2OutputsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `deleteOpSuccinctConfig(bytes32)` and selector `0xec5b2e3a`. +```solidity +function deleteOpSuccinctConfig(bytes32 _configName) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct deleteOpSuccinctConfigCall { + #[allow(missing_docs)] + pub _configName: alloy::sol_types::private::FixedBytes<32>, + } + ///Container type for the return parameters of the [`deleteOpSuccinctConfig(bytes32)`](deleteOpSuccinctConfigCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct deleteOpSuccinctConfigReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: deleteOpSuccinctConfigCall) -> Self { + (value._configName,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for deleteOpSuccinctConfigCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _configName: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: deleteOpSuccinctConfigReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for deleteOpSuccinctConfigReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl deleteOpSuccinctConfigReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for deleteOpSuccinctConfigCall { + type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = deleteOpSuccinctConfigReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "deleteOpSuccinctConfig(bytes32)"; + const SELECTOR: [u8; 4] = [236u8, 91u8, 46u8, 58u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._configName), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + deleteOpSuccinctConfigReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `dgfProposeL2Output(bytes32,bytes32,uint256,uint256,bytes,address)` and selector `0x7a41a035`. +```solidity +function dgfProposeL2Output(bytes32 _configName, bytes32 _outputRoot, uint256 _l2BlockNumber, uint256 _l1BlockNumber, bytes memory _proof, address _proverAddress) external payable returns (address _game); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct dgfProposeL2OutputCall { + #[allow(missing_docs)] + pub _configName: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _outputRoot: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _l1BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _proof: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub _proverAddress: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`dgfProposeL2Output(bytes32,bytes32,uint256,uint256,bytes,address)`](dgfProposeL2OutputCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct dgfProposeL2OutputReturn { + #[allow(missing_docs)] + pub _game: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: dgfProposeL2OutputCall) -> Self { + ( + value._configName, + value._outputRoot, + value._l2BlockNumber, + value._l1BlockNumber, + value._proof, + value._proverAddress, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for dgfProposeL2OutputCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _configName: tuple.0, + _outputRoot: tuple.1, + _l2BlockNumber: tuple.2, + _l1BlockNumber: tuple.3, + _proof: tuple.4, + _proverAddress: tuple.5, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: dgfProposeL2OutputReturn) -> Self { + (value._game,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for dgfProposeL2OutputReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _game: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for dgfProposeL2OutputCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "dgfProposeL2Output(bytes32,bytes32,uint256,uint256,bytes,address)"; + const SELECTOR: [u8; 4] = [122u8, 65u8, 160u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._configName), + as alloy_sol_types::SolType>::tokenize(&self._outputRoot), + as alloy_sol_types::SolType>::tokenize(&self._l2BlockNumber), + as alloy_sol_types::SolType>::tokenize(&self._l1BlockNumber), + ::tokenize( + &self._proof, + ), + ::tokenize( + &self._proverAddress, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: dgfProposeL2OutputReturn = r.into(); + r._game + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: dgfProposeL2OutputReturn = r.into(); + r._game + }) + } + } + }; + /**Function with signature `disableOptimisticMode(uint256)` and selector `0x4ab309ac`. +```solidity +function disableOptimisticMode(uint256 _finalizationPeriodSeconds) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disableOptimisticModeCall { + #[allow(missing_docs)] + pub _finalizationPeriodSeconds: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`disableOptimisticMode(uint256)`](disableOptimisticModeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disableOptimisticModeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disableOptimisticModeCall) -> Self { + (value._finalizationPeriodSeconds,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disableOptimisticModeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _finalizationPeriodSeconds: tuple.0, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disableOptimisticModeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disableOptimisticModeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl disableOptimisticModeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disableOptimisticModeCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = disableOptimisticModeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disableOptimisticMode(uint256)"; + const SELECTOR: [u8; 4] = [74u8, 179u8, 9u8, 172u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize( + &self._finalizationPeriodSeconds, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + disableOptimisticModeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `disputeGameFactory()` and selector `0xf2b4e617`. +```solidity +function disputeGameFactory() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFactoryCall; + ///Container type for the return parameters of the [`disputeGameFactory()`](disputeGameFactoryCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct disputeGameFactoryReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFactoryCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFactoryCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: disputeGameFactoryReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for disputeGameFactoryReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for disputeGameFactoryCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "disputeGameFactory()"; + const SELECTOR: [u8; 4] = [242u8, 180u8, 230u8, 23u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: disputeGameFactoryReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: disputeGameFactoryReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `enableOptimisticMode(uint256)` and selector `0x2c697961`. +```solidity +function enableOptimisticMode(uint256 _finalizationPeriodSeconds) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct enableOptimisticModeCall { + #[allow(missing_docs)] + pub _finalizationPeriodSeconds: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`enableOptimisticMode(uint256)`](enableOptimisticModeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct enableOptimisticModeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: enableOptimisticModeCall) -> Self { + (value._finalizationPeriodSeconds,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for enableOptimisticModeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _finalizationPeriodSeconds: tuple.0, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: enableOptimisticModeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for enableOptimisticModeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl enableOptimisticModeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for enableOptimisticModeCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = enableOptimisticModeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "enableOptimisticMode(uint256)"; + const SELECTOR: [u8; 4] = [44u8, 105u8, 121u8, 97u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize( + &self._finalizationPeriodSeconds, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + enableOptimisticModeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `fallbackTimeout()` and selector `0x4277bc06`. +```solidity +function fallbackTimeout() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct fallbackTimeoutCall; + ///Container type for the return parameters of the [`fallbackTimeout()`](fallbackTimeoutCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct fallbackTimeoutReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: fallbackTimeoutCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for fallbackTimeoutCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: fallbackTimeoutReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for fallbackTimeoutReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for fallbackTimeoutCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "fallbackTimeout()"; + const SELECTOR: [u8; 4] = [66u8, 119u8, 188u8, 6u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: fallbackTimeoutReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: fallbackTimeoutReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `finalizationPeriodSeconds()` and selector `0xce5db8d6`. +```solidity +function finalizationPeriodSeconds() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct finalizationPeriodSecondsCall; + ///Container type for the return parameters of the [`finalizationPeriodSeconds()`](finalizationPeriodSecondsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct finalizationPeriodSecondsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: finalizationPeriodSecondsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for finalizationPeriodSecondsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: finalizationPeriodSecondsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for finalizationPeriodSecondsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for finalizationPeriodSecondsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "finalizationPeriodSeconds()"; + const SELECTOR: [u8; 4] = [206u8, 93u8, 184u8, 214u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: finalizationPeriodSecondsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: finalizationPeriodSecondsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `getL2Output(uint256)` and selector `0xa25ae557`. +```solidity +function getL2Output(uint256 _l2OutputIndex) external view returns (Types.OutputProposal memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getL2OutputCall { + #[allow(missing_docs)] + pub _l2OutputIndex: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`getL2Output(uint256)`](getL2OutputCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getL2OutputReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getL2OutputCall) -> Self { + (value._l2OutputIndex,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getL2OutputCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _l2OutputIndex: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Types::OutputProposal,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getL2OutputReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getL2OutputReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getL2OutputCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Types::OutputProposal,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getL2Output(uint256)"; + const SELECTOR: [u8; 4] = [162u8, 90u8, 229u8, 87u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._l2OutputIndex), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getL2OutputReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getL2OutputReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `getL2OutputAfter(uint256)` and selector `0xcf8e5cf0`. +```solidity +function getL2OutputAfter(uint256 _l2BlockNumber) external view returns (Types.OutputProposal memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getL2OutputAfterCall { + #[allow(missing_docs)] + pub _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`getL2OutputAfter(uint256)`](getL2OutputAfterCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getL2OutputAfterReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getL2OutputAfterCall) -> Self { + (value._l2BlockNumber,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getL2OutputAfterCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _l2BlockNumber: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (Types::OutputProposal,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getL2OutputAfterReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getL2OutputAfterReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getL2OutputAfterCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (Types::OutputProposal,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getL2OutputAfter(uint256)"; + const SELECTOR: [u8; 4] = [207u8, 142u8, 92u8, 240u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._l2BlockNumber), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getL2OutputAfterReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getL2OutputAfterReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `getL2OutputIndexAfter(uint256)` and selector `0x7f006420`. +```solidity +function getL2OutputIndexAfter(uint256 _l2BlockNumber) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getL2OutputIndexAfterCall { + #[allow(missing_docs)] + pub _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`getL2OutputIndexAfter(uint256)`](getL2OutputIndexAfterCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getL2OutputIndexAfterReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getL2OutputIndexAfterCall) -> Self { + (value._l2BlockNumber,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getL2OutputIndexAfterCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _l2BlockNumber: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getL2OutputIndexAfterReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getL2OutputIndexAfterReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getL2OutputIndexAfterCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getL2OutputIndexAfter(uint256)"; + const SELECTOR: [u8; 4] = [127u8, 0u8, 100u8, 32u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._l2BlockNumber), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getL2OutputIndexAfterReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getL2OutputIndexAfterReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `historicBlockHashes(uint256)` and selector `0xa196b525`. +```solidity +function historicBlockHashes(uint256) external view returns (bytes32); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct historicBlockHashesCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + ///Container type for the return parameters of the [`historicBlockHashes(uint256)`](historicBlockHashesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct historicBlockHashesReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: historicBlockHashesCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for historicBlockHashesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: historicBlockHashesReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for historicBlockHashesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for historicBlockHashesCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "historicBlockHashes(uint256)"; + const SELECTOR: [u8; 4] = [161u8, 150u8, 181u8, 37u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: historicBlockHashesReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: historicBlockHashesReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initialize((address,address,address,uint256,uint256,bytes32,bytes32,bytes32,bytes32,uint256,uint256,uint256,address,uint256))` and selector `0xe40b7a12`. +```solidity +function initialize(InitParams memory _initParams) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall { + #[allow(missing_docs)] + pub _initParams: ::RustType, + } + ///Container type for the return parameters of the [`initialize((address,address,address,uint256,uint256,bytes32,bytes32,bytes32,bytes32,uint256,uint256,uint256,address,uint256))`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (InitParams,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + (value._initParams,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _initParams: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = (InitParams,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize((address,address,address,uint256,uint256,bytes32,bytes32,bytes32,bytes32,uint256,uint256,uint256,address,uint256))"; + const SELECTOR: [u8; 4] = [228u8, 11u8, 122u8, 18u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + (::tokenize(&self._initParams),) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `initializerVersion()` and selector `0x7f01ea68`. +```solidity +function initializerVersion() external view returns (uint8); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializerVersionCall; + ///Container type for the return parameters of the [`initializerVersion()`](initializerVersionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializerVersionReturn { + #[allow(missing_docs)] + pub _0: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: initializerVersionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for initializerVersionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u8,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: initializerVersionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for initializerVersionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializerVersionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initializerVersion()"; + const SELECTOR: [u8; 4] = [127u8, 1u8, 234u8, 104u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: initializerVersionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: initializerVersionReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `isValidOpSuccinctConfig((bytes32,bytes32,bytes32))` and selector `0x49185e06`. +```solidity +function isValidOpSuccinctConfig(OpSuccinctConfig memory _config) external pure returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isValidOpSuccinctConfigCall { + #[allow(missing_docs)] + pub _config: ::RustType, + } + ///Container type for the return parameters of the [`isValidOpSuccinctConfig((bytes32,bytes32,bytes32))`](isValidOpSuccinctConfigCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isValidOpSuccinctConfigReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (OpSuccinctConfig,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isValidOpSuccinctConfigCall) -> Self { + (value._config,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isValidOpSuccinctConfigCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _config: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isValidOpSuccinctConfigReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isValidOpSuccinctConfigReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isValidOpSuccinctConfigCall { + type Parameters<'a> = (OpSuccinctConfig,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isValidOpSuccinctConfig((bytes32,bytes32,bytes32))"; + const SELECTOR: [u8; 4] = [73u8, 24u8, 94u8, 6u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._config, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isValidOpSuccinctConfigReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isValidOpSuccinctConfigReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `l2BlockTime()` and selector `0x93991af3`. +```solidity +function l2BlockTime() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockTimeCall; + ///Container type for the return parameters of the [`l2BlockTime()`](l2BlockTimeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct l2BlockTimeReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l2BlockTimeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l2BlockTimeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: l2BlockTimeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for l2BlockTimeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for l2BlockTimeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "l2BlockTime()"; + const SELECTOR: [u8; 4] = [147u8, 153u8, 26u8, 243u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: l2BlockTimeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: l2BlockTimeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `lastProposalTimestamp()` and selector `0xe0c2f935`. +```solidity +function lastProposalTimestamp() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct lastProposalTimestampCall; + ///Container type for the return parameters of the [`lastProposalTimestamp()`](lastProposalTimestampCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct lastProposalTimestampReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: lastProposalTimestampCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for lastProposalTimestampCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: lastProposalTimestampReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for lastProposalTimestampReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for lastProposalTimestampCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "lastProposalTimestamp()"; + const SELECTOR: [u8; 4] = [224u8, 194u8, 249u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: lastProposalTimestampReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: lastProposalTimestampReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `latestBlockNumber()` and selector `0x4599c788`. +```solidity +function latestBlockNumber() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct latestBlockNumberCall; + ///Container type for the return parameters of the [`latestBlockNumber()`](latestBlockNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct latestBlockNumberReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: latestBlockNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for latestBlockNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: latestBlockNumberReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for latestBlockNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for latestBlockNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "latestBlockNumber()"; + const SELECTOR: [u8; 4] = [69u8, 153u8, 199u8, 136u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: latestBlockNumberReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: latestBlockNumberReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `latestOutputIndex()` and selector `0x69f16eec`. +```solidity +function latestOutputIndex() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct latestOutputIndexCall; + ///Container type for the return parameters of the [`latestOutputIndex()`](latestOutputIndexCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct latestOutputIndexReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: latestOutputIndexCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for latestOutputIndexCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: latestOutputIndexReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for latestOutputIndexReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for latestOutputIndexCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "latestOutputIndex()"; + const SELECTOR: [u8; 4] = [105u8, 241u8, 110u8, 236u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: latestOutputIndexReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: latestOutputIndexReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `nextBlockNumber()` and selector `0xdcec3348`. +```solidity +function nextBlockNumber() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct nextBlockNumberCall; + ///Container type for the return parameters of the [`nextBlockNumber()`](nextBlockNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct nextBlockNumberReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nextBlockNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nextBlockNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: nextBlockNumberReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for nextBlockNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for nextBlockNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "nextBlockNumber()"; + const SELECTOR: [u8; 4] = [220u8, 236u8, 51u8, 72u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: nextBlockNumberReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: nextBlockNumberReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `nextOutputIndex()` and selector `0x6abcf563`. +```solidity +function nextOutputIndex() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct nextOutputIndexCall; + ///Container type for the return parameters of the [`nextOutputIndex()`](nextOutputIndexCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct nextOutputIndexReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nextOutputIndexCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nextOutputIndexCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: nextOutputIndexReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for nextOutputIndexReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for nextOutputIndexCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "nextOutputIndex()"; + const SELECTOR: [u8; 4] = [106u8, 188u8, 245u8, 99u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: nextOutputIndexReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: nextOutputIndexReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `opSuccinctConfigs(bytes32)` and selector `0x6a56620b`. +```solidity +function opSuccinctConfigs(bytes32) external view returns (bytes32 aggregationVkey, bytes32 rangeVkeyCommitment, bytes32 rollupConfigHash); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct opSuccinctConfigsCall(pub alloy::sol_types::private::FixedBytes<32>); + ///Container type for the return parameters of the [`opSuccinctConfigs(bytes32)`](opSuccinctConfigsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct opSuccinctConfigsReturn { + #[allow(missing_docs)] + pub aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: opSuccinctConfigsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for opSuccinctConfigsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: opSuccinctConfigsReturn) -> Self { + ( + value.aggregationVkey, + value.rangeVkeyCommitment, + value.rollupConfigHash, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for opSuccinctConfigsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + aggregationVkey: tuple.0, + rangeVkeyCommitment: tuple.1, + rollupConfigHash: tuple.2, + } + } + } + } + impl opSuccinctConfigsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.aggregationVkey), + as alloy_sol_types::SolType>::tokenize(&self.rangeVkeyCommitment), + as alloy_sol_types::SolType>::tokenize(&self.rollupConfigHash), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for opSuccinctConfigsCall { + type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = opSuccinctConfigsReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "opSuccinctConfigs(bytes32)"; + const SELECTOR: [u8; 4] = [106u8, 86u8, 98u8, 11u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + opSuccinctConfigsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `optimisticMode()` and selector `0x60caf7a0`. +```solidity +function optimisticMode() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct optimisticModeCall; + ///Container type for the return parameters of the [`optimisticMode()`](optimisticModeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct optimisticModeReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: optimisticModeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for optimisticModeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: optimisticModeReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for optimisticModeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for optimisticModeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "optimisticMode()"; + const SELECTOR: [u8; 4] = [96u8, 202u8, 247u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: optimisticModeReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: optimisticModeReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `owner()` and selector `0x8da5cb5b`. +```solidity +function owner() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ownerCall; + ///Container type for the return parameters of the [`owner()`](ownerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ownerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proposeL2Output(bytes32,uint256,bytes32,uint256)` and selector `0x9aaab648`. +```solidity +function proposeL2Output(bytes32 _outputRoot, uint256 _l2BlockNumber, bytes32 _l1BlockHash, uint256 _l1BlockNumber) external payable; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proposeL2Output_0Call { + #[allow(missing_docs)] + pub _outputRoot: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _l1BlockHash: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _l1BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`proposeL2Output(bytes32,uint256,bytes32,uint256)`](proposeL2Output_0Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proposeL2Output_0Return {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proposeL2Output_0Call) -> Self { + ( + value._outputRoot, + value._l2BlockNumber, + value._l1BlockHash, + value._l1BlockNumber, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proposeL2Output_0Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _outputRoot: tuple.0, + _l2BlockNumber: tuple.1, + _l1BlockHash: tuple.2, + _l1BlockNumber: tuple.3, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proposeL2Output_0Return) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proposeL2Output_0Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl proposeL2Output_0Return { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proposeL2Output_0Call { + type Parameters<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = proposeL2Output_0Return; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proposeL2Output(bytes32,uint256,bytes32,uint256)"; + const SELECTOR: [u8; 4] = [154u8, 170u8, 182u8, 72u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._outputRoot), + as alloy_sol_types::SolType>::tokenize(&self._l2BlockNumber), + as alloy_sol_types::SolType>::tokenize(&self._l1BlockHash), + as alloy_sol_types::SolType>::tokenize(&self._l1BlockNumber), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + proposeL2Output_0Return::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `proposeL2Output(bytes32,bytes32,uint256,uint256,bytes,address)` and selector `0xa4ee9d7b`. +```solidity +function proposeL2Output(bytes32 _configName, bytes32 _outputRoot, uint256 _l2BlockNumber, uint256 _l1BlockNumber, bytes memory _proof, address _proverAddress) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proposeL2Output_1Call { + #[allow(missing_docs)] + pub _configName: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _outputRoot: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _l1BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _proof: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub _proverAddress: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`proposeL2Output(bytes32,bytes32,uint256,uint256,bytes,address)`](proposeL2Output_1Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proposeL2Output_1Return {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::Address, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proposeL2Output_1Call) -> Self { + ( + value._configName, + value._outputRoot, + value._l2BlockNumber, + value._l1BlockNumber, + value._proof, + value._proverAddress, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proposeL2Output_1Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _configName: tuple.0, + _outputRoot: tuple.1, + _l2BlockNumber: tuple.2, + _l1BlockNumber: tuple.3, + _proof: tuple.4, + _proverAddress: tuple.5, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proposeL2Output_1Return) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proposeL2Output_1Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl proposeL2Output_1Return { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proposeL2Output_1Call { + type Parameters<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = proposeL2Output_1Return; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proposeL2Output(bytes32,bytes32,uint256,uint256,bytes,address)"; + const SELECTOR: [u8; 4] = [164u8, 238u8, 157u8, 123u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._configName), + as alloy_sol_types::SolType>::tokenize(&self._outputRoot), + as alloy_sol_types::SolType>::tokenize(&self._l2BlockNumber), + as alloy_sol_types::SolType>::tokenize(&self._l1BlockNumber), + ::tokenize( + &self._proof, + ), + ::tokenize( + &self._proverAddress, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + proposeL2Output_1Return::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `proposer()` and selector `0xa8e4fb90`. +```solidity +function proposer() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proposerCall; + ///Container type for the return parameters of the [`proposer()`](proposerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proposerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proposerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proposerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proposerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proposerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proposerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proposer()"; + const SELECTOR: [u8; 4] = [168u8, 228u8, 251u8, 144u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proposerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proposerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `rangeVkeyCommitment()` and selector `0x2b31841e`. +```solidity +function rangeVkeyCommitment() external view returns (bytes32); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rangeVkeyCommitmentCall; + ///Container type for the return parameters of the [`rangeVkeyCommitment()`](rangeVkeyCommitmentCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rangeVkeyCommitmentReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: rangeVkeyCommitmentCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for rangeVkeyCommitmentCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: rangeVkeyCommitmentReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for rangeVkeyCommitmentReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for rangeVkeyCommitmentCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "rangeVkeyCommitment()"; + const SELECTOR: [u8; 4] = [43u8, 49u8, 132u8, 30u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: rangeVkeyCommitmentReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: rangeVkeyCommitmentReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `removeProposer(address)` and selector `0x09d632d3`. +```solidity +function removeProposer(address _proposer) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct removeProposerCall { + #[allow(missing_docs)] + pub _proposer: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`removeProposer(address)`](removeProposerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct removeProposerReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: removeProposerCall) -> Self { + (value._proposer,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for removeProposerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _proposer: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: removeProposerReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for removeProposerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl removeProposerReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for removeProposerCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = removeProposerReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "removeProposer(address)"; + const SELECTOR: [u8; 4] = [9u8, 214u8, 50u8, 211u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._proposer, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + removeProposerReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `rollupConfigHash()` and selector `0x6d9a1c8b`. +```solidity +function rollupConfigHash() external view returns (bytes32); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rollupConfigHashCall; + ///Container type for the return parameters of the [`rollupConfigHash()`](rollupConfigHashCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct rollupConfigHashReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::FixedBytes<32>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: rollupConfigHashCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for rollupConfigHashCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: rollupConfigHashReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for rollupConfigHashReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for rollupConfigHashCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "rollupConfigHash()"; + const SELECTOR: [u8; 4] = [109u8, 154u8, 28u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: rollupConfigHashReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: rollupConfigHashReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `setDisputeGameFactory(address)` and selector `0x3419d2c2`. +```solidity +function setDisputeGameFactory(address _disputeGameFactory) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setDisputeGameFactoryCall { + #[allow(missing_docs)] + pub _disputeGameFactory: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`setDisputeGameFactory(address)`](setDisputeGameFactoryCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setDisputeGameFactoryReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setDisputeGameFactoryCall) -> Self { + (value._disputeGameFactory,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setDisputeGameFactoryCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _disputeGameFactory: tuple.0, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setDisputeGameFactoryReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setDisputeGameFactoryReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setDisputeGameFactoryReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setDisputeGameFactoryCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setDisputeGameFactoryReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setDisputeGameFactory(address)"; + const SELECTOR: [u8; 4] = [52u8, 25u8, 210u8, 194u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._disputeGameFactory, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setDisputeGameFactoryReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `startingBlockNumber()` and selector `0x70872aa5`. +```solidity +function startingBlockNumber() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingBlockNumberCall; + ///Container type for the return parameters of the [`startingBlockNumber()`](startingBlockNumberCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingBlockNumberReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingBlockNumberCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingBlockNumberCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingBlockNumberReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingBlockNumberReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for startingBlockNumberCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "startingBlockNumber()"; + const SELECTOR: [u8; 4] = [112u8, 135u8, 42u8, 165u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: startingBlockNumberReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: startingBlockNumberReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `startingTimestamp()` and selector `0x88786272`. +```solidity +function startingTimestamp() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingTimestampCall; + ///Container type for the return parameters of the [`startingTimestamp()`](startingTimestampCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct startingTimestampReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingTimestampCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingTimestampCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: startingTimestampReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for startingTimestampReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for startingTimestampCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "startingTimestamp()"; + const SELECTOR: [u8; 4] = [136u8, 120u8, 98u8, 114u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: startingTimestampReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: startingTimestampReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `submissionInterval()` and selector `0xe1a41bcf`. +```solidity +function submissionInterval() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct submissionIntervalCall; + ///Container type for the return parameters of the [`submissionInterval()`](submissionIntervalCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct submissionIntervalReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: submissionIntervalCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for submissionIntervalCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: submissionIntervalReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for submissionIntervalReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for submissionIntervalCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "submissionInterval()"; + const SELECTOR: [u8; 4] = [225u8, 164u8, 27u8, 207u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: submissionIntervalReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: submissionIntervalReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`. +```solidity +function transferOwnership(address _owner) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct transferOwnershipCall { + #[allow(missing_docs)] + pub _owner: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct transferOwnershipReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value._owner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _owner: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._owner, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + transferOwnershipReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `updateSubmissionInterval(uint256)` and selector `0x336c9e81`. +```solidity +function updateSubmissionInterval(uint256 _submissionInterval) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct updateSubmissionIntervalCall { + #[allow(missing_docs)] + pub _submissionInterval: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`updateSubmissionInterval(uint256)`](updateSubmissionIntervalCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct updateSubmissionIntervalReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: updateSubmissionIntervalCall) -> Self { + (value._submissionInterval,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for updateSubmissionIntervalCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _submissionInterval: tuple.0, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: updateSubmissionIntervalReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for updateSubmissionIntervalReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl updateSubmissionIntervalReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for updateSubmissionIntervalCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = updateSubmissionIntervalReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "updateSubmissionInterval(uint256)"; + const SELECTOR: [u8; 4] = [51u8, 108u8, 158u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._submissionInterval), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + updateSubmissionIntervalReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `updateVerifier(address)` and selector `0x97fc007c`. +```solidity +function updateVerifier(address _verifier) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct updateVerifierCall { + #[allow(missing_docs)] + pub _verifier: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`updateVerifier(address)`](updateVerifierCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct updateVerifierReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: updateVerifierCall) -> Self { + (value._verifier,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for updateVerifierCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _verifier: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: updateVerifierReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for updateVerifierReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl updateVerifierReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for updateVerifierCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = updateVerifierReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "updateVerifier(address)"; + const SELECTOR: [u8; 4] = [151u8, 252u8, 0u8, 124u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._verifier, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + updateVerifierReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `verifier()` and selector `0x2b7ac3f3`. +```solidity +function verifier() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct verifierCall; + ///Container type for the return parameters of the [`verifier()`](verifierCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct verifierReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: verifierCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for verifierCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: verifierReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for verifierReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for verifierCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "verifier()"; + const SELECTOR: [u8; 4] = [43u8, 122u8, 195u8, 243u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: verifierReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: verifierReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `version()` and selector `0x54fd4d50`. +```solidity +function version() external view returns (string memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionCall; + ///Container type for the return parameters of the [`version()`](versionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for versionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "version()"; + const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`OPSuccinctL2OutputOracle`](self) function calls. + #[derive(Clone)] + pub enum OPSuccinctL2OutputOracleCalls { + #[allow(missing_docs)] + GENESIS_CONFIG_NAME(GENESIS_CONFIG_NAMECall), + #[allow(missing_docs)] + addOpSuccinctConfig(addOpSuccinctConfigCall), + #[allow(missing_docs)] + addProposer(addProposerCall), + #[allow(missing_docs)] + aggregationVkey(aggregationVkeyCall), + #[allow(missing_docs)] + approvedProposers(approvedProposersCall), + #[allow(missing_docs)] + challenger(challengerCall), + #[allow(missing_docs)] + checkpointBlockHash(checkpointBlockHashCall), + #[allow(missing_docs)] + computeL2Timestamp(computeL2TimestampCall), + #[allow(missing_docs)] + deleteL2Outputs(deleteL2OutputsCall), + #[allow(missing_docs)] + deleteOpSuccinctConfig(deleteOpSuccinctConfigCall), + #[allow(missing_docs)] + dgfProposeL2Output(dgfProposeL2OutputCall), + #[allow(missing_docs)] + disableOptimisticMode(disableOptimisticModeCall), + #[allow(missing_docs)] + disputeGameFactory(disputeGameFactoryCall), + #[allow(missing_docs)] + enableOptimisticMode(enableOptimisticModeCall), + #[allow(missing_docs)] + fallbackTimeout(fallbackTimeoutCall), + #[allow(missing_docs)] + finalizationPeriodSeconds(finalizationPeriodSecondsCall), + #[allow(missing_docs)] + getL2Output(getL2OutputCall), + #[allow(missing_docs)] + getL2OutputAfter(getL2OutputAfterCall), + #[allow(missing_docs)] + getL2OutputIndexAfter(getL2OutputIndexAfterCall), + #[allow(missing_docs)] + historicBlockHashes(historicBlockHashesCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + initializerVersion(initializerVersionCall), + #[allow(missing_docs)] + isValidOpSuccinctConfig(isValidOpSuccinctConfigCall), + #[allow(missing_docs)] + l2BlockTime(l2BlockTimeCall), + #[allow(missing_docs)] + lastProposalTimestamp(lastProposalTimestampCall), + #[allow(missing_docs)] + latestBlockNumber(latestBlockNumberCall), + #[allow(missing_docs)] + latestOutputIndex(latestOutputIndexCall), + #[allow(missing_docs)] + nextBlockNumber(nextBlockNumberCall), + #[allow(missing_docs)] + nextOutputIndex(nextOutputIndexCall), + #[allow(missing_docs)] + opSuccinctConfigs(opSuccinctConfigsCall), + #[allow(missing_docs)] + optimisticMode(optimisticModeCall), + #[allow(missing_docs)] + owner(ownerCall), + #[allow(missing_docs)] + proposeL2Output_0(proposeL2Output_0Call), + #[allow(missing_docs)] + proposeL2Output_1(proposeL2Output_1Call), + #[allow(missing_docs)] + proposer(proposerCall), + #[allow(missing_docs)] + rangeVkeyCommitment(rangeVkeyCommitmentCall), + #[allow(missing_docs)] + removeProposer(removeProposerCall), + #[allow(missing_docs)] + rollupConfigHash(rollupConfigHashCall), + #[allow(missing_docs)] + setDisputeGameFactory(setDisputeGameFactoryCall), + #[allow(missing_docs)] + startingBlockNumber(startingBlockNumberCall), + #[allow(missing_docs)] + startingTimestamp(startingTimestampCall), + #[allow(missing_docs)] + submissionInterval(submissionIntervalCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + #[allow(missing_docs)] + updateSubmissionInterval(updateSubmissionIntervalCall), + #[allow(missing_docs)] + updateVerifier(updateVerifierCall), + #[allow(missing_docs)] + verifier(verifierCall), + #[allow(missing_docs)] + version(versionCall), + } + impl OPSuccinctL2OutputOracleCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [9u8, 214u8, 50u8, 211u8], + [30u8, 133u8, 104u8, 0u8], + [43u8, 49u8, 132u8, 30u8], + [43u8, 122u8, 195u8, 243u8], + [44u8, 105u8, 121u8, 97u8], + [51u8, 108u8, 158u8, 129u8], + [52u8, 25u8, 210u8, 194u8], + [66u8, 119u8, 188u8, 6u8], + [69u8, 153u8, 199u8, 136u8], + [71u8, 195u8, 126u8, 156u8], + [73u8, 24u8, 94u8, 6u8], + [74u8, 179u8, 9u8, 172u8], + [83u8, 77u8, 176u8, 226u8], + [84u8, 253u8, 77u8, 80u8], + [96u8, 202u8, 247u8, 160u8], + [105u8, 241u8, 110u8, 236u8], + [106u8, 86u8, 98u8, 11u8], + [106u8, 188u8, 245u8, 99u8], + [109u8, 154u8, 28u8, 139u8], + [112u8, 135u8, 42u8, 165u8], + [122u8, 65u8, 160u8, 53u8], + [127u8, 0u8, 100u8, 32u8], + [127u8, 1u8, 234u8, 104u8], + [136u8, 120u8, 98u8, 114u8], + [137u8, 196u8, 76u8, 187u8], + [141u8, 165u8, 203u8, 91u8], + [147u8, 153u8, 26u8, 243u8], + [151u8, 252u8, 0u8, 124u8], + [154u8, 170u8, 182u8, 72u8], + [161u8, 150u8, 181u8, 37u8], + [162u8, 90u8, 229u8, 87u8], + [164u8, 238u8, 157u8, 123u8], + [168u8, 228u8, 251u8, 144u8], + [176u8, 60u8, 212u8, 24u8], + [195u8, 46u8, 78u8, 62u8], + [206u8, 93u8, 184u8, 214u8], + [207u8, 142u8, 92u8, 240u8], + [209u8, 222u8, 133u8, 108u8], + [212u8, 101u8, 18u8, 118u8], + [220u8, 236u8, 51u8, 72u8], + [224u8, 194u8, 249u8, 53u8], + [225u8, 164u8, 27u8, 207u8], + [228u8, 11u8, 122u8, 18u8], + [236u8, 91u8, 46u8, 58u8], + [242u8, 180u8, 230u8, 23u8], + [242u8, 253u8, 227u8, 139u8], + [247u8, 47u8, 96u8, 109u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(removeProposer), + ::core::stringify!(checkpointBlockHash), + ::core::stringify!(rangeVkeyCommitment), + ::core::stringify!(verifier), + ::core::stringify!(enableOptimisticMode), + ::core::stringify!(updateSubmissionInterval), + ::core::stringify!(setDisputeGameFactory), + ::core::stringify!(fallbackTimeout), + ::core::stringify!(latestBlockNumber), + ::core::stringify!(addOpSuccinctConfig), + ::core::stringify!(isValidOpSuccinctConfig), + ::core::stringify!(disableOptimisticMode), + ::core::stringify!(challenger), + ::core::stringify!(version), + ::core::stringify!(optimisticMode), + ::core::stringify!(latestOutputIndex), + ::core::stringify!(opSuccinctConfigs), + ::core::stringify!(nextOutputIndex), + ::core::stringify!(rollupConfigHash), + ::core::stringify!(startingBlockNumber), + ::core::stringify!(dgfProposeL2Output), + ::core::stringify!(getL2OutputIndexAfter), + ::core::stringify!(initializerVersion), + ::core::stringify!(startingTimestamp), + ::core::stringify!(deleteL2Outputs), + ::core::stringify!(owner), + ::core::stringify!(l2BlockTime), + ::core::stringify!(updateVerifier), + ::core::stringify!(proposeL2Output_0), + ::core::stringify!(historicBlockHashes), + ::core::stringify!(getL2Output), + ::core::stringify!(proposeL2Output_1), + ::core::stringify!(proposer), + ::core::stringify!(addProposer), + ::core::stringify!(aggregationVkey), + ::core::stringify!(finalizationPeriodSeconds), + ::core::stringify!(getL2OutputAfter), + ::core::stringify!(computeL2Timestamp), + ::core::stringify!(approvedProposers), + ::core::stringify!(nextBlockNumber), + ::core::stringify!(lastProposalTimestamp), + ::core::stringify!(submissionInterval), + ::core::stringify!(initialize), + ::core::stringify!(deleteOpSuccinctConfig), + ::core::stringify!(disputeGameFactory), + ::core::stringify!(transferOwnership), + ::core::stringify!(GENESIS_CONFIG_NAME), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for OPSuccinctL2OutputOracleCalls { + const NAME: &'static str = "OPSuccinctL2OutputOracleCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 47usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::GENESIS_CONFIG_NAME(_) => { + ::SELECTOR + } + Self::addOpSuccinctConfig(_) => { + ::SELECTOR + } + Self::addProposer(_) => { + ::SELECTOR + } + Self::aggregationVkey(_) => { + ::SELECTOR + } + Self::approvedProposers(_) => { + ::SELECTOR + } + Self::challenger(_) => { + ::SELECTOR + } + Self::checkpointBlockHash(_) => { + ::SELECTOR + } + Self::computeL2Timestamp(_) => { + ::SELECTOR + } + Self::deleteL2Outputs(_) => { + ::SELECTOR + } + Self::deleteOpSuccinctConfig(_) => { + ::SELECTOR + } + Self::dgfProposeL2Output(_) => { + ::SELECTOR + } + Self::disableOptimisticMode(_) => { + ::SELECTOR + } + Self::disputeGameFactory(_) => { + ::SELECTOR + } + Self::enableOptimisticMode(_) => { + ::SELECTOR + } + Self::fallbackTimeout(_) => { + ::SELECTOR + } + Self::finalizationPeriodSeconds(_) => { + ::SELECTOR + } + Self::getL2Output(_) => { + ::SELECTOR + } + Self::getL2OutputAfter(_) => { + ::SELECTOR + } + Self::getL2OutputIndexAfter(_) => { + ::SELECTOR + } + Self::historicBlockHashes(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } + Self::initializerVersion(_) => { + ::SELECTOR + } + Self::isValidOpSuccinctConfig(_) => { + ::SELECTOR + } + Self::l2BlockTime(_) => { + ::SELECTOR + } + Self::lastProposalTimestamp(_) => { + ::SELECTOR + } + Self::latestBlockNumber(_) => { + ::SELECTOR + } + Self::latestOutputIndex(_) => { + ::SELECTOR + } + Self::nextBlockNumber(_) => { + ::SELECTOR + } + Self::nextOutputIndex(_) => { + ::SELECTOR + } + Self::opSuccinctConfigs(_) => { + ::SELECTOR + } + Self::optimisticMode(_) => { + ::SELECTOR + } + Self::owner(_) => ::SELECTOR, + Self::proposeL2Output_0(_) => { + ::SELECTOR + } + Self::proposeL2Output_1(_) => { + ::SELECTOR + } + Self::proposer(_) => ::SELECTOR, + Self::rangeVkeyCommitment(_) => { + ::SELECTOR + } + Self::removeProposer(_) => { + ::SELECTOR + } + Self::rollupConfigHash(_) => { + ::SELECTOR + } + Self::setDisputeGameFactory(_) => { + ::SELECTOR + } + Self::startingBlockNumber(_) => { + ::SELECTOR + } + Self::startingTimestamp(_) => { + ::SELECTOR + } + Self::submissionInterval(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::SELECTOR + } + Self::updateSubmissionInterval(_) => { + ::SELECTOR + } + Self::updateVerifier(_) => { + ::SELECTOR + } + Self::verifier(_) => ::SELECTOR, + Self::version(_) => ::SELECTOR, + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn removeProposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::removeProposer) + } + removeProposer + }, + { + fn checkpointBlockHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::checkpointBlockHash) + } + checkpointBlockHash + }, + { + fn rangeVkeyCommitment( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::rangeVkeyCommitment) + } + rangeVkeyCommitment + }, + { + fn verifier( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctL2OutputOracleCalls::verifier) + } + verifier + }, + { + fn enableOptimisticMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::enableOptimisticMode) + } + enableOptimisticMode + }, + { + fn updateSubmissionInterval( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::updateSubmissionInterval) + } + updateSubmissionInterval + }, + { + fn setDisputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::setDisputeGameFactory) + } + setDisputeGameFactory + }, + { + fn fallbackTimeout( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::fallbackTimeout) + } + fallbackTimeout + }, + { + fn latestBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::latestBlockNumber) + } + latestBlockNumber + }, + { + fn addOpSuccinctConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::addOpSuccinctConfig) + } + addOpSuccinctConfig + }, + { + fn isValidOpSuccinctConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::isValidOpSuccinctConfig) + } + isValidOpSuccinctConfig + }, + { + fn disableOptimisticMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::disableOptimisticMode) + } + disableOptimisticMode + }, + { + fn challenger( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::challenger) + } + challenger + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctL2OutputOracleCalls::version) + } + version + }, + { + fn optimisticMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::optimisticMode) + } + optimisticMode + }, + { + fn latestOutputIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::latestOutputIndex) + } + latestOutputIndex + }, + { + fn opSuccinctConfigs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::opSuccinctConfigs) + } + opSuccinctConfigs + }, + { + fn nextOutputIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::nextOutputIndex) + } + nextOutputIndex + }, + { + fn rollupConfigHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::rollupConfigHash) + } + rollupConfigHash + }, + { + fn startingBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::startingBlockNumber) + } + startingBlockNumber + }, + { + fn dgfProposeL2Output( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::dgfProposeL2Output) + } + dgfProposeL2Output + }, + { + fn getL2OutputIndexAfter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::getL2OutputIndexAfter) + } + getL2OutputIndexAfter + }, + { + fn initializerVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::initializerVersion) + } + initializerVersion + }, + { + fn startingTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::startingTimestamp) + } + startingTimestamp + }, + { + fn deleteL2Outputs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::deleteL2Outputs) + } + deleteL2Outputs + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctL2OutputOracleCalls::owner) + } + owner + }, + { + fn l2BlockTime( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::l2BlockTime) + } + l2BlockTime + }, + { + fn updateVerifier( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::updateVerifier) + } + updateVerifier + }, + { + fn proposeL2Output_0( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::proposeL2Output_0) + } + proposeL2Output_0 + }, + { + fn historicBlockHashes( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::historicBlockHashes) + } + historicBlockHashes + }, + { + fn getL2Output( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::getL2Output) + } + getL2Output + }, + { + fn proposeL2Output_1( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::proposeL2Output_1) + } + proposeL2Output_1 + }, + { + fn proposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OPSuccinctL2OutputOracleCalls::proposer) + } + proposer + }, + { + fn addProposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::addProposer) + } + addProposer + }, + { + fn aggregationVkey( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::aggregationVkey) + } + aggregationVkey + }, + { + fn finalizationPeriodSeconds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + OPSuccinctL2OutputOracleCalls::finalizationPeriodSeconds, + ) + } + finalizationPeriodSeconds + }, + { + fn getL2OutputAfter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::getL2OutputAfter) + } + getL2OutputAfter + }, + { + fn computeL2Timestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::computeL2Timestamp) + } + computeL2Timestamp + }, + { + fn approvedProposers( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::approvedProposers) + } + approvedProposers + }, + { + fn nextBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::nextBlockNumber) + } + nextBlockNumber + }, + { + fn lastProposalTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::lastProposalTimestamp) + } + lastProposalTimestamp + }, + { + fn submissionInterval( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::submissionInterval) + } + submissionInterval + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::initialize) + } + initialize + }, + { + fn deleteOpSuccinctConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::deleteOpSuccinctConfig) + } + deleteOpSuccinctConfig + }, + { + fn disputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::disputeGameFactory) + } + disputeGameFactory + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::transferOwnership) + } + transferOwnership + }, + { + fn GENESIS_CONFIG_NAME( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::GENESIS_CONFIG_NAME) + } + GENESIS_CONFIG_NAME + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn removeProposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::removeProposer) + } + removeProposer + }, + { + fn checkpointBlockHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::checkpointBlockHash) + } + checkpointBlockHash + }, + { + fn rangeVkeyCommitment( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::rangeVkeyCommitment) + } + rangeVkeyCommitment + }, + { + fn verifier( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::verifier) + } + verifier + }, + { + fn enableOptimisticMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::enableOptimisticMode) + } + enableOptimisticMode + }, + { + fn updateSubmissionInterval( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::updateSubmissionInterval) + } + updateSubmissionInterval + }, + { + fn setDisputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::setDisputeGameFactory) + } + setDisputeGameFactory + }, + { + fn fallbackTimeout( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::fallbackTimeout) + } + fallbackTimeout + }, + { + fn latestBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::latestBlockNumber) + } + latestBlockNumber + }, + { + fn addOpSuccinctConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::addOpSuccinctConfig) + } + addOpSuccinctConfig + }, + { + fn isValidOpSuccinctConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::isValidOpSuccinctConfig) + } + isValidOpSuccinctConfig + }, + { + fn disableOptimisticMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::disableOptimisticMode) + } + disableOptimisticMode + }, + { + fn challenger( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::challenger) + } + challenger + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::version) + } + version + }, + { + fn optimisticMode( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::optimisticMode) + } + optimisticMode + }, + { + fn latestOutputIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::latestOutputIndex) + } + latestOutputIndex + }, + { + fn opSuccinctConfigs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::opSuccinctConfigs) + } + opSuccinctConfigs + }, + { + fn nextOutputIndex( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::nextOutputIndex) + } + nextOutputIndex + }, + { + fn rollupConfigHash( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::rollupConfigHash) + } + rollupConfigHash + }, + { + fn startingBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::startingBlockNumber) + } + startingBlockNumber + }, + { + fn dgfProposeL2Output( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::dgfProposeL2Output) + } + dgfProposeL2Output + }, + { + fn getL2OutputIndexAfter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::getL2OutputIndexAfter) + } + getL2OutputIndexAfter + }, + { + fn initializerVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::initializerVersion) + } + initializerVersion + }, + { + fn startingTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::startingTimestamp) + } + startingTimestamp + }, + { + fn deleteL2Outputs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::deleteL2Outputs) + } + deleteL2Outputs + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::owner) + } + owner + }, + { + fn l2BlockTime( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::l2BlockTime) + } + l2BlockTime + }, + { + fn updateVerifier( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::updateVerifier) + } + updateVerifier + }, + { + fn proposeL2Output_0( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::proposeL2Output_0) + } + proposeL2Output_0 + }, + { + fn historicBlockHashes( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::historicBlockHashes) + } + historicBlockHashes + }, + { + fn getL2Output( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::getL2Output) + } + getL2Output + }, + { + fn proposeL2Output_1( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::proposeL2Output_1) + } + proposeL2Output_1 + }, + { + fn proposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::proposer) + } + proposer + }, + { + fn addProposer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::addProposer) + } + addProposer + }, + { + fn aggregationVkey( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::aggregationVkey) + } + aggregationVkey + }, + { + fn finalizationPeriodSeconds( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + OPSuccinctL2OutputOracleCalls::finalizationPeriodSeconds, + ) + } + finalizationPeriodSeconds + }, + { + fn getL2OutputAfter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::getL2OutputAfter) + } + getL2OutputAfter + }, + { + fn computeL2Timestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::computeL2Timestamp) + } + computeL2Timestamp + }, + { + fn approvedProposers( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::approvedProposers) + } + approvedProposers + }, + { + fn nextBlockNumber( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::nextBlockNumber) + } + nextBlockNumber + }, + { + fn lastProposalTimestamp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::lastProposalTimestamp) + } + lastProposalTimestamp + }, + { + fn submissionInterval( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::submissionInterval) + } + submissionInterval + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::initialize) + } + initialize + }, + { + fn deleteOpSuccinctConfig( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::deleteOpSuccinctConfig) + } + deleteOpSuccinctConfig + }, + { + fn disputeGameFactory( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::disputeGameFactory) + } + disputeGameFactory + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::transferOwnership) + } + transferOwnership + }, + { + fn GENESIS_CONFIG_NAME( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleCalls::GENESIS_CONFIG_NAME) + } + GENESIS_CONFIG_NAME + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::GENESIS_CONFIG_NAME(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::addOpSuccinctConfig(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::addProposer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::aggregationVkey(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::approvedProposers(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::challenger(inner) => { + ::abi_encoded_size(inner) + } + Self::checkpointBlockHash(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::computeL2Timestamp(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::deleteL2Outputs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::deleteOpSuccinctConfig(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::dgfProposeL2Output(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disableOptimisticMode(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::disputeGameFactory(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::enableOptimisticMode(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::fallbackTimeout(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::finalizationPeriodSeconds(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getL2Output(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getL2OutputAfter(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getL2OutputIndexAfter(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::historicBlockHashes(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::initializerVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isValidOpSuccinctConfig(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::l2BlockTime(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::lastProposalTimestamp(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::latestBlockNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::latestOutputIndex(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::nextBlockNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::nextOutputIndex(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::opSuccinctConfigs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::optimisticMode(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::proposeL2Output_0(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::proposeL2Output_1(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::proposer(inner) => { + ::abi_encoded_size(inner) + } + Self::rangeVkeyCommitment(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::removeProposer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::rollupConfigHash(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setDisputeGameFactory(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::startingBlockNumber(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::startingTimestamp(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::submissionInterval(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::updateSubmissionInterval(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::updateVerifier(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::verifier(inner) => { + ::abi_encoded_size(inner) + } + Self::version(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::GENESIS_CONFIG_NAME(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::addOpSuccinctConfig(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::addProposer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::aggregationVkey(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::approvedProposers(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::challenger(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::checkpointBlockHash(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::computeL2Timestamp(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::deleteL2Outputs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::deleteOpSuccinctConfig(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::dgfProposeL2Output(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disableOptimisticMode(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::disputeGameFactory(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::enableOptimisticMode(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::fallbackTimeout(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::finalizationPeriodSeconds(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getL2Output(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getL2OutputAfter(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getL2OutputIndexAfter(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::historicBlockHashes(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initializerVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isValidOpSuccinctConfig(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::l2BlockTime(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::lastProposalTimestamp(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::latestBlockNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::latestOutputIndex(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::nextBlockNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::nextOutputIndex(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::opSuccinctConfigs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::optimisticMode(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::proposeL2Output_0(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proposeL2Output_1(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proposer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::rangeVkeyCommitment(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::removeProposer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::rollupConfigHash(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setDisputeGameFactory(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::startingBlockNumber(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::startingTimestamp(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::submissionInterval(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::updateSubmissionInterval(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::updateVerifier(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::verifier(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::version(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`OPSuccinctL2OutputOracle`](self) custom errors. + #[derive(Clone)] + pub enum OPSuccinctL2OutputOracleErrors { + #[allow(missing_docs)] + L1BlockHashNotAvailable(L1BlockHashNotAvailable), + #[allow(missing_docs)] + L1BlockHashNotCheckpointed(L1BlockHashNotCheckpointed), + } + impl OPSuccinctL2OutputOracleErrors { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [34u8, 170u8, 58u8, 152u8], + [132u8, 192u8, 104u8, 100u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(L1BlockHashNotCheckpointed), + ::core::stringify!(L1BlockHashNotAvailable), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for OPSuccinctL2OutputOracleErrors { + const NAME: &'static str = "OPSuccinctL2OutputOracleErrors"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::L1BlockHashNotAvailable(_) => { + ::SELECTOR + } + Self::L1BlockHashNotCheckpointed(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn L1BlockHashNotCheckpointed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + OPSuccinctL2OutputOracleErrors::L1BlockHashNotCheckpointed, + ) + } + L1BlockHashNotCheckpointed + }, + { + fn L1BlockHashNotAvailable( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OPSuccinctL2OutputOracleErrors::L1BlockHashNotAvailable) + } + L1BlockHashNotAvailable + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn L1BlockHashNotCheckpointed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + OPSuccinctL2OutputOracleErrors::L1BlockHashNotCheckpointed, + ) + } + L1BlockHashNotCheckpointed + }, + { + fn L1BlockHashNotAvailable( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OPSuccinctL2OutputOracleErrors::L1BlockHashNotAvailable) + } + L1BlockHashNotAvailable + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::L1BlockHashNotAvailable(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::L1BlockHashNotCheckpointed(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::L1BlockHashNotAvailable(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::L1BlockHashNotCheckpointed(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`OPSuccinctL2OutputOracle`](self) events. + #[derive(Clone)] + pub enum OPSuccinctL2OutputOracleEvents { + #[allow(missing_docs)] + DisputeGameFactorySet(DisputeGameFactorySet), + #[allow(missing_docs)] + Initialized(Initialized), + #[allow(missing_docs)] + OpSuccinctConfigDeleted(OpSuccinctConfigDeleted), + #[allow(missing_docs)] + OpSuccinctConfigUpdated(OpSuccinctConfigUpdated), + #[allow(missing_docs)] + OptimisticModeToggled(OptimisticModeToggled), + #[allow(missing_docs)] + OutputProposed(OutputProposed), + #[allow(missing_docs)] + OutputsDeleted(OutputsDeleted), + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + #[allow(missing_docs)] + ProposerUpdated(ProposerUpdated), + #[allow(missing_docs)] + SubmissionIntervalUpdated(SubmissionIntervalUpdated), + #[allow(missing_docs)] + VerifierUpdated(VerifierUpdated), + } + impl OPSuccinctL2OutputOracleEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 2u8, 67u8, 84u8, 154u8, 146u8, 178u8, 65u8, 47u8, 122u8, 60u8, 175u8, + 122u8, 46u8, 86u8, 214u8, 91u8, 136u8, 33u8, 185u8, 19u8, 69u8, 54u8, + 63u8, 170u8, 95u8, 87u8, 25u8, 83u8, 132u8, 6u8, 95u8, 204u8, + ], + [ + 31u8, 92u8, 135u8, 47u8, 30u8, 169u8, 60u8, 87u8, 228u8, 49u8, 18u8, + 234u8, 68u8, 158u8, 225u8, 158u8, 245u8, 117u8, 68u8, 136u8, 184u8, + 118u8, 39u8, 180u8, 197u8, 36u8, 86u8, 176u8, 229u8, 164u8, 16u8, 154u8, + ], + [ + 68u8, 50u8, 176u8, 42u8, 47u8, 203u8, 237u8, 72u8, 217u8, 78u8, 141u8, + 114u8, 114u8, 62u8, 21u8, 92u8, 102u8, 144u8, 228u8, 183u8, 243u8, 154u8, + 250u8, 65u8, 162u8, 168u8, 255u8, 140u8, 10u8, 164u8, 37u8, 218u8, + ], + [ + 78u8, 227u8, 122u8, 194u8, 199u8, 134u8, 236u8, 133u8, 232u8, 117u8, + 146u8, 211u8, 197u8, 200u8, 161u8, 221u8, 102u8, 248u8, 73u8, 109u8, + 218u8, 63u8, 18u8, 93u8, 158u8, 168u8, 202u8, 95u8, 101u8, 118u8, 41u8, + 182u8, + ], + [ + 93u8, 243u8, 141u8, 57u8, 94u8, 220u8, 21u8, 182u8, 105u8, 214u8, 70u8, + 86u8, 155u8, 208u8, 21u8, 81u8, 51u8, 149u8, 7u8, 11u8, 91u8, 77u8, + 235u8, 138u8, 22u8, 48u8, 10u8, 187u8, 6u8, 13u8, 27u8, 90u8, + ], + [ + 115u8, 112u8, 33u8, 128u8, 206u8, 52u8, 142u8, 7u8, 176u8, 88u8, 132u8, + 109u8, 23u8, 69u8, 201u8, 153u8, 135u8, 174u8, 108u8, 116u8, 31u8, 249u8, + 126u8, 194u8, 141u8, 69u8, 57u8, 83u8, 14u8, 241u8, 232u8, 241u8, + ], + [ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ], + [ + 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, + 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, + 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + ], + [ + 167u8, 170u8, 242u8, 81u8, 39u8, 105u8, 218u8, 78u8, 68u8, 78u8, 61u8, + 226u8, 71u8, 190u8, 37u8, 100u8, 34u8, 92u8, 46u8, 122u8, 143u8, 116u8, + 207u8, 229u8, 40u8, 228u8, 110u8, 23u8, 210u8, 72u8, 104u8, 226u8, + ], + [ + 193u8, 191u8, 154u8, 191u8, 181u8, 126u8, 160u8, 30u8, 217u8, 236u8, + 180u8, 244u8, 94u8, 156u8, 239u8, 167u8, 186u8, 68u8, 178u8, 230u8, + 119u8, 140u8, 60u8, 231u8, 40u8, 20u8, 9u8, 153u8, 159u8, 26u8, 241u8, + 178u8, + ], + [ + 234u8, 1u8, 35u8, 199u8, 38u8, 166u8, 101u8, 203u8, 10u8, 181u8, 105u8, + 20u8, 68u8, 249u8, 41u8, 167u8, 5u8, 108u8, 122u8, 119u8, 9u8, 198u8, + 12u8, 5u8, 135u8, 130u8, 158u8, 128u8, 70u8, 184u8, 213u8, 20u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(VerifierUpdated), + ::core::stringify!(OptimisticModeToggled), + ::core::stringify!(OpSuccinctConfigDeleted), + ::core::stringify!(OutputsDeleted), + ::core::stringify!(ProposerUpdated), + ::core::stringify!(DisputeGameFactorySet), + ::core::stringify!(Initialized), + ::core::stringify!(OwnershipTransferred), + ::core::stringify!(OutputProposed), + ::core::stringify!(SubmissionIntervalUpdated), + ::core::stringify!(OpSuccinctConfigUpdated), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for OPSuccinctL2OutputOracleEvents { + const NAME: &'static str = "OPSuccinctL2OutputOracleEvents"; + const COUNT: usize = 11usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::DisputeGameFactorySet) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::Initialized) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OpSuccinctConfigDeleted) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OpSuccinctConfigUpdated) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OptimisticModeToggled) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OutputProposed) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OutputsDeleted) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ProposerUpdated) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::SubmissionIntervalUpdated) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::VerifierUpdated) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for OPSuccinctL2OutputOracleEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::DisputeGameFactorySet(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OpSuccinctConfigDeleted(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OpSuccinctConfigUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OptimisticModeToggled(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OutputProposed(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OutputsDeleted(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::ProposerUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::SubmissionIntervalUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::VerifierUpdated(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::DisputeGameFactorySet(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OpSuccinctConfigDeleted(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OpSuccinctConfigUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OptimisticModeToggled(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OutputProposed(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OutputsDeleted(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::ProposerUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::SubmissionIntervalUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::VerifierUpdated(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`OPSuccinctL2OutputOracle`](self) contract instance. + +See the [wrapper's documentation](`OPSuccinctL2OutputOracleInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> OPSuccinctL2OutputOracleInstance { + OPSuccinctL2OutputOracleInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + OPSuccinctL2OutputOracleInstance::::deploy(__provider) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(__provider: P) -> alloy_contract::RawCallBuilder { + OPSuccinctL2OutputOracleInstance::::deploy_builder(__provider) + } + /**A [`OPSuccinctL2OutputOracle`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`OPSuccinctL2OutputOracle`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct OPSuccinctL2OutputOracleInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for OPSuccinctL2OutputOracleInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("OPSuccinctL2OutputOracleInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OPSuccinctL2OutputOracleInstance { + /**Creates a new wrapper around an on-chain [`OPSuccinctL2OutputOracle`](self) contract instance. + +See the [wrapper's documentation](`OPSuccinctL2OutputOracleInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + ::core::clone::Clone::clone(&BYTECODE), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl OPSuccinctL2OutputOracleInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> OPSuccinctL2OutputOracleInstance { + OPSuccinctL2OutputOracleInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OPSuccinctL2OutputOracleInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`GENESIS_CONFIG_NAME`] function. + pub fn GENESIS_CONFIG_NAME( + &self, + ) -> alloy_contract::SolCallBuilder<&P, GENESIS_CONFIG_NAMECall, N> { + self.call_builder(&GENESIS_CONFIG_NAMECall) + } + ///Creates a new call builder for the [`addOpSuccinctConfig`] function. + pub fn addOpSuccinctConfig( + &self, + _configName: alloy::sol_types::private::FixedBytes<32>, + _rollupConfigHash: alloy::sol_types::private::FixedBytes<32>, + _aggregationVkey: alloy::sol_types::private::FixedBytes<32>, + _rangeVkeyCommitment: alloy::sol_types::private::FixedBytes<32>, + ) -> alloy_contract::SolCallBuilder<&P, addOpSuccinctConfigCall, N> { + self.call_builder( + &addOpSuccinctConfigCall { + _configName, + _rollupConfigHash, + _aggregationVkey, + _rangeVkeyCommitment, + }, + ) + } + ///Creates a new call builder for the [`addProposer`] function. + pub fn addProposer( + &self, + _proposer: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, addProposerCall, N> { + self.call_builder(&addProposerCall { _proposer }) + } + ///Creates a new call builder for the [`aggregationVkey`] function. + pub fn aggregationVkey( + &self, + ) -> alloy_contract::SolCallBuilder<&P, aggregationVkeyCall, N> { + self.call_builder(&aggregationVkeyCall) + } + ///Creates a new call builder for the [`approvedProposers`] function. + pub fn approvedProposers( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, approvedProposersCall, N> { + self.call_builder(&approvedProposersCall(_0)) + } + ///Creates a new call builder for the [`challenger`] function. + pub fn challenger( + &self, + ) -> alloy_contract::SolCallBuilder<&P, challengerCall, N> { + self.call_builder(&challengerCall) + } + ///Creates a new call builder for the [`checkpointBlockHash`] function. + pub fn checkpointBlockHash( + &self, + _blockNumber: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, checkpointBlockHashCall, N> { + self.call_builder( + &checkpointBlockHashCall { + _blockNumber, + }, + ) + } + ///Creates a new call builder for the [`computeL2Timestamp`] function. + pub fn computeL2Timestamp( + &self, + _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, computeL2TimestampCall, N> { + self.call_builder( + &computeL2TimestampCall { + _l2BlockNumber, + }, + ) + } + ///Creates a new call builder for the [`deleteL2Outputs`] function. + pub fn deleteL2Outputs( + &self, + _l2OutputIndex: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, deleteL2OutputsCall, N> { + self.call_builder( + &deleteL2OutputsCall { + _l2OutputIndex, + }, + ) + } + ///Creates a new call builder for the [`deleteOpSuccinctConfig`] function. + pub fn deleteOpSuccinctConfig( + &self, + _configName: alloy::sol_types::private::FixedBytes<32>, + ) -> alloy_contract::SolCallBuilder<&P, deleteOpSuccinctConfigCall, N> { + self.call_builder( + &deleteOpSuccinctConfigCall { + _configName, + }, + ) + } + ///Creates a new call builder for the [`dgfProposeL2Output`] function. + pub fn dgfProposeL2Output( + &self, + _configName: alloy::sol_types::private::FixedBytes<32>, + _outputRoot: alloy::sol_types::private::FixedBytes<32>, + _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + _l1BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + _proof: alloy::sol_types::private::Bytes, + _proverAddress: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, dgfProposeL2OutputCall, N> { + self.call_builder( + &dgfProposeL2OutputCall { + _configName, + _outputRoot, + _l2BlockNumber, + _l1BlockNumber, + _proof, + _proverAddress, + }, + ) + } + ///Creates a new call builder for the [`disableOptimisticMode`] function. + pub fn disableOptimisticMode( + &self, + _finalizationPeriodSeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, disableOptimisticModeCall, N> { + self.call_builder( + &disableOptimisticModeCall { + _finalizationPeriodSeconds, + }, + ) + } + ///Creates a new call builder for the [`disputeGameFactory`] function. + pub fn disputeGameFactory( + &self, + ) -> alloy_contract::SolCallBuilder<&P, disputeGameFactoryCall, N> { + self.call_builder(&disputeGameFactoryCall) + } + ///Creates a new call builder for the [`enableOptimisticMode`] function. + pub fn enableOptimisticMode( + &self, + _finalizationPeriodSeconds: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, enableOptimisticModeCall, N> { + self.call_builder( + &enableOptimisticModeCall { + _finalizationPeriodSeconds, + }, + ) + } + ///Creates a new call builder for the [`fallbackTimeout`] function. + pub fn fallbackTimeout( + &self, + ) -> alloy_contract::SolCallBuilder<&P, fallbackTimeoutCall, N> { + self.call_builder(&fallbackTimeoutCall) + } + ///Creates a new call builder for the [`finalizationPeriodSeconds`] function. + pub fn finalizationPeriodSeconds( + &self, + ) -> alloy_contract::SolCallBuilder<&P, finalizationPeriodSecondsCall, N> { + self.call_builder(&finalizationPeriodSecondsCall) + } + ///Creates a new call builder for the [`getL2Output`] function. + pub fn getL2Output( + &self, + _l2OutputIndex: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, getL2OutputCall, N> { + self.call_builder(&getL2OutputCall { _l2OutputIndex }) + } + ///Creates a new call builder for the [`getL2OutputAfter`] function. + pub fn getL2OutputAfter( + &self, + _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, getL2OutputAfterCall, N> { + self.call_builder( + &getL2OutputAfterCall { + _l2BlockNumber, + }, + ) + } + ///Creates a new call builder for the [`getL2OutputIndexAfter`] function. + pub fn getL2OutputIndexAfter( + &self, + _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, getL2OutputIndexAfterCall, N> { + self.call_builder( + &getL2OutputIndexAfterCall { + _l2BlockNumber, + }, + ) + } + ///Creates a new call builder for the [`historicBlockHashes`] function. + pub fn historicBlockHashes( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, historicBlockHashesCall, N> { + self.call_builder(&historicBlockHashesCall(_0)) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + _initParams: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder(&initializeCall { _initParams }) + } + ///Creates a new call builder for the [`initializerVersion`] function. + pub fn initializerVersion( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initializerVersionCall, N> { + self.call_builder(&initializerVersionCall) + } + ///Creates a new call builder for the [`isValidOpSuccinctConfig`] function. + pub fn isValidOpSuccinctConfig( + &self, + _config: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, isValidOpSuccinctConfigCall, N> { + self.call_builder( + &isValidOpSuccinctConfigCall { + _config, + }, + ) + } + ///Creates a new call builder for the [`l2BlockTime`] function. + pub fn l2BlockTime( + &self, + ) -> alloy_contract::SolCallBuilder<&P, l2BlockTimeCall, N> { + self.call_builder(&l2BlockTimeCall) + } + ///Creates a new call builder for the [`lastProposalTimestamp`] function. + pub fn lastProposalTimestamp( + &self, + ) -> alloy_contract::SolCallBuilder<&P, lastProposalTimestampCall, N> { + self.call_builder(&lastProposalTimestampCall) + } + ///Creates a new call builder for the [`latestBlockNumber`] function. + pub fn latestBlockNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, latestBlockNumberCall, N> { + self.call_builder(&latestBlockNumberCall) + } + ///Creates a new call builder for the [`latestOutputIndex`] function. + pub fn latestOutputIndex( + &self, + ) -> alloy_contract::SolCallBuilder<&P, latestOutputIndexCall, N> { + self.call_builder(&latestOutputIndexCall) + } + ///Creates a new call builder for the [`nextBlockNumber`] function. + pub fn nextBlockNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, nextBlockNumberCall, N> { + self.call_builder(&nextBlockNumberCall) + } + ///Creates a new call builder for the [`nextOutputIndex`] function. + pub fn nextOutputIndex( + &self, + ) -> alloy_contract::SolCallBuilder<&P, nextOutputIndexCall, N> { + self.call_builder(&nextOutputIndexCall) + } + ///Creates a new call builder for the [`opSuccinctConfigs`] function. + pub fn opSuccinctConfigs( + &self, + _0: alloy::sol_types::private::FixedBytes<32>, + ) -> alloy_contract::SolCallBuilder<&P, opSuccinctConfigsCall, N> { + self.call_builder(&opSuccinctConfigsCall(_0)) + } + ///Creates a new call builder for the [`optimisticMode`] function. + pub fn optimisticMode( + &self, + ) -> alloy_contract::SolCallBuilder<&P, optimisticModeCall, N> { + self.call_builder(&optimisticModeCall) + } + ///Creates a new call builder for the [`owner`] function. + pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> { + self.call_builder(&ownerCall) + } + ///Creates a new call builder for the [`proposeL2Output_0`] function. + pub fn proposeL2Output_0( + &self, + _outputRoot: alloy::sol_types::private::FixedBytes<32>, + _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + _l1BlockHash: alloy::sol_types::private::FixedBytes<32>, + _l1BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, proposeL2Output_0Call, N> { + self.call_builder( + &proposeL2Output_0Call { + _outputRoot, + _l2BlockNumber, + _l1BlockHash, + _l1BlockNumber, + }, + ) + } + ///Creates a new call builder for the [`proposeL2Output_1`] function. + pub fn proposeL2Output_1( + &self, + _configName: alloy::sol_types::private::FixedBytes<32>, + _outputRoot: alloy::sol_types::private::FixedBytes<32>, + _l2BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + _l1BlockNumber: alloy::sol_types::private::primitives::aliases::U256, + _proof: alloy::sol_types::private::Bytes, + _proverAddress: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, proposeL2Output_1Call, N> { + self.call_builder( + &proposeL2Output_1Call { + _configName, + _outputRoot, + _l2BlockNumber, + _l1BlockNumber, + _proof, + _proverAddress, + }, + ) + } + ///Creates a new call builder for the [`proposer`] function. + pub fn proposer(&self) -> alloy_contract::SolCallBuilder<&P, proposerCall, N> { + self.call_builder(&proposerCall) + } + ///Creates a new call builder for the [`rangeVkeyCommitment`] function. + pub fn rangeVkeyCommitment( + &self, + ) -> alloy_contract::SolCallBuilder<&P, rangeVkeyCommitmentCall, N> { + self.call_builder(&rangeVkeyCommitmentCall) + } + ///Creates a new call builder for the [`removeProposer`] function. + pub fn removeProposer( + &self, + _proposer: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, removeProposerCall, N> { + self.call_builder(&removeProposerCall { _proposer }) + } + ///Creates a new call builder for the [`rollupConfigHash`] function. + pub fn rollupConfigHash( + &self, + ) -> alloy_contract::SolCallBuilder<&P, rollupConfigHashCall, N> { + self.call_builder(&rollupConfigHashCall) + } + ///Creates a new call builder for the [`setDisputeGameFactory`] function. + pub fn setDisputeGameFactory( + &self, + _disputeGameFactory: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, setDisputeGameFactoryCall, N> { + self.call_builder( + &setDisputeGameFactoryCall { + _disputeGameFactory, + }, + ) + } + ///Creates a new call builder for the [`startingBlockNumber`] function. + pub fn startingBlockNumber( + &self, + ) -> alloy_contract::SolCallBuilder<&P, startingBlockNumberCall, N> { + self.call_builder(&startingBlockNumberCall) + } + ///Creates a new call builder for the [`startingTimestamp`] function. + pub fn startingTimestamp( + &self, + ) -> alloy_contract::SolCallBuilder<&P, startingTimestampCall, N> { + self.call_builder(&startingTimestampCall) + } + ///Creates a new call builder for the [`submissionInterval`] function. + pub fn submissionInterval( + &self, + ) -> alloy_contract::SolCallBuilder<&P, submissionIntervalCall, N> { + self.call_builder(&submissionIntervalCall) + } + ///Creates a new call builder for the [`transferOwnership`] function. + pub fn transferOwnership( + &self, + _owner: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> { + self.call_builder(&transferOwnershipCall { _owner }) + } + ///Creates a new call builder for the [`updateSubmissionInterval`] function. + pub fn updateSubmissionInterval( + &self, + _submissionInterval: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, updateSubmissionIntervalCall, N> { + self.call_builder( + &updateSubmissionIntervalCall { + _submissionInterval, + }, + ) + } + ///Creates a new call builder for the [`updateVerifier`] function. + pub fn updateVerifier( + &self, + _verifier: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, updateVerifierCall, N> { + self.call_builder(&updateVerifierCall { _verifier }) + } + ///Creates a new call builder for the [`verifier`] function. + pub fn verifier(&self) -> alloy_contract::SolCallBuilder<&P, verifierCall, N> { + self.call_builder(&verifierCall) + } + ///Creates a new call builder for the [`version`] function. + pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> { + self.call_builder(&versionCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OPSuccinctL2OutputOracleInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`DisputeGameFactorySet`] event. + pub fn DisputeGameFactorySet_filter( + &self, + ) -> alloy_contract::Event<&P, DisputeGameFactorySet, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Initialized`] event. + pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OpSuccinctConfigDeleted`] event. + pub fn OpSuccinctConfigDeleted_filter( + &self, + ) -> alloy_contract::Event<&P, OpSuccinctConfigDeleted, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OpSuccinctConfigUpdated`] event. + pub fn OpSuccinctConfigUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, OpSuccinctConfigUpdated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OptimisticModeToggled`] event. + pub fn OptimisticModeToggled_filter( + &self, + ) -> alloy_contract::Event<&P, OptimisticModeToggled, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OutputProposed`] event. + pub fn OutputProposed_filter( + &self, + ) -> alloy_contract::Event<&P, OutputProposed, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OutputsDeleted`] event. + pub fn OutputsDeleted_filter( + &self, + ) -> alloy_contract::Event<&P, OutputsDeleted, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`ProposerUpdated`] event. + pub fn ProposerUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, ProposerUpdated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`SubmissionIntervalUpdated`] event. + pub fn SubmissionIntervalUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, SubmissionIntervalUpdated, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`VerifierUpdated`] event. + pub fn VerifierUpdated_filter( + &self, + ) -> alloy_contract::Event<&P, VerifierUpdated, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/codegen/sp1_mock_verifier.rs b/bindings/src/codegen/sp1_mock_verifier.rs new file mode 100644 index 000000000..61e8c3955 --- /dev/null +++ b/bindings/src/codegen/sp1_mock_verifier.rs @@ -0,0 +1,572 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SP1MockVerifier { + function verifyProof(bytes32, bytes memory, bytes memory proofBytes) external pure; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "verifyProof", + "inputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "proofBytes", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "pure" + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod SP1MockVerifier { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x608060405234801561001057600080fd5b50610206806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c806341493c6014610030575b600080fd5b61004a6004803603810190610045919061010c565b61004c565b005b600082829050146100605761005f6101a1565b5b5050505050565b600080fd5b600080fd5b6000819050919050565b61008481610071565b811461008f57600080fd5b50565b6000813590506100a18161007b565b92915050565b600080fd5b600080fd5b600080fd5b60008083601f8401126100cc576100cb6100a7565b5b8235905067ffffffffffffffff8111156100e9576100e86100ac565b5b602083019150836001820283011115610105576101046100b1565b5b9250929050565b60008060008060006060868803121561012857610127610067565b5b600061013688828901610092565b955050602086013567ffffffffffffffff8111156101575761015661006c565b5b610163888289016100b6565b9450945050604086013567ffffffffffffffff8111156101865761018561006c565b5b610192888289016100b6565b92509250509295509295909350565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fdfea264697066735822122084bacd4a03346f0973c1e4fe8a1011375baf47128829c4877c084a833578ff3364736f6c634300080f0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[Pa\x02\x06\x80a\0 `\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0+W`\x005`\xE0\x1C\x80cAI<`\x14a\x000W[`\0\x80\xFD[a\0J`\x04\x806\x03\x81\x01\x90a\0E\x91\x90a\x01\x0CV[a\0LV[\0[`\0\x82\x82\x90P\x14a\0`Wa\0_a\x01\xA1V[[PPPPPV[`\0\x80\xFD[`\0\x80\xFD[`\0\x81\x90P\x91\x90PV[a\0\x84\x81a\0qV[\x81\x14a\0\x8FW`\0\x80\xFD[PV[`\0\x815\x90Pa\0\xA1\x81a\0{V[\x92\x91PPV[`\0\x80\xFD[`\0\x80\xFD[`\0\x80\xFD[`\0\x80\x83`\x1F\x84\x01\x12a\0\xCCWa\0\xCBa\0\xA7V[[\x825\x90Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\0\xE9Wa\0\xE8a\0\xACV[[` \x83\x01\x91P\x83`\x01\x82\x02\x83\x01\x11\x15a\x01\x05Wa\x01\x04a\0\xB1V[[\x92P\x92\x90PV[`\0\x80`\0\x80`\0``\x86\x88\x03\x12\x15a\x01(Wa\x01'a\0gV[[`\0a\x016\x88\x82\x89\x01a\0\x92V[\x95PP` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01WWa\x01Va\0lV[[a\x01c\x88\x82\x89\x01a\0\xB6V[\x94P\x94PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\x86Wa\x01\x85a\0lV[[a\x01\x92\x88\x82\x89\x01a\0\xB6V[\x92P\x92PP\x92\x95P\x92\x95\x90\x93PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x01`\x04R`$`\0\xFD\xFE\xA2dipfsX\"\x12 \x84\xBA\xCDJ\x034o\ts\xC1\xE4\xFE\x8A\x10\x117[\xAFG\x12\x88)\xC4\x87|\x08J\x835x\xFF3dsolcC\0\x08\x0F\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x608060405234801561001057600080fd5b506004361061002b5760003560e01c806341493c6014610030575b600080fd5b61004a6004803603810190610045919061010c565b61004c565b005b600082829050146100605761005f6101a1565b5b5050505050565b600080fd5b600080fd5b6000819050919050565b61008481610071565b811461008f57600080fd5b50565b6000813590506100a18161007b565b92915050565b600080fd5b600080fd5b600080fd5b60008083601f8401126100cc576100cb6100a7565b5b8235905067ffffffffffffffff8111156100e9576100e86100ac565b5b602083019150836001820283011115610105576101046100b1565b5b9250929050565b60008060008060006060868803121561012857610127610067565b5b600061013688828901610092565b955050602086013567ffffffffffffffff8111156101575761015661006c565b5b610163888289016100b6565b9450945050604086013567ffffffffffffffff8111156101865761018561006c565b5b610192888289016100b6565b92509250509295509295909350565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fdfea264697066735822122084bacd4a03346f0973c1e4fe8a1011375baf47128829c4877c084a833578ff3364736f6c634300080f0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0+W`\x005`\xE0\x1C\x80cAI<`\x14a\x000W[`\0\x80\xFD[a\0J`\x04\x806\x03\x81\x01\x90a\0E\x91\x90a\x01\x0CV[a\0LV[\0[`\0\x82\x82\x90P\x14a\0`Wa\0_a\x01\xA1V[[PPPPPV[`\0\x80\xFD[`\0\x80\xFD[`\0\x81\x90P\x91\x90PV[a\0\x84\x81a\0qV[\x81\x14a\0\x8FW`\0\x80\xFD[PV[`\0\x815\x90Pa\0\xA1\x81a\0{V[\x92\x91PPV[`\0\x80\xFD[`\0\x80\xFD[`\0\x80\xFD[`\0\x80\x83`\x1F\x84\x01\x12a\0\xCCWa\0\xCBa\0\xA7V[[\x825\x90Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\0\xE9Wa\0\xE8a\0\xACV[[` \x83\x01\x91P\x83`\x01\x82\x02\x83\x01\x11\x15a\x01\x05Wa\x01\x04a\0\xB1V[[\x92P\x92\x90PV[`\0\x80`\0\x80`\0``\x86\x88\x03\x12\x15a\x01(Wa\x01'a\0gV[[`\0a\x016\x88\x82\x89\x01a\0\x92V[\x95PP` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01WWa\x01Va\0lV[[a\x01c\x88\x82\x89\x01a\0\xB6V[\x94P\x94PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\x86Wa\x01\x85a\0lV[[a\x01\x92\x88\x82\x89\x01a\0\xB6V[\x92P\x92PP\x92\x95P\x92\x95\x90\x93PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x01`\x04R`$`\0\xFD\xFE\xA2dipfsX\"\x12 \x84\xBA\xCDJ\x034o\ts\xC1\xE4\xFE\x8A\x10\x117[\xAFG\x12\x88)\xC4\x87|\x08J\x835x\xFF3dsolcC\0\x08\x0F\x003", + ); + /**Function with signature `verifyProof(bytes32,bytes,bytes)` and selector `0x41493c60`. +```solidity +function verifyProof(bytes32, bytes memory, bytes memory proofBytes) external pure; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct verifyProofCall { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _1: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub proofBytes: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`verifyProof(bytes32,bytes,bytes)`](verifyProofCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct verifyProofReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::Bytes, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: verifyProofCall) -> Self { + (value._0, value._1, value.proofBytes) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for verifyProofCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _0: tuple.0, + _1: tuple.1, + proofBytes: tuple.2, + } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: verifyProofReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for verifyProofReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl verifyProofReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for verifyProofCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Bytes, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = verifyProofReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "verifyProof(bytes32,bytes,bytes)"; + const SELECTOR: [u8; 4] = [65u8, 73u8, 60u8, 96u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ::tokenize( + &self._1, + ), + ::tokenize( + &self.proofBytes, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + verifyProofReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`SP1MockVerifier`](self) function calls. + #[derive(Clone)] + pub enum SP1MockVerifierCalls { + #[allow(missing_docs)] + verifyProof(verifyProofCall), + } + impl SP1MockVerifierCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[[65u8, 73u8, 60u8, 96u8]]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(verifyProof), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SP1MockVerifierCalls { + const NAME: &'static str = "SP1MockVerifierCalls"; + const MIN_DATA_LENGTH: usize = 160usize; + const COUNT: usize = 1usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::verifyProof(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn verifyProof( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SP1MockVerifierCalls::verifyProof) + } + verifyProof + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn verifyProof( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SP1MockVerifierCalls::verifyProof) + } + verifyProof + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::verifyProof(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::verifyProof(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SP1MockVerifier`](self) contract instance. + +See the [wrapper's documentation](`SP1MockVerifierInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> SP1MockVerifierInstance { + SP1MockVerifierInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SP1MockVerifierInstance::::deploy(__provider) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(__provider: P) -> alloy_contract::RawCallBuilder { + SP1MockVerifierInstance::::deploy_builder(__provider) + } + /**A [`SP1MockVerifier`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SP1MockVerifier`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct SP1MockVerifierInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SP1MockVerifierInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SP1MockVerifierInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SP1MockVerifierInstance { + /**Creates a new wrapper around an on-chain [`SP1MockVerifier`](self) contract instance. + +See the [wrapper's documentation](`SP1MockVerifierInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + ::core::clone::Clone::clone(&BYTECODE), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl SP1MockVerifierInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SP1MockVerifierInstance { + SP1MockVerifierInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SP1MockVerifierInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`verifyProof`] function. + pub fn verifyProof( + &self, + _0: alloy::sol_types::private::FixedBytes<32>, + _1: alloy::sol_types::private::Bytes, + proofBytes: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, verifyProofCall, N> { + self.call_builder( + &verifyProofCall { + _0, + _1, + proofBytes, + }, + ) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SP1MockVerifierInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/bindings/src/codegen/superchain_config.rs b/bindings/src/codegen/superchain_config.rs new file mode 100644 index 000000000..5d432743f --- /dev/null +++ b/bindings/src/codegen/superchain_config.rs @@ -0,0 +1,5598 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SuperchainConfig { + type UpdateType is uint8; + + error ProxyAdminOwnedBase_NotProxyAdmin(); + error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); + error ProxyAdminOwnedBase_NotProxyAdminOwner(); + error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); + error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); + error ProxyAdminOwnedBase_ProxyAdminNotFound(); + error ReinitializableBase_ZeroInitVersion(); + error SuperchainConfig_AlreadyPaused(address identifier); + error SuperchainConfig_NotAlreadyPaused(address identifier); + error SuperchainConfig_OnlyGuardian(); + + event ConfigUpdate(UpdateType indexed updateType, bytes data); + event Initialized(uint8 version); + event Paused(address identifier); + event Unpaused(address identifier); + + constructor(); + + function expiration(address _identifier) external view returns (uint256); + function extend(address _identifier) external; + function guardian() external view returns (address); + function initVersion() external view returns (uint8); + function initialize(address _guardian) external; + function pausable(address _identifier) external view returns (bool); + function pause(address _identifier) external; + function pauseExpiry() external pure returns (uint256); + function pauseTimestamps(address) external view returns (uint256); + function paused(address _identifier) external view returns (bool); + function paused() external view returns (bool); + function proxyAdmin() external view returns (address); + function proxyAdminOwner() external view returns (address); + function unpause(address _identifier) external; + function version() external view returns (string memory); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "expiration", + "inputs": [ + { + "name": "_identifier", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "extend", + "inputs": [ + { + "name": "_identifier", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "guardian", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initVersion", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [ + { + "name": "_guardian", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "pausable", + "inputs": [ + { + "name": "_identifier", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "pause", + "inputs": [ + { + "name": "_identifier", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "pauseExpiry", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "pauseTimestamps", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "paused", + "inputs": [ + { + "name": "_identifier", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "paused", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdmin", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IProxyAdmin" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proxyAdminOwner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "unpause", + "inputs": [ + { + "name": "_identifier", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "ConfigUpdate", + "inputs": [ + { + "name": "updateType", + "type": "uint8", + "indexed": true, + "internalType": "enum SuperchainConfig.UpdateType" + }, + { + "name": "data", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Initialized", + "inputs": [ + { + "name": "version", + "type": "uint8", + "indexed": false, + "internalType": "uint8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Paused", + "inputs": [ + { + "name": "identifier", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Unpaused", + "inputs": [ + { + "name": "identifier", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdmin", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotResolvedDelegateProxy", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_NotSharedProxyAdminOwner", + "inputs": [] + }, + { + "type": "error", + "name": "ProxyAdminOwnedBase_ProxyAdminNotFound", + "inputs": [] + }, + { + "type": "error", + "name": "ReinitializableBase_ZeroInitVersion", + "inputs": [] + }, + { + "type": "error", + "name": "SuperchainConfig_AlreadyPaused", + "inputs": [ + { + "name": "identifier", + "type": "address", + "internalType": "address" + } + ] + }, + { + "type": "error", + "name": "SuperchainConfig_NotAlreadyPaused", + "inputs": [ + { + "name": "identifier", + "type": "address", + "internalType": "address" + } + ] + }, + { + "type": "error", + "name": "SuperchainConfig_OnlyGuardian", + "inputs": [] + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod SuperchainConfig { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\xA0`@R4\x80\x15b\0\0\x11W`\0\x80\xFD[P`\x02`\0\x81`\xFF\x16\x03b\0\0RW`@Q\x7F\x9B\x01\xAF\xED\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x80`\xFF\x16`\x80\x81`\xFF\x16\x81RPPPb\0\0qb\0\0w` \x1B` \x1CV[b\0\x02\"V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15b\0\0\xCAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01b\0\0\xC1\x90b\0\x01\xC5V[`@Q\x80\x91\x03\x90\xFD[`\xFF\x80\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10\x15b\0\x01V[\x91Pb\0\x01\xBA\x82b\0\x01OV[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Rb\0\x01\xE0\x81b\0\x01\x9EV[\x90P\x91\x90PV[`\0`\xFF\x82\x16\x90P\x91\x90PV[b\0\x01\xFF\x81b\0\x01\xE7V[\x82RPPV[`\0` \x82\x01\x90Pb\0\x02\x1C`\0\x83\x01\x84b\0\x01\xF4V[\x92\x91PPV[`\x80Qa\x12\xA7b\0\x02>`\09`\0a\x04C\x01Ra\x12\xA7`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xF5W`\x005`\xE0\x1C\x80cT\xFDMP\x11a\0\x97W\x80c\x82\0W\x15\x11a\0fW\x80c\x82\0W\x15\x14a\x02\x88W\x80c\xC4\xD6m\xE8\x14a\x02\xA4W\x80c\xDA\xD5D\xE0\x14a\x02\xC0W\x80c\xF1%\xAFk\x14a\x02\xDEWa\0\xF5V[\x80cT\xFDMP\x14a\x02\x14W\x80cW\xB0\x01\xF9\x14a\x022W\x80c\\\x97Z\xBB\x14a\x02NW\x80cv\xA6zQ\x14a\x02lWa\0\xF5V[\x80c2\xDF\xAD\xD9\x11a\0\xD3W\x80c2\xDF\xAD\xD9\x14a\x01\x8AW\x80c8\xD3\x8C\x97\x14a\x01\xBAW\x80c>G\x15\x8C\x14a\x01\xD8W\x80cE*\x93 \x14a\x01\xF6Wa\0\xF5V[\x80c\x04\xDB\xE3\xFE\x14a\0\xFAW\x80c\x0E;m\x1F\x14a\x01*W\x80c.H\x15,\x14a\x01ZW[`\0\x80\xFD[a\x01\x14`\x04\x806\x03\x81\x01\x90a\x01\x0F\x91\x90a\r\xC2V[a\x02\xFCV[`@Qa\x01!\x91\x90a\x0E\x08V[`@Q\x80\x91\x03\x90\xF3[a\x01D`\x04\x806\x03\x81\x01\x90a\x01?\x91\x90a\r\xC2V[a\x03kV[`@Qa\x01Q\x91\x90a\x0E\x08V[`@Q\x80\x91\x03\x90\xF3[a\x01t`\x04\x806\x03\x81\x01\x90a\x01o\x91\x90a\r\xC2V[a\x03\x83V[`@Qa\x01\x81\x91\x90a\x0E>V[`@Q\x80\x91\x03\x90\xF3[a\x01\xA4`\x04\x806\x03\x81\x01\x90a\x01\x9F\x91\x90a\r\xC2V[a\x03\xF4V[`@Qa\x01\xB1\x91\x90a\x0E>V[`@Q\x80\x91\x03\x90\xF3[a\x01\xC2a\x04?V[`@Qa\x01\xCF\x91\x90a\x0EuV[`@Q\x80\x91\x03\x90\xF3[a\x01\xE0a\x04gV[`@Qa\x01\xED\x91\x90a\x0E\xEFV[`@Q\x80\x91\x03\x90\xF3[a\x01\xFEa\x06\xC0V[`@Qa\x02\x0B\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xF3[a\x02\x1Ca\x06\xE6V[`@Qa\x02)\x91\x90a\x0F\xCDV[`@Q\x80\x91\x03\x90\xF3[a\x02L`\x04\x806\x03\x81\x01\x90a\x02G\x91\x90a\r\xC2V[a\x07\x1FV[\0[a\x02Va\x07\xA6V[`@Qa\x02c\x91\x90a\x0E>V[`@Q\x80\x91\x03\x90\xF3[a\x02\x86`\x04\x806\x03\x81\x01\x90a\x02\x81\x91\x90a\r\xC2V[a\x07\xB7V[\0[a\x02\xA2`\x04\x806\x03\x81\x01\x90a\x02\x9D\x91\x90a\r\xC2V[a\x08\xC1V[\0[a\x02\xBE`\x04\x806\x03\x81\x01\x90a\x02\xB9\x91\x90a\r\xC2V[a\t\xCBV[\0[a\x02\xC8a\n\xDCV[`@Qa\x02\xD5\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xF3[a\x02\xE6a\x0BYV[`@Qa\x02\xF3\x91\x90a\x0E\x08V[`@Q\x80\x91\x03\x90\xF3[`\0\x80`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90P`\0\x81\x03a\x03SW`\0\x91PPa\x03fV[bxL\xE0\x81a\x03b\x91\x90a\x10\x1EV[\x91PP[\x91\x90PV[`\x01` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[`\0\x80`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90P`\0\x81\x03a\x03\xDAW`\0\x91PPa\x03\xEFV[bxL\xE0\x81a\x03\xE9\x91\x90a\x10\x1EV[B\x10\x91PP[\x91\x90PV[`\0\x80`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x14\x90P\x91\x90PV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80a\x04\x96\x7F\xB51'hJV\x8B1s\xAE\x13\xB9\xF8\xA6\x01n$>c\xB6\xE8\xEE\x11x\xD6\xA7\x17\x85\x0B]a\x03`\0\x1Ba\x0BdV[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x04\xD5W\x80\x91PPa\x06\xBDV[`\x02`@Q\x80`@\x01`@R\x80`\x1A\x81R` \x01\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0\x81RPQa\x05\x18\x91\x90a\x10tV[\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0`\0\x1C\x17`\0\x1Ba\x05r0`\0`@Q` \x01a\x05W\x92\x91\x90a\x10\xCEV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x0BoV[\x14a\x05\xA9W`@Q\x7FT\xE43\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\x05\xDD0`\x01`@Q` \x01a\x05\xC2\x92\x91\x90a\x10\xCEV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x0BdV[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06\x8BW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06^W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x82\x91\x90a\x11\x0CV[\x92PPPa\x06\xBDV[`@Q\x7F3!D\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x90V[`\0`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F2.4.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[a\x07'a\x0BzV[`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x7F]\xB9\xEE\nI[\xF2\xE6\xFF\x9C\x91\xA7\x83L\x1B\xA4\xFD\xD2D\xA5\xE8\xAANS{\xD3\x8A\xEA\xE4\xB0s\xAA\x81`@Qa\x07\x9B\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xA1PV[`\0a\x07\xB2`\0a\x03\x83V[\x90P\x90V[a\x07\xBFa\x0BzV[`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x14a\x08CW\x80`@Q\x7F\xB7\xD8h\x94\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x08:\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xFD[B`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x7Fb\xE7\x8C\xEA\x01\xBE\xE3 \xCDNB\x02p\xB5\xEAt\0\r\x11\xB0\xC9\xF7GT\xEB\xDB\xFCTK\x05\xA2X\x81`@Qa\x08\xB6\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xA1PV[a\x08\xC9a\x0BzV[`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x03a\tMW\x80`@Q\x7F3[\x86\x95\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\tD\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xFD[B`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x7Fb\xE7\x8C\xEA\x01\xBE\xE3 \xCDNB\x02p\xB5\xEAt\0\r\x11\xB0\xC9\xF7GT\xEB\xDB\xFCTK\x05\xA2X\x81`@Qa\t\xC0\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xA1PV[a\t\xD3a\x04?V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15\x80\x15a\n\x02WP\x80`\xFF\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10[a\nAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\n8\x90a\x11\xABV[`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP`\x01`\0`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPa\n~a\x0C\x03V[a\n\x87\x82a\x0C\xB2V[`\0\x80`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x81`@Qa\n\xD0\x91\x90a\x0EuV[`@Q\x80\x91\x03\x90\xA1PPV[`\0a\n\xE6a\x04gV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B0W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0BT\x91\x90a\x11\x0CV[\x90P\x90V[`\0bxL\xE0\x90P\x90V[`\0\x81T\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[`\0`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x0C\x01W`@Q\x7F\xAF\xBE\x9B\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0C\"a\x04gV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x0CyWP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0C`a\n\xDCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x15a\x0C\xB0W`@Q\x7F\xC4\x05\n&\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[\x80`\0`\x02a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0\x80\x81\x11\x15a\r\x06Wa\r\x05a\x11\xCBV[[\x7F{t7\x89\xCF\xF0\x1D\xAF\xDE\xAEGs\x99%BZ\xAB]\xFD\x02\xD0\xC8\"\x9EJP\x8B\xCD+\x9FB\xBB\x82`@Q` \x01a\r8\x91\x90a\x0F\x19V[`@Q` \x81\x83\x03\x03\x81R\x90`@R`@Qa\rT\x91\x90a\x12OV[`@Q\x80\x91\x03\x90\xA2PV[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\r\x8F\x82a\rdV[\x90P\x91\x90PV[a\r\x9F\x81a\r\x84V[\x81\x14a\r\xAAW`\0\x80\xFD[PV[`\0\x815\x90Pa\r\xBC\x81a\r\x96V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\r\xD8Wa\r\xD7a\r_V[[`\0a\r\xE6\x84\x82\x85\x01a\r\xADV[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\x0E\x02\x81a\r\xEFV[\x82RPPV[`\0` \x82\x01\x90Pa\x0E\x1D`\0\x83\x01\x84a\r\xF9V[\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\x0E8\x81a\x0E#V[\x82RPPV[`\0` \x82\x01\x90Pa\x0ES`\0\x83\x01\x84a\x0E/V[\x92\x91PPV[`\0`\xFF\x82\x16\x90P\x91\x90PV[a\x0Eo\x81a\x0EYV[\x82RPPV[`\0` \x82\x01\x90Pa\x0E\x8A`\0\x83\x01\x84a\x0EfV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[`\0a\x0E\xB5a\x0E\xB0a\x0E\xAB\x84a\rdV[a\x0E\x90V[a\rdV[\x90P\x91\x90PV[`\0a\x0E\xC7\x82a\x0E\x9AV[\x90P\x91\x90PV[`\0a\x0E\xD9\x82a\x0E\xBCV[\x90P\x91\x90PV[a\x0E\xE9\x81a\x0E\xCEV[\x82RPPV[`\0` \x82\x01\x90Pa\x0F\x04`\0\x83\x01\x84a\x0E\xE0V[\x92\x91PPV[a\x0F\x13\x81a\r\x84V[\x82RPPV[`\0` \x82\x01\x90Pa\x0F.`\0\x83\x01\x84a\x0F\nV[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x0FnW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x0FSV[\x83\x81\x11\x15a\x0F}W`\0\x84\x84\x01R[PPPPV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x0F\x9F\x82a\x0F4V[a\x0F\xA9\x81\x85a\x0F?V[\x93Pa\x0F\xB9\x81\x85` \x86\x01a\x0FPV[a\x0F\xC2\x81a\x0F\x83V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x0F\xE7\x81\x84a\x0F\x94V[\x90P\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x11`\x04R`$`\0\xFD[`\0a\x10)\x82a\r\xEFV[\x91Pa\x104\x83a\r\xEFV[\x92P\x82\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x03\x82\x11\x15a\x10iWa\x10ha\x0F\xEFV[[\x82\x82\x01\x90P\x92\x91PPV[`\0a\x10\x7F\x82a\r\xEFV[\x91Pa\x10\x8A\x83a\r\xEFV[\x92P\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x04\x83\x11\x82\x15\x15\x16\x15a\x10\xC3Wa\x10\xC2a\x0F\xEFV[[\x82\x82\x02\x90P\x92\x91PPV[`\0`@\x82\x01\x90Pa\x10\xE3`\0\x83\x01\x85a\x0F\nV[a\x10\xF0` \x83\x01\x84a\r\xF9V[\x93\x92PPPV[`\0\x81Q\x90Pa\x11\x06\x81a\r\x96V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x11\"Wa\x11!a\r_V[[`\0a\x110\x84\x82\x85\x01a\x10\xF7V[\x91PP\x92\x91PPV[\x7FInitializable: contract is alrea`\0\x82\x01R\x7Fdy initialized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a\x11\x95`.\x83a\x0F?V[\x91Pa\x11\xA0\x82a\x119V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x11\xC4\x81a\x11\x88V[\x90P\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`!`\x04R`$`\0\xFD[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0a\x12!\x82a\x11\xFAV[a\x12+\x81\x85a\x12\x05V[\x93Pa\x12;\x81\x85` \x86\x01a\x0FPV[a\x12D\x81a\x0F\x83V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x12i\x81\x84a\x12\x16V[\x90P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xFC\xA2\xEE\xD8\xD7/w\xD9\x9A\xEDd\x08y\x92\x07\x14v\x8E\x80\xA3W\xFE\x0E8\x01@\xF7\xB4\x971v\xBBdsolcC\0\x08\x0F\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + 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 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xF5W`\x005`\xE0\x1C\x80cT\xFDMP\x11a\0\x97W\x80c\x82\0W\x15\x11a\0fW\x80c\x82\0W\x15\x14a\x02\x88W\x80c\xC4\xD6m\xE8\x14a\x02\xA4W\x80c\xDA\xD5D\xE0\x14a\x02\xC0W\x80c\xF1%\xAFk\x14a\x02\xDEWa\0\xF5V[\x80cT\xFDMP\x14a\x02\x14W\x80cW\xB0\x01\xF9\x14a\x022W\x80c\\\x97Z\xBB\x14a\x02NW\x80cv\xA6zQ\x14a\x02lWa\0\xF5V[\x80c2\xDF\xAD\xD9\x11a\0\xD3W\x80c2\xDF\xAD\xD9\x14a\x01\x8AW\x80c8\xD3\x8C\x97\x14a\x01\xBAW\x80c>G\x15\x8C\x14a\x01\xD8W\x80cE*\x93 \x14a\x01\xF6Wa\0\xF5V[\x80c\x04\xDB\xE3\xFE\x14a\0\xFAW\x80c\x0E;m\x1F\x14a\x01*W\x80c.H\x15,\x14a\x01ZW[`\0\x80\xFD[a\x01\x14`\x04\x806\x03\x81\x01\x90a\x01\x0F\x91\x90a\r\xC2V[a\x02\xFCV[`@Qa\x01!\x91\x90a\x0E\x08V[`@Q\x80\x91\x03\x90\xF3[a\x01D`\x04\x806\x03\x81\x01\x90a\x01?\x91\x90a\r\xC2V[a\x03kV[`@Qa\x01Q\x91\x90a\x0E\x08V[`@Q\x80\x91\x03\x90\xF3[a\x01t`\x04\x806\x03\x81\x01\x90a\x01o\x91\x90a\r\xC2V[a\x03\x83V[`@Qa\x01\x81\x91\x90a\x0E>V[`@Q\x80\x91\x03\x90\xF3[a\x01\xA4`\x04\x806\x03\x81\x01\x90a\x01\x9F\x91\x90a\r\xC2V[a\x03\xF4V[`@Qa\x01\xB1\x91\x90a\x0E>V[`@Q\x80\x91\x03\x90\xF3[a\x01\xC2a\x04?V[`@Qa\x01\xCF\x91\x90a\x0EuV[`@Q\x80\x91\x03\x90\xF3[a\x01\xE0a\x04gV[`@Qa\x01\xED\x91\x90a\x0E\xEFV[`@Q\x80\x91\x03\x90\xF3[a\x01\xFEa\x06\xC0V[`@Qa\x02\x0B\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xF3[a\x02\x1Ca\x06\xE6V[`@Qa\x02)\x91\x90a\x0F\xCDV[`@Q\x80\x91\x03\x90\xF3[a\x02L`\x04\x806\x03\x81\x01\x90a\x02G\x91\x90a\r\xC2V[a\x07\x1FV[\0[a\x02Va\x07\xA6V[`@Qa\x02c\x91\x90a\x0E>V[`@Q\x80\x91\x03\x90\xF3[a\x02\x86`\x04\x806\x03\x81\x01\x90a\x02\x81\x91\x90a\r\xC2V[a\x07\xB7V[\0[a\x02\xA2`\x04\x806\x03\x81\x01\x90a\x02\x9D\x91\x90a\r\xC2V[a\x08\xC1V[\0[a\x02\xBE`\x04\x806\x03\x81\x01\x90a\x02\xB9\x91\x90a\r\xC2V[a\t\xCBV[\0[a\x02\xC8a\n\xDCV[`@Qa\x02\xD5\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xF3[a\x02\xE6a\x0BYV[`@Qa\x02\xF3\x91\x90a\x0E\x08V[`@Q\x80\x91\x03\x90\xF3[`\0\x80`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90P`\0\x81\x03a\x03SW`\0\x91PPa\x03fV[bxL\xE0\x81a\x03b\x91\x90a\x10\x1EV[\x91PP[\x91\x90PV[`\x01` R\x80`\0R`@`\0 `\0\x91P\x90PT\x81V[`\0\x80`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x90P`\0\x81\x03a\x03\xDAW`\0\x91PPa\x03\xEFV[bxL\xE0\x81a\x03\xE9\x91\x90a\x10\x1EV[B\x10\x91PP[\x91\x90PV[`\0\x80`\x01`\0\x84s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x14\x90P\x91\x90PV[`\0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90P\x90V[`\0\x80a\x04\x96\x7F\xB51'hJV\x8B1s\xAE\x13\xB9\xF8\xA6\x01n$>c\xB6\xE8\xEE\x11x\xD6\xA7\x17\x85\x0B]a\x03`\0\x1Ba\x0BdV[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x04\xD5W\x80\x91PPa\x06\xBDV[`\x02`@Q\x80`@\x01`@R\x80`\x1A\x81R` \x01\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0\x81RPQa\x05\x18\x91\x90a\x10tV[\x7FOVM_L1CrossDomainMessenger\0\0\0\0\0\0`\0\x1C\x17`\0\x1Ba\x05r0`\0`@Q` \x01a\x05W\x92\x91\x90a\x10\xCEV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x0BoV[\x14a\x05\xA9W`@Q\x7FT\xE43\xCD\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0a\x05\xDD0`\x01`@Q` \x01a\x05\xC2\x92\x91\x90a\x10\xCEV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 a\x0BdV[\x90P`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x06\x8BW\x80s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06^W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x82\x91\x90a\x11\x0CV[\x92PPPa\x06\xBDV[`@Q\x7F3!D\xDB\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x90V[`\0`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7F2.4.0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP\x81V[a\x07'a\x0BzV[`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x7F]\xB9\xEE\nI[\xF2\xE6\xFF\x9C\x91\xA7\x83L\x1B\xA4\xFD\xD2D\xA5\xE8\xAANS{\xD3\x8A\xEA\xE4\xB0s\xAA\x81`@Qa\x07\x9B\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xA1PV[`\0a\x07\xB2`\0a\x03\x83V[\x90P\x90V[a\x07\xBFa\x0BzV[`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x14a\x08CW\x80`@Q\x7F\xB7\xD8h\x94\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\x08:\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xFD[B`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x7Fb\xE7\x8C\xEA\x01\xBE\xE3 \xCDNB\x02p\xB5\xEAt\0\r\x11\xB0\xC9\xF7GT\xEB\xDB\xFCTK\x05\xA2X\x81`@Qa\x08\xB6\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xA1PV[a\x08\xC9a\x0BzV[`\0`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 T\x03a\tMW\x80`@Q\x7F3[\x86\x95\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\tD\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xFD[B`\x01`\0\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R` \x01\x90\x81R` \x01`\0 \x81\x90UP\x7Fb\xE7\x8C\xEA\x01\xBE\xE3 \xCDNB\x02p\xB5\xEAt\0\r\x11\xB0\xC9\xF7GT\xEB\xDB\xFCTK\x05\xA2X\x81`@Qa\t\xC0\x91\x90a\x0F\x19V[`@Q\x80\x91\x03\x90\xA1PV[a\t\xD3a\x04?V[`\0`\x01\x90T\x90a\x01\0\n\x90\x04`\xFF\x16\x15\x80\x15a\n\x02WP\x80`\xFF\x16`\0\x80T\x90a\x01\0\n\x90\x04`\xFF\x16`\xFF\x16\x10[a\nAW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01a\n8\x90a\x11\xABV[`@Q\x80\x91\x03\x90\xFD[\x80`\0\x80a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83`\xFF\x16\x02\x17\x90UP`\x01`\0`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UPa\n~a\x0C\x03V[a\n\x87\x82a\x0C\xB2V[`\0\x80`\x01a\x01\0\n\x81T\x81`\xFF\x02\x19\x16\x90\x83\x15\x15\x02\x17\x90UP\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x81`@Qa\n\xD0\x91\x90a\x0EuV[`@Q\x80\x91\x03\x90\xA1PPV[`\0a\n\xE6a\x04gV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x8D\xA5\xCB[`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B0W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0BT\x91\x90a\x11\x0CV[\x90P\x90V[`\0bxL\xE0\x90P\x90V[`\0\x81T\x90P\x91\x90PV[`\0\x81T\x90P\x91\x90PV[`\0`\x02\x90T\x90a\x01\0\n\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14a\x0C\x01W`@Q\x7F\xAF\xBE\x9B\xC6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0C\"a\x04gV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15\x80\x15a\x0CyWP3s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x0C`a\n\xDCV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x14\x15[\x15a\x0C\xB0W`@Q\x7F\xC4\x05\n&\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[\x80`\0`\x02a\x01\0\n\x81T\x81s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x02\x17\x90UP`\0\x80\x81\x11\x15a\r\x06Wa\r\x05a\x11\xCBV[[\x7F{t7\x89\xCF\xF0\x1D\xAF\xDE\xAEGs\x99%BZ\xAB]\xFD\x02\xD0\xC8\"\x9EJP\x8B\xCD+\x9FB\xBB\x82`@Q` \x01a\r8\x91\x90a\x0F\x19V[`@Q` \x81\x83\x03\x03\x81R\x90`@R`@Qa\rT\x91\x90a\x12OV[`@Q\x80\x91\x03\x90\xA2PV[`\0\x80\xFD[`\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16\x90P\x91\x90PV[`\0a\r\x8F\x82a\rdV[\x90P\x91\x90PV[a\r\x9F\x81a\r\x84V[\x81\x14a\r\xAAW`\0\x80\xFD[PV[`\0\x815\x90Pa\r\xBC\x81a\r\x96V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\r\xD8Wa\r\xD7a\r_V[[`\0a\r\xE6\x84\x82\x85\x01a\r\xADV[\x91PP\x92\x91PPV[`\0\x81\x90P\x91\x90PV[a\x0E\x02\x81a\r\xEFV[\x82RPPV[`\0` \x82\x01\x90Pa\x0E\x1D`\0\x83\x01\x84a\r\xF9V[\x92\x91PPV[`\0\x81\x15\x15\x90P\x91\x90PV[a\x0E8\x81a\x0E#V[\x82RPPV[`\0` \x82\x01\x90Pa\x0ES`\0\x83\x01\x84a\x0E/V[\x92\x91PPV[`\0`\xFF\x82\x16\x90P\x91\x90PV[a\x0Eo\x81a\x0EYV[\x82RPPV[`\0` \x82\x01\x90Pa\x0E\x8A`\0\x83\x01\x84a\x0EfV[\x92\x91PPV[`\0\x81\x90P\x91\x90PV[`\0a\x0E\xB5a\x0E\xB0a\x0E\xAB\x84a\rdV[a\x0E\x90V[a\rdV[\x90P\x91\x90PV[`\0a\x0E\xC7\x82a\x0E\x9AV[\x90P\x91\x90PV[`\0a\x0E\xD9\x82a\x0E\xBCV[\x90P\x91\x90PV[a\x0E\xE9\x81a\x0E\xCEV[\x82RPPV[`\0` \x82\x01\x90Pa\x0F\x04`\0\x83\x01\x84a\x0E\xE0V[\x92\x91PPV[a\x0F\x13\x81a\r\x84V[\x82RPPV[`\0` \x82\x01\x90Pa\x0F.`\0\x83\x01\x84a\x0F\nV[\x92\x91PPV[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0[\x83\x81\x10\x15a\x0FnW\x80\x82\x01Q\x81\x84\x01R` \x81\x01\x90Pa\x0FSV[\x83\x81\x11\x15a\x0F}W`\0\x84\x84\x01R[PPPPV[`\0`\x1F\x19`\x1F\x83\x01\x16\x90P\x91\x90PV[`\0a\x0F\x9F\x82a\x0F4V[a\x0F\xA9\x81\x85a\x0F?V[\x93Pa\x0F\xB9\x81\x85` \x86\x01a\x0FPV[a\x0F\xC2\x81a\x0F\x83V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x0F\xE7\x81\x84a\x0F\x94V[\x90P\x92\x91PPV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`\x11`\x04R`$`\0\xFD[`\0a\x10)\x82a\r\xEFV[\x91Pa\x104\x83a\r\xEFV[\x92P\x82\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x03\x82\x11\x15a\x10iWa\x10ha\x0F\xEFV[[\x82\x82\x01\x90P\x92\x91PPV[`\0a\x10\x7F\x82a\r\xEFV[\x91Pa\x10\x8A\x83a\r\xEFV[\x92P\x81\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x04\x83\x11\x82\x15\x15\x16\x15a\x10\xC3Wa\x10\xC2a\x0F\xEFV[[\x82\x82\x02\x90P\x92\x91PPV[`\0`@\x82\x01\x90Pa\x10\xE3`\0\x83\x01\x85a\x0F\nV[a\x10\xF0` \x83\x01\x84a\r\xF9V[\x93\x92PPPV[`\0\x81Q\x90Pa\x11\x06\x81a\r\x96V[\x92\x91PPV[`\0` \x82\x84\x03\x12\x15a\x11\"Wa\x11!a\r_V[[`\0a\x110\x84\x82\x85\x01a\x10\xF7V[\x91PP\x92\x91PPV[\x7FInitializable: contract is alrea`\0\x82\x01R\x7Fdy initialized\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01RPV[`\0a\x11\x95`.\x83a\x0F?V[\x91Pa\x11\xA0\x82a\x119V[`@\x82\x01\x90P\x91\x90PV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x11\xC4\x81a\x11\x88V[\x90P\x91\x90PV[\x7FNH{q\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\0R`!`\x04R`$`\0\xFD[`\0\x81Q\x90P\x91\x90PV[`\0\x82\x82R` \x82\x01\x90P\x92\x91PPV[`\0a\x12!\x82a\x11\xFAV[a\x12+\x81\x85a\x12\x05V[\x93Pa\x12;\x81\x85` \x86\x01a\x0FPV[a\x12D\x81a\x0F\x83V[\x84\x01\x91PP\x92\x91PPV[`\0` \x82\x01\x90P\x81\x81\x03`\0\x83\x01Ra\x12i\x81\x84a\x12\x16V[\x90P\x92\x91PPV\xFE\xA2dipfsX\"\x12 \xFC\xA2\xEE\xD8\xD7/w\xD9\x9A\xEDd\x08y\x92\x07\x14v\x8E\x80\xA3W\xFE\x0E8\x01@\xF7\xB4\x971v\xBBdsolcC\0\x08\x0F\x003", + ); + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct UpdateType(u8); + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for u8 { + #[inline] + fn stv_to_tokens( + &self, + ) -> as alloy_sol_types::SolType>::Token<'_> { + alloy_sol_types::private::SolTypeValue::< + alloy::sol_types::sol_data::Uint<8>, + >::stv_to_tokens(self) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + as alloy_sol_types::SolType>::tokenize(self) + .0 + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + as alloy_sol_types::SolType>::abi_encoded_size(self) + } + } + impl UpdateType { + /// The Solidity type name. + pub const NAME: &'static str = stringify!(@ name); + /// Convert from the underlying value type. + #[inline] + pub const fn from_underlying(value: u8) -> Self { + Self(value) + } + /// Return the underlying value. + #[inline] + pub const fn into_underlying(self) -> u8 { + self.0 + } + /// Return the single encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode(&self) -> alloy_sol_types::private::Vec { + ::abi_encode(&self.0) + } + /// Return the packed encoding of this value, delegating to the + /// underlying type. + #[inline] + pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec { + ::abi_encode_packed(&self.0) + } + } + #[automatically_derived] + impl From for UpdateType { + fn from(value: u8) -> Self { + Self::from_underlying(value) + } + } + #[automatically_derived] + impl From for u8 { + fn from(value: UpdateType) -> Self { + value.into_underlying() + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for UpdateType { + type RustType = u8; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = Self::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + Self::type_check(token).is_ok() + } + #[inline] + fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { + as alloy_sol_types::SolType>::type_check(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + as alloy_sol_types::SolType>::detokenize(token) + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for UpdateType { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + as alloy_sol_types::EventTopic>::topic_preimage_length(rust) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdmin()` and selector `0xe818dcc3`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdmin(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdmin; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdmin) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdmin { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdmin { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdmin()"; + const SELECTOR: [u8; 4] = [232u8, 24u8, 220u8, 195u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()` and selector `0xc4050a26`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError + for ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [196u8, 5u8, 10u8, 38u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotProxyAdminOwner()` and selector `0x7f12c64b`. +```solidity +error ProxyAdminOwnedBase_NotProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [127u8, 18u8, 198u8, 75u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotResolvedDelegateProxy()` and selector `0x54e433cd`. +```solidity +error ProxyAdminOwnedBase_NotResolvedDelegateProxy(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotResolvedDelegateProxy; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotResolvedDelegateProxy) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotResolvedDelegateProxy { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotResolvedDelegateProxy()"; + const SELECTOR: [u8; 4] = [84u8, 228u8, 51u8, 205u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_NotSharedProxyAdminOwner()` and selector `0x075c4314`. +```solidity +error ProxyAdminOwnedBase_NotSharedProxyAdminOwner(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_NotSharedProxyAdminOwner; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_NotSharedProxyAdminOwner) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_NotSharedProxyAdminOwner { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_NotSharedProxyAdminOwner()"; + const SELECTOR: [u8; 4] = [7u8, 92u8, 67u8, 20u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ProxyAdminOwnedBase_ProxyAdminNotFound()` and selector `0x332144db`. +```solidity +error ProxyAdminOwnedBase_ProxyAdminNotFound(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ProxyAdminOwnedBase_ProxyAdminNotFound; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ProxyAdminOwnedBase_ProxyAdminNotFound) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ProxyAdminOwnedBase_ProxyAdminNotFound { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ProxyAdminOwnedBase_ProxyAdminNotFound { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ProxyAdminOwnedBase_ProxyAdminNotFound()"; + const SELECTOR: [u8; 4] = [51u8, 33u8, 68u8, 219u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `ReinitializableBase_ZeroInitVersion()` and selector `0x9b01afed`. +```solidity +error ReinitializableBase_ZeroInitVersion(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ReinitializableBase_ZeroInitVersion; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ReinitializableBase_ZeroInitVersion) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ReinitializableBase_ZeroInitVersion { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for ReinitializableBase_ZeroInitVersion { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ReinitializableBase_ZeroInitVersion()"; + const SELECTOR: [u8; 4] = [155u8, 1u8, 175u8, 237u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `SuperchainConfig_AlreadyPaused(address)` and selector `0xb7d86894`. +```solidity +error SuperchainConfig_AlreadyPaused(address identifier); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct SuperchainConfig_AlreadyPaused { + #[allow(missing_docs)] + pub identifier: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: SuperchainConfig_AlreadyPaused) -> Self { + (value.identifier,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for SuperchainConfig_AlreadyPaused { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { identifier: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for SuperchainConfig_AlreadyPaused { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "SuperchainConfig_AlreadyPaused(address)"; + const SELECTOR: [u8; 4] = [183u8, 216u8, 104u8, 148u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.identifier, + ), + ) + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `SuperchainConfig_NotAlreadyPaused(address)` and selector `0x335b8695`. +```solidity +error SuperchainConfig_NotAlreadyPaused(address identifier); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct SuperchainConfig_NotAlreadyPaused { + #[allow(missing_docs)] + pub identifier: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: SuperchainConfig_NotAlreadyPaused) -> Self { + (value.identifier,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for SuperchainConfig_NotAlreadyPaused { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { identifier: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for SuperchainConfig_NotAlreadyPaused { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "SuperchainConfig_NotAlreadyPaused(address)"; + const SELECTOR: [u8; 4] = [51u8, 91u8, 134u8, 149u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.identifier, + ), + ) + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Custom error with signature `SuperchainConfig_OnlyGuardian()` and selector `0xafbe9bc6`. +```solidity +error SuperchainConfig_OnlyGuardian(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct SuperchainConfig_OnlyGuardian; + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: SuperchainConfig_OnlyGuardian) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for SuperchainConfig_OnlyGuardian { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + #[automatically_derived] + impl alloy_sol_types::SolError for SuperchainConfig_OnlyGuardian { + type Parameters<'a> = UnderlyingSolTuple<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "SuperchainConfig_OnlyGuardian()"; + const SELECTOR: [u8; 4] = [175u8, 190u8, 155u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Self::new) + } + } + }; + /**Event with signature `ConfigUpdate(uint8,bytes)` and selector `0x7b743789cff01dafdeae47739925425aab5dfd02d0c8229e4a508bcd2b9f42bb`. +```solidity +event ConfigUpdate(UpdateType indexed updateType, bytes data); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct ConfigUpdate { + #[allow(missing_docs)] + pub updateType: ::RustType, + #[allow(missing_docs)] + pub data: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for ConfigUpdate { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>, UpdateType); + const SIGNATURE: &'static str = "ConfigUpdate(uint8,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 123u8, 116u8, 55u8, 137u8, 207u8, 240u8, 29u8, 175u8, 222u8, 174u8, 71u8, + 115u8, 153u8, 37u8, 66u8, 90u8, 171u8, 93u8, 253u8, 2u8, 208u8, 200u8, + 34u8, 158u8, 74u8, 80u8, 139u8, 205u8, 43u8, 159u8, 66u8, 187u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + updateType: topics.1, + data: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.data, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.updateType.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.updateType, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for ConfigUpdate { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ConfigUpdate> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &ConfigUpdate) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`. +```solidity +event Initialized(uint8 version); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Initialized { + #[allow(missing_docs)] + pub version: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Initialized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Initialized(uint8)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { version: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Initialized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Initialized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Initialized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Paused(address)` and selector `0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258`. +```solidity +event Paused(address identifier); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Paused { + #[allow(missing_docs)] + pub identifier: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Paused { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Paused(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 98u8, 231u8, 140u8, 234u8, 1u8, 190u8, 227u8, 32u8, 205u8, 78u8, 66u8, + 2u8, 112u8, 181u8, 234u8, 116u8, 0u8, 13u8, 17u8, 176u8, 201u8, 247u8, + 71u8, 84u8, 235u8, 219u8, 252u8, 84u8, 75u8, 5u8, 162u8, 88u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { identifier: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.identifier, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Paused { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Paused> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Paused) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Event with signature `Unpaused(address)` and selector `0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa`. +```solidity +event Unpaused(address identifier); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Unpaused { + #[allow(missing_docs)] + pub identifier: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Unpaused { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Unpaused(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 185u8, 238u8, 10u8, 73u8, 91u8, 242u8, 230u8, 255u8, 156u8, 145u8, + 167u8, 131u8, 76u8, 27u8, 164u8, 253u8, 210u8, 68u8, 165u8, 232u8, 170u8, + 78u8, 83u8, 123u8, 211u8, 138u8, 234u8, 228u8, 176u8, 115u8, 170u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { identifier: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.identifier, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(),) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for Unpaused { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Unpaused> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Unpaused) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall {} + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + } + }; + /**Function with signature `expiration(address)` and selector `0x04dbe3fe`. +```solidity +function expiration(address _identifier) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct expirationCall { + #[allow(missing_docs)] + pub _identifier: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`expiration(address)`](expirationCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct expirationReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: expirationCall) -> Self { + (value._identifier,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for expirationCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _identifier: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: expirationReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for expirationReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for expirationCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "expiration(address)"; + const SELECTOR: [u8; 4] = [4u8, 219u8, 227u8, 254u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._identifier, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: expirationReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: expirationReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `extend(address)` and selector `0x82005715`. +```solidity +function extend(address _identifier) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extendCall { + #[allow(missing_docs)] + pub _identifier: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`extend(address)`](extendCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct extendReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extendCall) -> Self { + (value._identifier,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extendCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _identifier: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: extendReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for extendReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl extendReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for extendCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = extendReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "extend(address)"; + const SELECTOR: [u8; 4] = [130u8, 0u8, 87u8, 21u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._identifier, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + extendReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `guardian()` and selector `0x452a9320`. +```solidity +function guardian() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct guardianCall; + ///Container type for the return parameters of the [`guardian()`](guardianCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct guardianReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: guardianCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for guardianCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: guardianReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for guardianReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for guardianCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "guardian()"; + const SELECTOR: [u8; 4] = [69u8, 42u8, 147u8, 32u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: guardianReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: guardianReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initVersion()` and selector `0x38d38c97`. +```solidity +function initVersion() external view returns (uint8); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionCall; + ///Container type for the return parameters of the [`initVersion()`](initVersionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initVersionReturn { + #[allow(missing_docs)] + pub _0: u8, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u8,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initVersionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initVersionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initVersionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initVersion()"; + const SELECTOR: [u8; 4] = [56u8, 211u8, 140u8, 151u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: initVersionReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `initialize(address)` and selector `0xc4d66de8`. +```solidity +function initialize(address _guardian) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeCall { + #[allow(missing_docs)] + pub _guardian: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`initialize(address)`](initializeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct initializeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeCall) -> Self { + (value._guardian,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _guardian: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: initializeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for initializeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl initializeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for initializeCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = initializeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "initialize(address)"; + const SELECTOR: [u8; 4] = [196u8, 214u8, 109u8, 232u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._guardian, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + initializeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `pausable(address)` and selector `0x32dfadd9`. +```solidity +function pausable(address _identifier) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pausableCall { + #[allow(missing_docs)] + pub _identifier: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`pausable(address)`](pausableCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pausableReturn { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pausableCall) -> Self { + (value._identifier,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pausableCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _identifier: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pausableReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pausableReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pausableCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pausable(address)"; + const SELECTOR: [u8; 4] = [50u8, 223u8, 173u8, 217u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._identifier, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: pausableReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: pausableReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `pause(address)` and selector `0x76a67a51`. +```solidity +function pause(address _identifier) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pauseCall { + #[allow(missing_docs)] + pub _identifier: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`pause(address)`](pauseCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pauseReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pauseCall) -> Self { + (value._identifier,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pauseCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _identifier: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pauseReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pauseReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl pauseReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pauseCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = pauseReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pause(address)"; + const SELECTOR: [u8; 4] = [118u8, 166u8, 122u8, 81u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._identifier, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + pauseReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `pauseExpiry()` and selector `0xf125af6b`. +```solidity +function pauseExpiry() external pure returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pauseExpiryCall; + ///Container type for the return parameters of the [`pauseExpiry()`](pauseExpiryCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pauseExpiryReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pauseExpiryCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pauseExpiryCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pauseExpiryReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pauseExpiryReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pauseExpiryCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pauseExpiry()"; + const SELECTOR: [u8; 4] = [241u8, 37u8, 175u8, 107u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: pauseExpiryReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: pauseExpiryReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `pauseTimestamps(address)` and selector `0x0e3b6d1f`. +```solidity +function pauseTimestamps(address) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pauseTimestampsCall(pub alloy::sol_types::private::Address); + ///Container type for the return parameters of the [`pauseTimestamps(address)`](pauseTimestampsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pauseTimestampsReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pauseTimestampsCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pauseTimestampsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: pauseTimestampsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for pauseTimestampsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pauseTimestampsCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pauseTimestamps(address)"; + const SELECTOR: [u8; 4] = [14u8, 59u8, 109u8, 31u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: pauseTimestampsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: pauseTimestampsReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `paused(address)` and selector `0x2e48152c`. +```solidity +function paused(address _identifier) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct paused_0Call { + #[allow(missing_docs)] + pub _identifier: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`paused(address)`](paused_0Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct paused_0Return { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: paused_0Call) -> Self { + (value._identifier,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for paused_0Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _identifier: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: paused_0Return) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for paused_0Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for paused_0Call { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "paused(address)"; + const SELECTOR: [u8; 4] = [46u8, 72u8, 21u8, 44u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._identifier, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: paused_0Return = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: paused_0Return = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `paused()` and selector `0x5c975abb`. +```solidity +function paused() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct paused_1Call; + ///Container type for the return parameters of the [`paused()`](paused_1Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct paused_1Return { + #[allow(missing_docs)] + pub _0: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: paused_1Call) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for paused_1Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: paused_1Return) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for paused_1Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for paused_1Call { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "paused()"; + const SELECTOR: [u8; 4] = [92u8, 151u8, 90u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: paused_1Return = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: paused_1Return = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdmin()` and selector `0x3e47158c`. +```solidity +function proxyAdmin() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminCall; + ///Container type for the return parameters of the [`proxyAdmin()`](proxyAdminCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdmin()"; + const SELECTOR: [u8; 4] = [62u8, 71u8, 21u8, 140u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `proxyAdminOwner()` and selector `0xdad544e0`. +```solidity +function proxyAdminOwner() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerCall; + ///Container type for the return parameters of the [`proxyAdminOwner()`](proxyAdminOwnerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proxyAdminOwnerReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proxyAdminOwnerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proxyAdminOwnerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proxyAdminOwnerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proxyAdminOwnerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proxyAdminOwner()"; + const SELECTOR: [u8; 4] = [218u8, 213u8, 68u8, 224u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proxyAdminOwnerReturn = r.into(); + r._0 + }) + } + } + }; + /**Function with signature `unpause(address)` and selector `0x57b001f9`. +```solidity +function unpause(address _identifier) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct unpauseCall { + #[allow(missing_docs)] + pub _identifier: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`unpause(address)`](unpauseCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct unpauseReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: unpauseCall) -> Self { + (value._identifier,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for unpauseCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _identifier: tuple.0 } + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: unpauseReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for unpauseReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl unpauseReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for unpauseCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = unpauseReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "unpause(address)"; + const SELECTOR: [u8; 4] = [87u8, 176u8, 1u8, 249u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._identifier, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + unpauseReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + /**Function with signature `version()` and selector `0x54fd4d50`. +```solidity +function version() external view returns (string memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionCall; + ///Container type for the return parameters of the [`version()`](versionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct versionReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + #[allow(dead_code)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: versionReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for versionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for versionCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "version()"; + const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: versionReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`SuperchainConfig`](self) function calls. + #[derive(Clone)] + pub enum SuperchainConfigCalls { + #[allow(missing_docs)] + expiration(expirationCall), + #[allow(missing_docs)] + extend(extendCall), + #[allow(missing_docs)] + guardian(guardianCall), + #[allow(missing_docs)] + initVersion(initVersionCall), + #[allow(missing_docs)] + initialize(initializeCall), + #[allow(missing_docs)] + pausable(pausableCall), + #[allow(missing_docs)] + pause(pauseCall), + #[allow(missing_docs)] + pauseExpiry(pauseExpiryCall), + #[allow(missing_docs)] + pauseTimestamps(pauseTimestampsCall), + #[allow(missing_docs)] + paused_0(paused_0Call), + #[allow(missing_docs)] + paused_1(paused_1Call), + #[allow(missing_docs)] + proxyAdmin(proxyAdminCall), + #[allow(missing_docs)] + proxyAdminOwner(proxyAdminOwnerCall), + #[allow(missing_docs)] + unpause(unpauseCall), + #[allow(missing_docs)] + version(versionCall), + } + impl SuperchainConfigCalls { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [4u8, 219u8, 227u8, 254u8], + [14u8, 59u8, 109u8, 31u8], + [46u8, 72u8, 21u8, 44u8], + [50u8, 223u8, 173u8, 217u8], + [56u8, 211u8, 140u8, 151u8], + [62u8, 71u8, 21u8, 140u8], + [69u8, 42u8, 147u8, 32u8], + [84u8, 253u8, 77u8, 80u8], + [87u8, 176u8, 1u8, 249u8], + [92u8, 151u8, 90u8, 187u8], + [118u8, 166u8, 122u8, 81u8], + [130u8, 0u8, 87u8, 21u8], + [196u8, 214u8, 109u8, 232u8], + [218u8, 213u8, 68u8, 224u8], + [241u8, 37u8, 175u8, 107u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(expiration), + ::core::stringify!(pauseTimestamps), + ::core::stringify!(paused_0), + ::core::stringify!(pausable), + ::core::stringify!(initVersion), + ::core::stringify!(proxyAdmin), + ::core::stringify!(guardian), + ::core::stringify!(version), + ::core::stringify!(unpause), + ::core::stringify!(paused_1), + ::core::stringify!(pause), + ::core::stringify!(extend), + ::core::stringify!(initialize), + ::core::stringify!(proxyAdminOwner), + ::core::stringify!(pauseExpiry), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SuperchainConfigCalls { + const NAME: &'static str = "SuperchainConfigCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 15usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::expiration(_) => { + ::SELECTOR + } + Self::extend(_) => ::SELECTOR, + Self::guardian(_) => ::SELECTOR, + Self::initVersion(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } + Self::pausable(_) => ::SELECTOR, + Self::pause(_) => ::SELECTOR, + Self::pauseExpiry(_) => { + ::SELECTOR + } + Self::pauseTimestamps(_) => { + ::SELECTOR + } + Self::paused_0(_) => ::SELECTOR, + Self::paused_1(_) => ::SELECTOR, + Self::proxyAdmin(_) => { + ::SELECTOR + } + Self::proxyAdminOwner(_) => { + ::SELECTOR + } + Self::unpause(_) => ::SELECTOR, + Self::version(_) => ::SELECTOR, + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn expiration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SuperchainConfigCalls::expiration) + } + expiration + }, + { + fn pauseTimestamps( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SuperchainConfigCalls::pauseTimestamps) + } + pauseTimestamps + }, + { + fn paused_0( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SuperchainConfigCalls::paused_0) + } + paused_0 + }, + { + fn pausable( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SuperchainConfigCalls::pausable) + } + pausable + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SuperchainConfigCalls::initVersion) + } + initVersion + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SuperchainConfigCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn guardian( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SuperchainConfigCalls::guardian) + } + guardian + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SuperchainConfigCalls::version) + } + version + }, + { + fn unpause( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SuperchainConfigCalls::unpause) + } + unpause + }, + { + fn paused_1( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SuperchainConfigCalls::paused_1) + } + paused_1 + }, + { + fn pause( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SuperchainConfigCalls::pause) + } + pause + }, + { + fn extend( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SuperchainConfigCalls::extend) + } + extend + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SuperchainConfigCalls::initialize) + } + initialize + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SuperchainConfigCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn pauseExpiry( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SuperchainConfigCalls::pauseExpiry) + } + pauseExpiry + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn expiration( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::expiration) + } + expiration + }, + { + fn pauseTimestamps( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::pauseTimestamps) + } + pauseTimestamps + }, + { + fn paused_0( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::paused_0) + } + paused_0 + }, + { + fn pausable( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::pausable) + } + pausable + }, + { + fn initVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::initVersion) + } + initVersion + }, + { + fn proxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::proxyAdmin) + } + proxyAdmin + }, + { + fn guardian( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::guardian) + } + guardian + }, + { + fn version( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::version) + } + version + }, + { + fn unpause( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::unpause) + } + unpause + }, + { + fn paused_1( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::paused_1) + } + paused_1 + }, + { + fn pause( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::pause) + } + pause + }, + { + fn extend( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::extend) + } + extend + }, + { + fn initialize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::initialize) + } + initialize + }, + { + fn proxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::proxyAdminOwner) + } + proxyAdminOwner + }, + { + fn pauseExpiry( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigCalls::pauseExpiry) + } + pauseExpiry + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::expiration(inner) => { + ::abi_encoded_size(inner) + } + Self::extend(inner) => { + ::abi_encoded_size(inner) + } + Self::guardian(inner) => { + ::abi_encoded_size(inner) + } + Self::initVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::initialize(inner) => { + ::abi_encoded_size(inner) + } + Self::pausable(inner) => { + ::abi_encoded_size(inner) + } + Self::pause(inner) => { + ::abi_encoded_size(inner) + } + Self::pauseExpiry(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::pauseTimestamps(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::paused_0(inner) => { + ::abi_encoded_size(inner) + } + Self::paused_1(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdmin(inner) => { + ::abi_encoded_size(inner) + } + Self::proxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::unpause(inner) => { + ::abi_encoded_size(inner) + } + Self::version(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::expiration(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::extend(inner) => { + ::abi_encode_raw(inner, out) + } + Self::guardian(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::initialize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::pausable(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::pause(inner) => { + ::abi_encode_raw(inner, out) + } + Self::pauseExpiry(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::pauseTimestamps(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::paused_0(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::paused_1(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::unpause(inner) => { + ::abi_encode_raw(inner, out) + } + Self::version(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`SuperchainConfig`](self) custom errors. + #[derive(Clone)] + pub enum SuperchainConfigErrors { + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdmin(ProxyAdminOwnedBase_NotProxyAdmin), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotProxyAdminOwner(ProxyAdminOwnedBase_NotProxyAdminOwner), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotResolvedDelegateProxy( + ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ), + #[allow(missing_docs)] + ProxyAdminOwnedBase_ProxyAdminNotFound(ProxyAdminOwnedBase_ProxyAdminNotFound), + #[allow(missing_docs)] + ReinitializableBase_ZeroInitVersion(ReinitializableBase_ZeroInitVersion), + #[allow(missing_docs)] + SuperchainConfig_AlreadyPaused(SuperchainConfig_AlreadyPaused), + #[allow(missing_docs)] + SuperchainConfig_NotAlreadyPaused(SuperchainConfig_NotAlreadyPaused), + #[allow(missing_docs)] + SuperchainConfig_OnlyGuardian(SuperchainConfig_OnlyGuardian), + } + impl SuperchainConfigErrors { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 4usize]] = &[ + [7u8, 92u8, 67u8, 20u8], + [51u8, 33u8, 68u8, 219u8], + [51u8, 91u8, 134u8, 149u8], + [84u8, 228u8, 51u8, 205u8], + [127u8, 18u8, 198u8, 75u8], + [155u8, 1u8, 175u8, 237u8], + [175u8, 190u8, 155u8, 198u8], + [183u8, 216u8, 104u8, 148u8], + [196u8, 5u8, 10u8, 38u8], + [232u8, 24u8, 220u8, 195u8], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(ProxyAdminOwnedBase_NotSharedProxyAdminOwner), + ::core::stringify!(ProxyAdminOwnedBase_ProxyAdminNotFound), + ::core::stringify!(SuperchainConfig_NotAlreadyPaused), + ::core::stringify!(ProxyAdminOwnedBase_NotResolvedDelegateProxy), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOwner), + ::core::stringify!(ReinitializableBase_ZeroInitVersion), + ::core::stringify!(SuperchainConfig_OnlyGuardian), + ::core::stringify!(SuperchainConfig_AlreadyPaused), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner), + ::core::stringify!(ProxyAdminOwnedBase_NotProxyAdmin), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 4usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SuperchainConfigErrors { + const NAME: &'static str = "SuperchainConfigErrors"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 10usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::ProxyAdminOwnedBase_NotProxyAdmin(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(_) => { + ::SELECTOR + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(_) => { + ::SELECTOR + } + Self::ReinitializableBase_ZeroInitVersion(_) => { + ::SELECTOR + } + Self::SuperchainConfig_AlreadyPaused(_) => { + ::SELECTOR + } + Self::SuperchainConfig_NotAlreadyPaused(_) => { + ::SELECTOR + } + Self::SuperchainConfig_OnlyGuardian(_) => { + ::SELECTOR + } + } + } + #[inline] + fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> { + Self::SELECTORS.get(i).copied() + } + #[inline] + fn valid_selector(selector: [u8; 4]) -> bool { + Self::SELECTORS.binary_search(&selector).is_ok() + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn SuperchainConfig_NotAlreadyPaused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SuperchainConfigErrors::SuperchainConfig_NotAlreadyPaused, + ) + } + SuperchainConfig_NotAlreadyPaused + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SuperchainConfigErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn SuperchainConfig_OnlyGuardian( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SuperchainConfigErrors::SuperchainConfig_OnlyGuardian) + } + SuperchainConfig_OnlyGuardian + }, + { + fn SuperchainConfig_AlreadyPaused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SuperchainConfigErrors::SuperchainConfig_AlreadyPaused) + } + SuperchainConfig_AlreadyPaused + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_SHIMS[idx](data) + } + #[inline] + #[allow(non_snake_case)] + fn abi_decode_raw_validate( + selector: [u8; 4], + data: &[u8], + ) -> alloy_sol_types::Result { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn ProxyAdminOwnedBase_NotSharedProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotSharedProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotSharedProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_ProxyAdminNotFound( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_ProxyAdminNotFound, + ) + } + ProxyAdminOwnedBase_ProxyAdminNotFound + }, + { + fn SuperchainConfig_NotAlreadyPaused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SuperchainConfigErrors::SuperchainConfig_NotAlreadyPaused, + ) + } + SuperchainConfig_NotAlreadyPaused + }, + { + fn ProxyAdminOwnedBase_NotResolvedDelegateProxy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotResolvedDelegateProxy, + ) + } + ProxyAdminOwnedBase_NotResolvedDelegateProxy + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOwner + }, + { + fn ReinitializableBase_ZeroInitVersion( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SuperchainConfigErrors::ReinitializableBase_ZeroInitVersion, + ) + } + ReinitializableBase_ZeroInitVersion + }, + { + fn SuperchainConfig_OnlyGuardian( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigErrors::SuperchainConfig_OnlyGuardian) + } + SuperchainConfig_OnlyGuardian + }, + { + fn SuperchainConfig_AlreadyPaused( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SuperchainConfigErrors::SuperchainConfig_AlreadyPaused) + } + SuperchainConfig_AlreadyPaused + }, + { + fn ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner, + ) + } + ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner + }, + { + fn ProxyAdminOwnedBase_NotProxyAdmin( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SuperchainConfigErrors::ProxyAdminOwnedBase_NotProxyAdmin, + ) + } + ProxyAdminOwnedBase_NotProxyAdmin + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::SuperchainConfig_AlreadyPaused(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::SuperchainConfig_NotAlreadyPaused(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::SuperchainConfig_OnlyGuardian(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::ProxyAdminOwnedBase_NotProxyAdmin(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotResolvedDelegateProxy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_NotSharedProxyAdminOwner(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ProxyAdminOwnedBase_ProxyAdminNotFound(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ReinitializableBase_ZeroInitVersion(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::SuperchainConfig_AlreadyPaused(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::SuperchainConfig_NotAlreadyPaused(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::SuperchainConfig_OnlyGuardian(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`SuperchainConfig`](self) events. + #[derive(Clone)] + pub enum SuperchainConfigEvents { + #[allow(missing_docs)] + ConfigUpdate(ConfigUpdate), + #[allow(missing_docs)] + Initialized(Initialized), + #[allow(missing_docs)] + Paused(Paused), + #[allow(missing_docs)] + Unpaused(Unpaused), + } + impl SuperchainConfigEvents { + /// All the selectors of this enum. + /// + /// Note that the selectors might not be in the same order as the variants. + /// No guarantees are made about the order of the selectors. + /// + /// Prefer using `SolInterface` methods instead. + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 93u8, 185u8, 238u8, 10u8, 73u8, 91u8, 242u8, 230u8, 255u8, 156u8, 145u8, + 167u8, 131u8, 76u8, 27u8, 164u8, 253u8, 210u8, 68u8, 165u8, 232u8, 170u8, + 78u8, 83u8, 123u8, 211u8, 138u8, 234u8, 228u8, 176u8, 115u8, 170u8, + ], + [ + 98u8, 231u8, 140u8, 234u8, 1u8, 190u8, 227u8, 32u8, 205u8, 78u8, 66u8, + 2u8, 112u8, 181u8, 234u8, 116u8, 0u8, 13u8, 17u8, 176u8, 201u8, 247u8, + 71u8, 84u8, 235u8, 219u8, 252u8, 84u8, 75u8, 5u8, 162u8, 88u8, + ], + [ + 123u8, 116u8, 55u8, 137u8, 207u8, 240u8, 29u8, 175u8, 222u8, 174u8, 71u8, + 115u8, 153u8, 37u8, 66u8, 90u8, 171u8, 93u8, 253u8, 2u8, 208u8, 200u8, + 34u8, 158u8, 74u8, 80u8, 139u8, 205u8, 43u8, 159u8, 66u8, 187u8, + ], + [ + 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, + 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, + 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8, + ], + ]; + /// The names of the variants in the same order as `SELECTORS`. + pub const VARIANT_NAMES: &'static [&'static str] = &[ + ::core::stringify!(Unpaused), + ::core::stringify!(Paused), + ::core::stringify!(ConfigUpdate), + ::core::stringify!(Initialized), + ]; + /// The signatures in the same order as `SELECTORS`. + pub const SIGNATURES: &'static [&'static str] = &[ + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ::SIGNATURE, + ]; + /// Returns the signature for the given selector, if known. + #[inline] + pub fn signature_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + match Self::SELECTORS.binary_search(&selector) { + ::core::result::Result::Ok(idx) => { + ::core::option::Option::Some(Self::SIGNATURES[idx]) + } + ::core::result::Result::Err(_) => ::core::option::Option::None, + } + } + /// Returns the enum variant name for the given selector, if known. + #[inline] + pub fn name_by_selector( + selector: [u8; 32usize], + ) -> ::core::option::Option<&'static str> { + let sig = Self::signature_by_selector(selector)?; + sig.split_once('(').map(|(name, _)| name) + } + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for SuperchainConfigEvents { + const NAME: &'static str = "SuperchainConfigEvents"; + const COUNT: usize = 4usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ConfigUpdate) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::Initialized) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Paused) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Unpaused) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), + ), + }) + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for SuperchainConfigEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::ConfigUpdate(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Paused(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Unpaused(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::ConfigUpdate(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Initialized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Paused(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Unpaused(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SuperchainConfig`](self) contract instance. + +See the [wrapper's documentation](`SuperchainConfigInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> SuperchainConfigInstance { + SuperchainConfigInstance::::new(address, __provider) + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub fn deploy< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + __provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SuperchainConfigInstance::::deploy(__provider) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(__provider: P) -> alloy_contract::RawCallBuilder { + SuperchainConfigInstance::::deploy_builder(__provider) + } + /**A [`SuperchainConfig`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SuperchainConfig`](self) contract located at a given `address`, using a given +provider `P`. + +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. + +See the [module-level documentation](self) for all the available methods.*/ + #[derive(Clone)] + pub struct SuperchainConfigInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SuperchainConfigInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SuperchainConfigInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SuperchainConfigInstance { + /**Creates a new wrapper around an on-chain [`SuperchainConfig`](self) contract instance. + +See the [wrapper's documentation](`SuperchainConfigInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + __provider: P, + ) -> Self { + Self { + address, + provider: __provider, + _network: ::core::marker::PhantomData, + } + } + /**Deploys this contract using the given `provider` and constructor arguments, if any. + +Returns a new instance of the contract, if the deployment was successful. + +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ + #[inline] + pub async fn deploy( + __provider: P, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(__provider); + let contract_address = call_builder.deploy().await?; + Ok(Self::new(contract_address, call_builder.provider)) + } + /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` +and constructor arguments, if any. + +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ + #[inline] + pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + __provider, + ::core::clone::Clone::clone(&BYTECODE), + ) + } + /// Returns a reference to the address. + #[inline] + pub const fn address(&self) -> &alloy_sol_types::private::Address { + &self.address + } + /// Sets the address. + #[inline] + pub fn set_address(&mut self, address: alloy_sol_types::private::Address) { + self.address = address; + } + /// Sets the address and returns `self`. + pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self { + self.set_address(address); + self + } + /// Returns a reference to the provider. + #[inline] + pub const fn provider(&self) -> &P { + &self.provider + } + } + impl SuperchainConfigInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SuperchainConfigInstance { + SuperchainConfigInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SuperchainConfigInstance { + /// Creates a new call builder using this contract instance's provider and address. + /// + /// Note that the call can be any function call, not just those defined in this + /// contract. Prefer using the other methods for building type-safe contract calls. + pub fn call_builder( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + ///Creates a new call builder for the [`expiration`] function. + pub fn expiration( + &self, + _identifier: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, expirationCall, N> { + self.call_builder(&expirationCall { _identifier }) + } + ///Creates a new call builder for the [`extend`] function. + pub fn extend( + &self, + _identifier: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, extendCall, N> { + self.call_builder(&extendCall { _identifier }) + } + ///Creates a new call builder for the [`guardian`] function. + pub fn guardian(&self) -> alloy_contract::SolCallBuilder<&P, guardianCall, N> { + self.call_builder(&guardianCall) + } + ///Creates a new call builder for the [`initVersion`] function. + pub fn initVersion( + &self, + ) -> alloy_contract::SolCallBuilder<&P, initVersionCall, N> { + self.call_builder(&initVersionCall) + } + ///Creates a new call builder for the [`initialize`] function. + pub fn initialize( + &self, + _guardian: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> { + self.call_builder(&initializeCall { _guardian }) + } + ///Creates a new call builder for the [`pausable`] function. + pub fn pausable( + &self, + _identifier: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, pausableCall, N> { + self.call_builder(&pausableCall { _identifier }) + } + ///Creates a new call builder for the [`pause`] function. + pub fn pause( + &self, + _identifier: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, pauseCall, N> { + self.call_builder(&pauseCall { _identifier }) + } + ///Creates a new call builder for the [`pauseExpiry`] function. + pub fn pauseExpiry( + &self, + ) -> alloy_contract::SolCallBuilder<&P, pauseExpiryCall, N> { + self.call_builder(&pauseExpiryCall) + } + ///Creates a new call builder for the [`pauseTimestamps`] function. + pub fn pauseTimestamps( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, pauseTimestampsCall, N> { + self.call_builder(&pauseTimestampsCall(_0)) + } + ///Creates a new call builder for the [`paused_0`] function. + pub fn paused_0( + &self, + _identifier: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, paused_0Call, N> { + self.call_builder(&paused_0Call { _identifier }) + } + ///Creates a new call builder for the [`paused_1`] function. + pub fn paused_1(&self) -> alloy_contract::SolCallBuilder<&P, paused_1Call, N> { + self.call_builder(&paused_1Call) + } + ///Creates a new call builder for the [`proxyAdmin`] function. + pub fn proxyAdmin( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminCall, N> { + self.call_builder(&proxyAdminCall) + } + ///Creates a new call builder for the [`proxyAdminOwner`] function. + pub fn proxyAdminOwner( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proxyAdminOwnerCall, N> { + self.call_builder(&proxyAdminOwnerCall) + } + ///Creates a new call builder for the [`unpause`] function. + pub fn unpause( + &self, + _identifier: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, unpauseCall, N> { + self.call_builder(&unpauseCall { _identifier }) + } + ///Creates a new call builder for the [`version`] function. + pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> { + self.call_builder(&versionCall) + } + } + /// Event filters. + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SuperchainConfigInstance { + /// Creates a new event filter using this contract instance's provider and address. + /// + /// Note that the type can be any event, not just those defined in this contract. + /// Prefer using the other methods for building type-safe event filters. + pub fn event_filter( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`ConfigUpdate`] event. + pub fn ConfigUpdate_filter(&self) -> alloy_contract::Event<&P, ConfigUpdate, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Initialized`] event. + pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Paused`] event. + pub fn Paused_filter(&self) -> alloy_contract::Event<&P, Paused, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Unpaused`] event. + pub fn Unpaused_filter(&self) -> alloy_contract::Event<&P, Unpaused, N> { + self.event_filter::() + } + } +} diff --git a/bindings/src/lib.rs b/bindings/src/lib.rs index 468775cfe..4db71cb94 100644 --- a/bindings/src/lib.rs +++ b/bindings/src/lib.rs @@ -3,8 +3,23 @@ #![allow(unused)] //! This lib re-exports the contract bindings. +use alloy_sol_types::sol; + #[cfg_attr(rustfmt, rustfmt_skip)] mod codegen; #[cfg_attr(rustfmt, rustfmt_skip)] pub use codegen::*; + +// Hand-written types shared across crates. +// These are not generated by forge bind because they need identical layout +// across fault-proof and host-utils. +sol! { + /// The L2 output used for computing output roots. + struct L2Output { + uint64 zero; + bytes32 l2_state_root; + bytes32 l2_storage_hash; + bytes32 l2_claim_hash; + } +} diff --git a/fault-proof/Cargo.toml b/fault-proof/Cargo.toml index c1342ecd7..541139791 100644 --- a/fault-proof/Cargo.toml +++ b/fault-proof/Cargo.toml @@ -21,6 +21,7 @@ path = "bin/challenger.rs" [dependencies] # local +op-succinct-bindings.workspace = true op-succinct-client-utils.workspace = true op-succinct-elfs.workspace = true op-succinct-ethereum-host-utils.workspace = true @@ -72,7 +73,6 @@ tempfile = "3" alloy-signer-local.workspace = true alloy-node-bindings.workspace = true alloy.workspace = true -op-succinct-bindings.workspace = true serde_json.workspace = true serde.workspace = true alloy-rpc-types-trace.workspace = true diff --git a/fault-proof/src/challenger.rs b/fault-proof/src/challenger.rs index 33568d925..99039aa58 100644 --- a/fault-proof/src/challenger.rs +++ b/fault-proof/src/challenger.rs @@ -237,10 +237,10 @@ where for game in games { let contract = OPSuccinctFaultDisputeGame::new(game.address, self.l1_provider.clone()); - let status = contract.status().call().await?; + let status = GameStatus::try_from(contract.status().call().await?)?; let claim_data = contract.claimData().call().await?; - let proposal_status = claim_data.status; - let deadline = U256::from(claim_data.deadline).to::(); + let proposal_status = ProposalStatus::try_from(claim_data.status)?; + let deadline = claim_data.deadline; match status { GameStatus::IN_PROGRESS => { @@ -342,7 +342,7 @@ where /// Drop game if the game type is invalid or the game was not respected at the time of creation. async fn fetch_game(&self, index: U256) -> Result<()> { let game = self.factory.gameAtIndex(index).call().await?; - let game_address = game.proxy; + let game_address = game.proxy_; let contract = OPSuccinctFaultDisputeGame::new(game_address, self.l1_provider.clone()); let game_type = contract.gameType().call().await?; @@ -361,7 +361,7 @@ where let claim_data = contract.claimData().call().await?; let was_respected = contract.wasRespectedGameTypeWhenCreated().call().await?; - let status = contract.status().call().await?; + let status = GameStatus::try_from(contract.status().call().await?)?; let mut state = self.state.lock().await; @@ -375,7 +375,7 @@ where l2_block_number, is_invalid: output_root != computed_output_root, status, - proposal_status: claim_data.status, + proposal_status: ProposalStatus::try_from(claim_data.status)?, should_attempt_to_challenge: false, should_attempt_to_resolve: false, should_attempt_to_claim_bond: false, diff --git a/fault-proof/src/contract.rs b/fault-proof/src/contract.rs index be8f6fb62..b4b1bfc0f 100644 --- a/fault-proof/src/contract.rs +++ b/fault-proof/src/contract.rs @@ -1,197 +1,113 @@ +//! Contract bindings for the fault proof system. +//! +//! Contract types (instances, events, function calls) are imported from forge-generated +//! bindings in `op-succinct-bindings`, which are the source of truth for ABI correctness. +//! +//! Enums (GameStatus, ProposalStatus) are kept as hand-written `sol!` definitions because +//! forge bind generates UDT wrappers (`struct GameStatus(u8)`) instead of proper Rust enums, +//! and we need named variants for pattern matching and Serialize/Deserialize derives. + use alloy_sol_macro::sol; use serde::{Deserialize, Serialize}; -sol! { - type GameType is uint32; - type Claim is bytes32; - type Timestamp is uint64; - type Hash is bytes32; - - #[sol(rpc)] - #[derive(Debug)] - contract DisputeGameFactory { - /// @notice Emitted when a new dispute game is created. - event DisputeGameCreated(address indexed disputeProxy, GameType indexed gameType, Claim indexed rootClaim); - - /// @notice Emitted when a new game implementation added to the factory - event ImplementationSet(address indexed impl, GameType indexed gameType); - - /// @notice `gameImpls` is a mapping that maps `GameType`s to their respective - /// `IDisputeGame` implementations. - mapping(GameType => IDisputeGame) public gameImpls; - - /// @notice Returns the required bonds for initializing a dispute game of the given type. - mapping(GameType => uint256) public initBonds; - - /// @notice The total number of dispute games created by this factory. - function gameCount() external view returns (uint256 gameCount_); - - /// @notice `gameAtIndex` returns the dispute game contract address and its creation timestamp - /// at the given index. Each created dispute game increments the underlying index. - function gameAtIndex(uint256 _index) external view returns (GameType gameType, Timestamp timestamp, IDisputeGame proxy); - - /// @notice Returns the dispute game metadata for a given UUID. - function games(GameType gameType, Claim rootClaim, bytes extraData) external view returns (IDisputeGame proxy, Timestamp timestamp); - - /// @notice Returns the UUID for a given dispute game configuration. - function getGameUUID(GameType gameType, Claim rootClaim, bytes extraData) external pure returns (Hash uuid); - - /// @notice Creates a new DisputeGame proxy contract. - function create(GameType gameType, Claim rootClaim, bytes extraData) external; - } - - #[allow(missing_docs)] - #[sol(rpc)] - interface IDisputeGame { - function status() external view returns (GameStatus status_); - } - - #[allow(missing_docs)] - #[sol(rpc)] - interface IFaultDisputeGame { - function l2SequenceNumber() external view returns (uint256 l2SequenceNumber_); - } - - #[sol(rpc)] - contract OPSuccinctFaultDisputeGame { - /// @notice Getter for the game type. - function gameType() public pure returns (GameType gameType_); - - /// @notice Getter for the creator of the dispute game. - function gameCreator() public pure returns (address creator_); - - /// @notice The L2 sequence number (block number) for which this game is proposing an output root. - function l2SequenceNumber() public pure returns (uint256 l2SequenceNumber_); - - /// @notice The L2 block number for which this game is proposing an output root. - /// @dev Alias for l2SequenceNumber() for backward compatibility. - function l2BlockNumber() public pure returns (uint256 l2BlockNumber_); - - /// @notice Only the starting block number of the game. - function startingBlockNumber() external view returns (uint256 startingBlockNumber_); - - /// @notice Getter for the root claim. - function rootClaim() public pure returns (Claim rootClaim_); - - /// @notice Getter for the parent hash of the L1 block when the dispute game was created. - function l1Head() public pure returns (Hash l1Head_); - - /// @notice Getter for the status of the game. - function status() public view returns (GameStatus status_); - - /// @notice Getter for the claim data. - function claimData() public view returns (ClaimData memory claimData_); - - /// @notice Getter for the was respected game type when created. - function wasRespectedGameTypeWhenCreated() external view returns (bool wasRespectedGameTypeWhenCreated_); - - /// @notice Challenges the game. - function challenge() external payable returns (ProposalStatus); - /// @notice Proves the game. - function prove(bytes calldata proofBytes) external returns (ProposalStatus); - - /// @notice Resolves the game after the clock expires. - /// `DEFENDER_WINS` when no one has challenged the proposer's claim and `MAX_CHALLENGE_DURATION` has passed - /// or there is a challenge but the prover has provided a valid proof within the `MAX_PROVE_DURATION`. - /// `CHALLENGER_WINS` when the proposer's claim has been challenged, but the proposer has not proven - /// its claim within the `MAX_PROVE_DURATION`. - function resolve() external returns (GameStatus status_); - - /// @notice Determines if the game is finished. - function gameOver() external view returns (bool gameOver_); - - /// @notice Returns the max challenge duration. - function maxChallengeDuration() external view returns (uint256 maxChallengeDuration_); - - /// @notice Returns the max prove duration. - function maxProveDuration() external view returns (uint64 maxProveDuration_); - - /// @notice Returns the anchor state registry contract. - function anchorStateRegistry() external view returns (IAnchorStateRegistry registry_); - - /// @notice Returns the challenger bond amount. - function challengerBond() external view returns (uint256 challengerBond_); - - /// @notice Returns the aggregation verification key. - function aggregationVkey() external view returns (bytes32 aggregationVkey_); - - /// @notice Returns the range verification key commitment. - function rangeVkeyCommitment() external view returns (bytes32 rangeVkeyCommitment_); - - /// @notice Returns the rollup config hash. - function rollupConfigHash() external view returns (bytes32 rollupConfigHash_); - - /// @notice Claim the credit belonging to the recipient address. - function claimCredit(address _recipient) external; - - /// @notice Returns the credit balance of a given recipient. - function credit(address _recipient) external view returns (uint256 credit_); - } - - #[allow(missing_docs)] - #[sol(rpc)] - interface IAnchorStateRegistry { - function anchorGame() external view returns (IDisputeGame anchorGame_); - } - - #[allow(missing_docs)] - #[sol(rpc)] - contract AnchorStateRegistry { - /// @notice Returns the current anchor root. - function getAnchorRoot() public view returns (Hash, uint256); - - /// @notice Returns whether a game is finalized. - function isGameFinalized(IDisputeGame _game) public view returns (bool); - - /// @notice Returns the current anchor game reference. - function anchorGame() public view returns (IDisputeGame anchorGame_); - - /// @notice Returns the respected game type. - function respectedGameType() external view returns (GameType); - } +// Re-export contract modules from forge-generated bindings. +// These are auto-synced from Solidity, preventing ABI drift. +pub use op_succinct_bindings::{ + anchor_state_registry::AnchorStateRegistry, dispute_game_factory::DisputeGameFactory, + i_anchor_state_registry::IAnchorStateRegistry, i_dispute_game::IDisputeGame, + i_fault_dispute_game::IFaultDisputeGame, + op_succinct_fault_dispute_game::OPSuccinctFaultDisputeGame, L2Output, +}; +// Hand-written types that need custom derives or are not generated by forge bind. +sol! { + /// The current status of the dispute game. #[derive(Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "SCREAMING_SNAKE_CASE")] - /// @notice The current status of the dispute game. enum GameStatus { - // The game is currently in progress, and has not been resolved. IN_PROGRESS, - // The game has concluded, and the `rootClaim` was challenged successfully. CHALLENGER_WINS, - // The game has concluded, and the `rootClaim` could not be contested. DEFENDER_WINS } + /// The proposal status within a dispute game. #[derive(Debug, PartialEq, Serialize, Deserialize)] enum ProposalStatus { - // The initial state of a new proposal. Unchallenged, - // A proposal that has been challenged but not yet proven. Challenged, - // An unchallenged proposal that has been proven valid with a verified proof. UnchallengedAndValidProofProvided, - // A challenged proposal that has been proven valid with a verified proof. ChallengedAndValidProofProvided, - // The final state after resolution, either GameStatus.CHALLENGER_WINS or GameStatus.DEFENDER_WINS. Resolved } +} - #[derive(Debug)] - /// @notice The `ClaimData` struct represents the data associated with a Claim. - struct ClaimData { - uint32 parentIndex; - address counteredBy; - address prover; - Claim claim; - ProposalStatus status; - Timestamp deadline; +#[cfg(test)] +mod tests { + use super::*; + + mod game_status { + use super::*; + + #[test] + fn try_from_valid_values() { + assert_eq!(GameStatus::try_from(0u8).unwrap(), GameStatus::IN_PROGRESS); + assert_eq!(GameStatus::try_from(1u8).unwrap(), GameStatus::CHALLENGER_WINS); + assert_eq!(GameStatus::try_from(2u8).unwrap(), GameStatus::DEFENDER_WINS); + } + + #[test] + fn try_from_out_of_range() { + assert!(GameStatus::try_from(3u8).is_err()); + } + + #[test] + fn serde_roundtrip() { + for variant in + [GameStatus::IN_PROGRESS, GameStatus::CHALLENGER_WINS, GameStatus::DEFENDER_WINS] + { + let json = serde_json::to_string(&variant).unwrap(); + let deserialized: GameStatus = serde_json::from_str(&json).unwrap(); + assert_eq!(variant, deserialized); + } + } } - /// @notice The `L2Output` struct represents the L2 output. - struct L2Output { - uint64 zero; - bytes32 l2_state_root; - bytes32 l2_storage_hash; - bytes32 l2_claim_hash; + mod proposal_status { + use super::*; + + #[test] + fn try_from_valid_values() { + assert_eq!(ProposalStatus::try_from(0u8).unwrap(), ProposalStatus::Unchallenged); + assert_eq!(ProposalStatus::try_from(1u8).unwrap(), ProposalStatus::Challenged); + assert_eq!( + ProposalStatus::try_from(2u8).unwrap(), + ProposalStatus::UnchallengedAndValidProofProvided + ); + assert_eq!( + ProposalStatus::try_from(3u8).unwrap(), + ProposalStatus::ChallengedAndValidProofProvided + ); + assert_eq!(ProposalStatus::try_from(4u8).unwrap(), ProposalStatus::Resolved); + } + + #[test] + fn try_from_out_of_range() { + assert!(ProposalStatus::try_from(5u8).is_err()); + } + + #[test] + fn serde_roundtrip() { + for variant in [ + ProposalStatus::Unchallenged, + ProposalStatus::Challenged, + ProposalStatus::UnchallengedAndValidProofProvided, + ProposalStatus::ChallengedAndValidProofProvided, + ProposalStatus::Resolved, + ] { + let json = serde_json::to_string(&variant).unwrap(); + let deserialized: ProposalStatus = serde_json::from_str(&json).unwrap(); + assert_eq!(variant, deserialized); + } + } } } diff --git a/fault-proof/src/lib.rs b/fault-proof/src/lib.rs index 1c25d5ac4..f7fb5b3e7 100644 --- a/fault-proof/src/lib.rs +++ b/fault-proof/src/lib.rs @@ -173,10 +173,11 @@ where return Ok(true); } - let parent_game_address = factory.gameAtIndex(U256::from(parent_index)).call().await?.proxy; + let parent_game_address = factory.gameAtIndex(U256::from(parent_index)).call().await?.proxy_; let parent_game_contract = IDisputeGame::new(parent_game_address, factory.provider()); + let status = GameStatus::try_from(parent_game_contract.status().call().await?)?; - Ok(parent_game_contract.status().call().await? != GameStatus::IN_PROGRESS) + Ok(status != GameStatus::IN_PROGRESS) } async fn is_parent_challenger_wins

( @@ -190,10 +191,11 @@ where return Ok(false); } - let parent_game_address = factory.gameAtIndex(U256::from(parent_index)).call().await?.proxy; + let parent_game_address = factory.gameAtIndex(U256::from(parent_index)).call().await?.proxy_; let parent_game_contract = IDisputeGame::new(parent_game_address, factory.provider()); + let status = GameStatus::try_from(parent_game_contract.status().call().await?)?; - Ok(parent_game_contract.status().call().await? == GameStatus::CHALLENGER_WINS) + Ok(status == GameStatus::CHALLENGER_WINS) } /// Prefix used for transaction revert errors. diff --git a/fault-proof/src/proposer.rs b/fault-proof/src/proposer.rs index 96ed3cc2d..a12cf8f32 100644 --- a/fault-proof/src/proposer.rs +++ b/fault-proof/src/proposer.rs @@ -489,7 +489,7 @@ where // Fetch contract params from game implementation. let game_impl = self.factory.game_impl(self.config.game_type).await?; - let max_challenge_duration = game_impl.maxChallengeDuration().call().await?.to::(); + let max_challenge_duration = game_impl.maxChallengeDuration().call().await?; let max_prove_duration = game_impl.maxProveDuration().call().await?; let contract_params = ContractParams { max_challenge_duration, max_prove_duration }; @@ -756,26 +756,27 @@ where let contract = OPSuccinctFaultDisputeGame::new(game_address, self.l1_provider.clone()); let claim_data = contract.claimData().call().await?; - let status = contract.status().call().await?; - let deadline = U256::from(claim_data.deadline).to::(); + let status = GameStatus::try_from(contract.status().call().await?)?; + let deadline = claim_data.deadline; let parent_index = claim_data.parentIndex; let is_finalized = self.anchor_state_registry.isGameFinalized(game_address).call().await?; + let proposal_status = ProposalStatus::try_from(claim_data.status)?; match status { GameStatus::IN_PROGRESS => { let game_type = contract.gameType().call().await?; let parent_resolved = is_parent_resolved(parent_index, self.factory.as_ref()).await?; - let is_game_over = match claim_data.status { + let is_game_over = match proposal_status { ProposalStatus::Unchallenged => now_ts >= deadline, ProposalStatus::UnchallengedAndValidProofProvided | ProposalStatus::ChallengedAndValidProofProvided => true, _ => false, }; let creator = contract.gameCreator().call().await?; - let is_own_game = match claim_data.status { + let is_own_game = match proposal_status { ProposalStatus::Unchallenged => creator == signer_address, ProposalStatus::UnchallengedAndValidProofProvided | ProposalStatus::ChallengedAndValidProofProvided => { @@ -792,7 +793,7 @@ where actions.push(GameSyncAction::Update { index, status, - proposal_status: claim_data.status, + proposal_status, deadline, should_attempt_to_resolve, should_attempt_to_claim_bond: false, @@ -840,7 +841,7 @@ where actions.push(GameSyncAction::Update { index, status, - proposal_status: claim_data.status, + proposal_status, deadline, should_attempt_to_resolve: false, should_attempt_to_claim_bond: false, @@ -850,7 +851,7 @@ where actions.push(GameSyncAction::Update { index, status, - proposal_status: claim_data.status, + proposal_status, deadline, should_attempt_to_resolve: false, should_attempt_to_claim_bond: is_finalized && credit > U256::ZERO, @@ -1365,8 +1366,8 @@ where } let game = self.factory.gameAtIndex(index).call().await?; - let game_address = game.proxy; - let game_type = game.gameType; + let game_address = game.proxy_; + let game_type = game.gameType_; // Drop unsupported game types. if game_type != self.config.game_type { @@ -1386,13 +1387,13 @@ where let output_root = self.l2_provider.compute_output_root_at_block(l2_block).await?; let claim = contract.rootClaim().call().await?; let was_respected = contract.wasRespectedGameTypeWhenCreated().call().await?; - let status = contract.status().call().await?; + let status = GameStatus::try_from(contract.status().call().await?)?; let claim_data = contract.claimData().call().await?; let (parent_index, proposal_status, deadline) = ( claim_data.parentIndex, - claim_data.status, - U256::from(claim_data.deadline).to::(), + ProposalStatus::try_from(claim_data.status)?, + claim_data.deadline, ); let aggregation_vkey = B256::from(contract.aggregationVkey().call().await?.0); @@ -1477,7 +1478,7 @@ where .games(self.config.game_type, output_root, extra_data.clone().into()) .call() .await? - .proxy; + .proxy_; // If there already exists a game at the next L2 block number for proposal, increment the L2 // block number by 1 @@ -1493,7 +1494,7 @@ where .games(self.config.game_type, output_root, extra_data.clone().into()) .call() .await? - .proxy; + .proxy_; } tracing::info!( diff --git a/fault-proof/tests/common/monitor.rs b/fault-proof/tests/common/monitor.rs index 9b6d9342d..975a54d01 100644 --- a/fault-proof/tests/common/monitor.rs +++ b/fault-proof/tests/common/monitor.rs @@ -226,7 +226,7 @@ pub async fn wait_for_challenges( statuses[i] = claim_data_status == ProposalStatus::Challenged; - if claim_data.status != 0 { + if claim_data_status != ProposalStatus::Unchallenged { info!("Game {} status: {:?}", game_address, claim_data_status); } } diff --git a/scripts/utils/bin/preflight.rs b/scripts/utils/bin/preflight.rs index cc17236ab..8077a97f9 100644 --- a/scripts/utils/bin/preflight.rs +++ b/scripts/utils/bin/preflight.rs @@ -344,7 +344,7 @@ async fn main() -> Result<()> { let new_game_count = factory.gameCount().call().await?; let game_index = new_game_count - U256::from(1); let game_info = factory.gameAtIndex(game_index).call().await?; - let game_address = game_info.proxy; + let game_address = game_info.proxy_; info!("Game address: {}", game_address); let game = OPSuccinctFaultDisputeGame::new(game_address, provider_with_signer.clone()); @@ -373,7 +373,10 @@ async fn main() -> Result<()> { info!("Transaction receipt: {:?}", receipt); let claim_data = game.claimData().call().await?; - assert_eq!(claim_data.status, ProposalStatus::UnchallengedAndValidProofProvided); + assert_eq!( + ProposalStatus::try_from(claim_data.status)?, + ProposalStatus::UnchallengedAndValidProofProvided + ); info!("Successfully completed preflight check"); diff --git a/utils/host/Cargo.toml b/utils/host/Cargo.toml index 928322647..a855a6aa6 100644 --- a/utils/host/Cargo.toml +++ b/utils/host/Cargo.toml @@ -14,6 +14,7 @@ ansi = [] sp1-sdk.workspace = true # local +op-succinct-bindings.workspace = true op-succinct-client-utils.workspace = true op-succinct-elfs.workspace = true diff --git a/utils/host/src/contract.rs b/utils/host/src/contract.rs index 21ab905c3..fdfccbec0 100644 --- a/utils/host/src/contract.rs +++ b/utils/host/src/contract.rs @@ -1,135 +1,18 @@ -use crate::OPSuccinctL2OutputOracle::opSuccinctConfigsReturn; -use alloy_primitives::B256; -use alloy_sol_types::sol; - -// Sourced from op-succinct/contracts/src/validity/OPSuccinctL2OutputOracle.sol -sol! { - #[sol(rpc)] - contract OPSuccinctL2OutputOracle { - struct OpSuccinctConfig { - bytes32 aggregationVkey; - bytes32 rangeVkeyCommitment; - bytes32 rollupConfigHash; - } - - mapping(bytes32 => OpSuccinctConfig) public opSuccinctConfigs; - - uint256 public submissionInterval; - - function latestBlockNumber() public view returns (uint256); - - function historicBlockHashes(uint256 _blockNumber) external view returns (bytes32); - - function updateAggregationVKey(bytes32 _aggregationVKey) external onlyOwner; - - function updateRangeVkeyCommitment(bytes32 _rangeVkeyCommitment) external onlyOwner; - - // Checkpointing L1 block hashes. - function checkpointBlockHash(uint256 _blockNumber) external; - - // Proposing outputs when the output oracle is set to ZK mode. - function proposeL2Output(bytes32 _configName, bytes32 _outputRoot, uint256 _l2BlockNumber, uint256 _l1BlockNumber, bytes memory _proof, address _proverAddress) - external - payable - whenNotOptimistic; - - function dgfProposeL2Output( - bytes32 _configName, - bytes32 _outputRoot, - uint256 _l2BlockNumber, - uint256 _l1BlockNumber, - bytes memory _proof, - address _proverAddress - ) external payable whenNotOptimistic returns (address _game); - } -} - -impl opSuccinctConfigsReturn { - pub fn aggregation_vkey(&self) -> B256 { - self._0 - } - - pub fn range_vkey_commitment(&self) -> B256 { - self._1 - } - - pub fn rollup_config_hash(&self) -> B256 { - self._2 - } -} - -// Sourced from https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/dispute/DisputeGameFactory.sol. -sol! { - /// @notice The current status of the dispute game. - enum GameStatus { - // The game is currently in progress, and has not been resolved. - IN_PROGRESS, - // The game has concluded, and the `rootClaim` was challenged successfully. - CHALLENGER_WINS, - // The game has concluded, and the `rootClaim` could not be contested. - DEFENDER_WINS - } - - /// @notice A `GameType` represents the type of game being played. - type GameType is uint32; - - /// @notice A claim represents an MPT root representing the state of the fault proof program. - type Claim is bytes32; - - /// @notice A dedicated timestamp type. - type Timestamp is uint64; - - /// @notice A custom type for a generic hash. - type Hash is bytes32; +//! Contract bindings for the host utilities. +//! +//! Contract types are imported from forge-generated bindings in `op-succinct-bindings`, +//! which are the source of truth for ABI correctness. +//! +//! Only types that are not generated (external contracts like SP1Blobstream) are kept as +//! hand-written `sol!` definitions. - interface IInitializable { - function initialize() external payable; - } - - interface IDisputeGame is IInitializable { - event Resolved(GameStatus indexed status); - - function createdAt() external view returns (Timestamp); - function resolvedAt() external view returns (Timestamp); - function status() external view returns (GameStatus); - function gameType() external view returns (GameType gameType_); - function gameCreator() external pure returns (address creator_); - function rootClaim() external pure returns (Claim rootClaim_); - function l1Head() external pure returns (Hash l1Head_); - function l2BlockNumber() external pure returns (uint256 l2BlockNumber_); - function extraData() external pure returns (bytes memory extraData_); - function resolve() external returns (GameStatus status_); - function gameData() external view returns (GameType gameType_, Claim rootClaim_, bytes memory extraData_); - function wasRespectedGameTypeWhenCreated() external view returns (bool); - } - - #[sol(rpc)] - contract DisputeGameFactory { - - /// @notice Returns the required bonds for initializing a dispute game of the given type. - mapping(GameType => uint256) public initBonds; +use alloy_sol_types::sol; - /// @notice Creates a new DisputeGame proxy contract. - /// @param _gameType The type of the DisputeGame - used to decide the proxy implementation. - /// @param _rootClaim The root claim of the DisputeGame. - /// @param _extraData Any extra data that should be provided to the created dispute game. - /// @return proxy_ The address of the created DisputeGame proxy. - function create( - GameType _gameType, - Claim _rootClaim, - bytes calldata _extraData - ) external payable returns (IDisputeGame proxy_); - } -} - -sol! { - struct L2Output { - uint64 zero; - bytes32 l2_state_root; - bytes32 l2_storage_hash; - bytes32 l2_claim_hash; - } -} +// Re-export contract modules from forge-generated bindings. +pub use op_succinct_bindings::{ + dispute_game_factory::DisputeGameFactory, + op_succinct_l2_output_oracle::OPSuccinctL2OutputOracle, L2Output, +}; sol! { #[sol(rpc)] @@ -137,9 +20,3 @@ sol! { uint64 public latestBlock; } } - -impl PartialEq for GameStatus { - fn eq(&self, other: &Self) -> bool { - *self as u8 == *other as u8 - } -} diff --git a/validity/src/proposer.rs b/validity/src/proposer.rs index 1c3b1006f..ce7a8a593 100644 --- a/validity/src/proposer.rs +++ b/validity/src/proposer.rs @@ -1119,7 +1119,8 @@ where let transaction_request = self .contract_config .l2oo_contract - .proposeL2Output( + // `_1` suffix: forge-generated disambiguation for the 6-arg configName overload. + .proposeL2Output_1( self.requester_config.op_succinct_config_name_hash, output.output_root, U256::from(completed_agg_proof.end_block), @@ -1154,9 +1155,9 @@ where self.contract_config.l2oo_contract.opSuccinctConfigs(config_name).call().await?; // Extract the OpSuccinctConfig fields with meaningful names. - let contract_agg_vkey_hash = contract_config.aggregation_vkey(); - let contract_range_vkey_commitment = contract_config.range_vkey_commitment(); - let contract_rollup_config_hash = contract_config.rollup_config_hash(); + let contract_agg_vkey_hash = contract_config.aggregationVkey; + let contract_range_vkey_commitment = contract_config.rangeVkeyCommitment; + let contract_rollup_config_hash = contract_config.rollupConfigHash; let rollup_config_hash_match = contract_rollup_config_hash == self.program_config.commitments.rollup_config_hash;