From f9bca581ef36756de8a0197ef66777ace264c5df Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 30 Dec 2024 16:12:13 +0700 Subject: [PATCH] accounts/abi/bind/v2/internal/contracts: regenerate bindings (they were mistakenly generated with a broken iteration of the code, and empty/broken bindings were included) --- .../bind/v2/internal/contracts/db/bindings.go | 219 ++++++++++ .../v2/internal/contracts/events/bindings.go | 164 ++++++++ .../contracts/nested_libraries/bindings.go | 397 ++++++++++++++++++ .../contracts/solc_errors/bindings.go | 162 +++++++ 4 files changed, 942 insertions(+) diff --git a/accounts/abi/bind/v2/internal/contracts/db/bindings.go b/accounts/abi/bind/v2/internal/contracts/db/bindings.go index b6fdd5555a45..b6687b256986 100644 --- a/accounts/abi/bind/v2/internal/contracts/db/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/db/bindings.go @@ -22,3 +22,222 @@ var ( _ = types.BloomLookup _ = abi.ConvertType ) + +// DBStats is an auto generated low-level Go binding around an user-defined struct. +type DBStats struct { + Gets *big.Int + Inserts *big.Int + Mods *big.Int +} + +// TODO: convert this type to value type after everything works. +// DBMetaData contains all meta data concerning the DB contract. +var DBMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"key\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"name\":\"Insert\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"key\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"KeyedInsert\",\"type\":\"event\"},{\"stateMutability\":\"nonpayable\",\"type\":\"fallback\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"k\",\"type\":\"uint256\"}],\"name\":\"get\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getNamedStatParams\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inserts\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"mods\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getStatParams\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getStatsStruct\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"gets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"inserts\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"mods\",\"type\":\"uint256\"}],\"internalType\":\"structDB.Stats\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"k\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"v\",\"type\":\"uint256\"}],\"name\":\"insert\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]", + Pattern: "253cc2574e2f8b5e909644530e4934f6ac", + Bin: "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", +} + +// DB is an auto generated Go binding around an Ethereum contract. +type DB struct { + abi abi.ABI +} + +// NewDB creates a new instance of DB. +func NewDB() (*DB, error) { + parsed, err := DBMetaData.GetAbi() + if err != nil { + return nil, err + } + return &DB{abi: *parsed}, nil +} + +func (_DB *DB) PackConstructor() []byte { + res, _ := _DB.abi.Pack("") + return res +} + +// Get is a free data retrieval call binding the contract method 0x9507d39a. +// +// Solidity: function get(uint256 k) returns(uint256) +func (_DB *DB) PackGet(k *big.Int) ([]byte, error) { + return _DB.abi.Pack("get", k) +} + +func (_DB *DB) UnpackGet(data []byte) (*big.Int, error) { + out, err := _DB.abi.Unpack("get", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetNamedStatParams is a free data retrieval call binding the contract method 0xe369ba3b. +// +// Solidity: function getNamedStatParams() view returns(uint256 gets, uint256 inserts, uint256 mods) +func (_DB *DB) PackGetNamedStatParams() ([]byte, error) { + return _DB.abi.Pack("getNamedStatParams") +} + +type GetNamedStatParamsOutput struct { + Gets *big.Int + Inserts *big.Int + Mods *big.Int +} + +func (_DB *DB) UnpackGetNamedStatParams(data []byte) (GetNamedStatParamsOutput, error) { + out, err := _DB.abi.Unpack("getNamedStatParams", data) + + outstruct := new(GetNamedStatParamsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Gets = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Inserts = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.Mods = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// GetStatParams is a free data retrieval call binding the contract method 0x6fcb9c70. +// +// Solidity: function getStatParams() view returns(uint256, uint256, uint256) +func (_DB *DB) PackGetStatParams() ([]byte, error) { + return _DB.abi.Pack("getStatParams") +} + +type GetStatParamsOutput struct { + Arg *big.Int + Arg0 *big.Int + Arg1 *big.Int +} + +func (_DB *DB) UnpackGetStatParams(data []byte) (GetStatParamsOutput, error) { + out, err := _DB.abi.Unpack("getStatParams", data) + + outstruct := new(GetStatParamsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Arg0 = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.Arg1 = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// GetStatsStruct is a free data retrieval call binding the contract method 0xee8161e0. +// +// Solidity: function getStatsStruct() view returns((uint256,uint256,uint256)) +func (_DB *DB) PackGetStatsStruct() ([]byte, error) { + return _DB.abi.Pack("getStatsStruct") +} + +func (_DB *DB) UnpackGetStatsStruct(data []byte) (DBStats, error) { + out, err := _DB.abi.Unpack("getStatsStruct", data) + + if err != nil { + return *new(DBStats), err + } + + out0 := *abi.ConvertType(out[0], new(DBStats)).(*DBStats) + + return out0, err + +} + +// Insert is a free data retrieval call binding the contract method 0x1d834a1b. +// +// Solidity: function insert(uint256 k, uint256 v) returns(uint256) +func (_DB *DB) PackInsert(k *big.Int, v *big.Int) ([]byte, error) { + return _DB.abi.Pack("insert", k, v) +} + +func (_DB *DB) UnpackInsert(data []byte) (*big.Int, error) { + out, err := _DB.abi.Unpack("insert", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DBInsert represents a Insert event raised by the DB contract. +type DBInsert struct { + Key *big.Int + Value *big.Int + Length *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const DBInsertEventName = "Insert" + +func (_DB *DB) UnpackInsertEvent(log *types.Log) (*DBInsert, error) { + event := "Insert" + if log.Topics[0] != _DB.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DBInsert) + if len(log.Data) > 0 { + if err := _DB.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DB.abi.Events[event].Inputs { + if arg.Indexed { + indexed = append(indexed, arg) + } + } + if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil { + return nil, err + } + out.Raw = log + return out, nil +} + +// DBKeyedInsert represents a KeyedInsert event raised by the DB contract. +type DBKeyedInsert struct { + Key *big.Int + Value *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const DBKeyedInsertEventName = "KeyedInsert" + +func (_DB *DB) UnpackKeyedInsertEvent(log *types.Log) (*DBKeyedInsert, error) { + event := "KeyedInsert" + if log.Topics[0] != _DB.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DBKeyedInsert) + if len(log.Data) > 0 { + if err := _DB.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DB.abi.Events[event].Inputs { + if arg.Indexed { + indexed = append(indexed, arg) + } + } + if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil { + return nil, err + } + out.Raw = log + return out, nil +} diff --git a/accounts/abi/bind/v2/internal/contracts/events/bindings.go b/accounts/abi/bind/v2/internal/contracts/events/bindings.go index c9a027a0f980..1570fe9b50d0 100644 --- a/accounts/abi/bind/v2/internal/contracts/events/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/events/bindings.go @@ -22,3 +22,167 @@ var ( _ = types.BloomLookup _ = abi.ConvertType ) + +// CPoint is an auto generated low-level Go binding around an user-defined struct. +type CPoint struct { + X *big.Int + Y *big.Int +} + +// TODO: convert this type to value type after everything works. +// CMetaData contains all meta data concerning the C contract. +var CMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"data\",\"type\":\"uint256\"}],\"name\":\"basic1\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"data\",\"type\":\"uint256\"}],\"name\":\"basic2\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DoSomethingWithManyArgs\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structC.Point\",\"name\":\"p\",\"type\":\"tuple\"}],\"name\":\"DoSomethingWithPoint\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structC.Point\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"EmitMulti\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"EmitOne\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Pattern: "55ef3c19a0ab1c1845f9e347540c1e51f5", + Bin: "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", +} + +// C is an auto generated Go binding around an Ethereum contract. +type C struct { + abi abi.ABI +} + +// NewC creates a new instance of C. +func NewC() (*C, error) { + parsed, err := CMetaData.GetAbi() + if err != nil { + return nil, err + } + return &C{abi: *parsed}, nil +} + +func (_C *C) PackConstructor() []byte { + res, _ := _C.abi.Pack("") + return res +} + +// DoSomethingWithManyArgs is a free data retrieval call binding the contract method 0x6fd8b968. +// +// Solidity: function DoSomethingWithManyArgs() pure returns(uint256, uint256, uint256, bool) +func (_C *C) PackDoSomethingWithManyArgs() ([]byte, error) { + return _C.abi.Pack("DoSomethingWithManyArgs") +} + +type DoSomethingWithManyArgsOutput struct { + Arg *big.Int + Arg0 *big.Int + Arg1 *big.Int + Arg2 bool +} + +func (_C *C) UnpackDoSomethingWithManyArgs(data []byte) (DoSomethingWithManyArgsOutput, error) { + out, err := _C.abi.Unpack("DoSomethingWithManyArgs", data) + + outstruct := new(DoSomethingWithManyArgsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Arg0 = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.Arg1 = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + outstruct.Arg2 = *abi.ConvertType(out[3], new(bool)).(*bool) + + return *outstruct, err + +} + +// DoSomethingWithPoint is a free data retrieval call binding the contract method 0xedcdc894. +// +// Solidity: function DoSomethingWithPoint((uint256,uint256) p) pure returns((uint256,uint256)) +func (_C *C) PackDoSomethingWithPoint(p CPoint) ([]byte, error) { + return _C.abi.Pack("DoSomethingWithPoint", p) +} + +func (_C *C) UnpackDoSomethingWithPoint(data []byte) (CPoint, error) { + out, err := _C.abi.Unpack("DoSomethingWithPoint", data) + + if err != nil { + return *new(CPoint), err + } + + out0 := *abi.ConvertType(out[0], new(CPoint)).(*CPoint) + + return out0, err + +} + +// EmitMulti is a free data retrieval call binding the contract method 0xcb493749. +// +// Solidity: function EmitMulti() returns() +func (_C *C) PackEmitMulti() ([]byte, error) { + return _C.abi.Pack("EmitMulti") +} + +// EmitOne is a free data retrieval call binding the contract method 0xe8e49a71. +// +// Solidity: function EmitOne() returns() +func (_C *C) PackEmitOne() ([]byte, error) { + return _C.abi.Pack("EmitOne") +} + +// CBasic1 represents a Basic1 event raised by the C contract. +type CBasic1 struct { + Id *big.Int + Data *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const CBasic1EventName = "basic1" + +func (_C *C) UnpackBasic1Event(log *types.Log) (*CBasic1, error) { + event := "basic1" + if log.Topics[0] != _C.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(CBasic1) + if len(log.Data) > 0 { + if err := _C.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _C.abi.Events[event].Inputs { + if arg.Indexed { + indexed = append(indexed, arg) + } + } + if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil { + return nil, err + } + out.Raw = log + return out, nil +} + +// CBasic2 represents a Basic2 event raised by the C contract. +type CBasic2 struct { + Flag bool + Data *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const CBasic2EventName = "basic2" + +func (_C *C) UnpackBasic2Event(log *types.Log) (*CBasic2, error) { + event := "basic2" + if log.Topics[0] != _C.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(CBasic2) + if len(log.Data) > 0 { + if err := _C.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _C.abi.Events[event].Inputs { + if arg.Indexed { + indexed = append(indexed, arg) + } + } + if err := abi.ParseTopics(out, indexed, log.Topics[1:]); err != nil { + return nil, err + } + out.Raw = log + return out, nil +} diff --git a/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go b/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go index 4a2415dbcccf..bbe7c408219f 100644 --- a/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go @@ -22,3 +22,400 @@ var ( _ = types.BloomLookup _ = abi.ConvertType ) + +// TODO: convert this type to value type after everything works. +// C1MetaData contains all meta data concerning the C1 contract. +var C1MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"v1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"v2\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"res\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "ae26158f1824f3918bd66724ee8b6eb7c9", + Bin: "0x6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$5f33a1fab8ea7d932b4bc8c5e7dcd90bc2$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea26469706673582212209d07b322f13a9a05a62ccf2e925d28587ba6709742c985a55dad244e25b5cdd564736f6c634300081a0033", + Deps: []*bind.MetaData{ + L1MetaData, + L4MetaData, + }, +} + +// C1 is an auto generated Go binding around an Ethereum contract. +type C1 struct { + abi abi.ABI +} + +// NewC1 creates a new instance of C1. +func NewC1() (*C1, error) { + parsed, err := C1MetaData.GetAbi() + if err != nil { + return nil, err + } + return &C1{abi: *parsed}, nil +} + +func (_C1 *C1) PackConstructor(v1 *big.Int, v2 *big.Int) []byte { + res, _ := _C1.abi.Pack("", v1, v2) + return res +} + +// Do is a free data retrieval call binding the contract method 0x2ad11272. +// +// Solidity: function Do(uint256 val) pure returns(uint256 res) +func (_C1 *C1) PackDo(val *big.Int) ([]byte, error) { + return _C1.abi.Pack("Do", val) +} + +func (_C1 *C1) UnpackDo(data []byte) (*big.Int, error) { + out, err := _C1.abi.Unpack("Do", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TODO: convert this type to value type after everything works. +// C2MetaData contains all meta data concerning the C2 contract. +var C2MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"v1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"v2\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"res\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "78ef2840de5b706112ca2dbfa765501a89", + Bin: "0x6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$6070639404c39b5667691bb1f9177e1eac$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea26469706673582212203f624c062b23db1417622d9d64f8bb382c9e4613e15338001e190945d6e7f2c864736f6c634300081a0033", + Deps: []*bind.MetaData{ + L1MetaData, + L4bMetaData, + }, +} + +// C2 is an auto generated Go binding around an Ethereum contract. +type C2 struct { + abi abi.ABI +} + +// NewC2 creates a new instance of C2. +func NewC2() (*C2, error) { + parsed, err := C2MetaData.GetAbi() + if err != nil { + return nil, err + } + return &C2{abi: *parsed}, nil +} + +func (_C2 *C2) PackConstructor(v1 *big.Int, v2 *big.Int) []byte { + res, _ := _C2.abi.Pack("", v1, v2) + return res +} + +// Do is a free data retrieval call binding the contract method 0x2ad11272. +// +// Solidity: function Do(uint256 val) pure returns(uint256 res) +func (_C2 *C2) PackDo(val *big.Int) ([]byte, error) { + return _C2.abi.Pack("Do", val) +} + +func (_C2 *C2) UnpackDo(data []byte) (*big.Int, error) { + out, err := _C2.abi.Unpack("Do", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TODO: convert this type to value type after everything works. +// L1MetaData contains all meta data concerning the L1 contract. +var L1MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "ffc1393672b8ed81d0c8093ffcb0e7fbe8", + Bin: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea26469706673582212204b676b17ea48d7d33ea6c1612dfbcd963e273670638c919797e980a6e42d6e5a64736f6c634300081a0033", +} + +// L1 is an auto generated Go binding around an Ethereum contract. +type L1 struct { + abi abi.ABI +} + +// NewL1 creates a new instance of L1. +func NewL1() (*L1, error) { + parsed, err := L1MetaData.GetAbi() + if err != nil { + return nil, err + } + return &L1{abi: *parsed}, nil +} + +func (_L1 *L1) PackConstructor() []byte { + res, _ := _L1.abi.Pack("") + return res +} + +// Do is a free data retrieval call binding the contract method 0x2ad11272. +// +// Solidity: function Do(uint256 val) pure returns(uint256) +func (_L1 *L1) PackDo(val *big.Int) ([]byte, error) { + return _L1.abi.Pack("Do", val) +} + +func (_L1 *L1) UnpackDo(data []byte) (*big.Int, error) { + out, err := _L1.abi.Unpack("Do", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TODO: convert this type to value type after everything works. +// L2MetaData contains all meta data concerning the L2 contract. +var L2MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "2ce896a6dd38932d354f317286f90bc675", + Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220c6f7a5f2e4ef9458b4081d7a828ede24efb394c00dad7182493a56186a60b62f64736f6c634300081a0033", + Deps: []*bind.MetaData{ + L1MetaData, + }, +} + +// L2 is an auto generated Go binding around an Ethereum contract. +type L2 struct { + abi abi.ABI +} + +// NewL2 creates a new instance of L2. +func NewL2() (*L2, error) { + parsed, err := L2MetaData.GetAbi() + if err != nil { + return nil, err + } + return &L2{abi: *parsed}, nil +} + +func (_L2 *L2) PackConstructor() []byte { + res, _ := _L2.abi.Pack("") + return res +} + +// Do is a free data retrieval call binding the contract method 0x2ad11272. +// +// Solidity: function Do(uint256 val) pure returns(uint256) +func (_L2 *L2) PackDo(val *big.Int) ([]byte, error) { + return _L2.abi.Pack("Do", val) +} + +func (_L2 *L2) UnpackDo(data []byte) (*big.Int, error) { + out, err := _L2.abi.Unpack("Do", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TODO: convert this type to value type after everything works. +// L2bMetaData contains all meta data concerning the L2b contract. +var L2bMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "fd1474cf57f7ed48491e8bfdfd0d172adf", + Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220a36a724bd2bb81778a0380d6d4b41d69d81d8b6d3d2a672e14cfa22a6e98253e64736f6c634300081a0033", + Deps: []*bind.MetaData{ + L1MetaData, + }, +} + +// L2b is an auto generated Go binding around an Ethereum contract. +type L2b struct { + abi abi.ABI +} + +// NewL2b creates a new instance of L2b. +func NewL2b() (*L2b, error) { + parsed, err := L2bMetaData.GetAbi() + if err != nil { + return nil, err + } + return &L2b{abi: *parsed}, nil +} + +func (_L2b *L2b) PackConstructor() []byte { + res, _ := _L2b.abi.Pack("") + return res +} + +// Do is a free data retrieval call binding the contract method 0x2ad11272. +// +// Solidity: function Do(uint256 val) pure returns(uint256) +func (_L2b *L2b) PackDo(val *big.Int) ([]byte, error) { + return _L2b.abi.Pack("Do", val) +} + +func (_L2b *L2b) UnpackDo(data []byte) (*big.Int, error) { + out, err := _L2b.abi.Unpack("Do", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TODO: convert this type to value type after everything works. +// L3MetaData contains all meta data concerning the L3 contract. +var L3MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "d03b97f5e1a564374023a72ac7d1806773", + Bin: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea264697066735822122061067055c16517eded3faafba31b658871b20986f922183b577ffe64c8290c9764736f6c634300081a0033", +} + +// L3 is an auto generated Go binding around an Ethereum contract. +type L3 struct { + abi abi.ABI +} + +// NewL3 creates a new instance of L3. +func NewL3() (*L3, error) { + parsed, err := L3MetaData.GetAbi() + if err != nil { + return nil, err + } + return &L3{abi: *parsed}, nil +} + +func (_L3 *L3) PackConstructor() []byte { + res, _ := _L3.abi.Pack("") + return res +} + +// Do is a free data retrieval call binding the contract method 0x2ad11272. +// +// Solidity: function Do(uint256 val) pure returns(uint256) +func (_L3 *L3) PackDo(val *big.Int) ([]byte, error) { + return _L3.abi.Pack("Do", val) +} + +func (_L3 *L3) UnpackDo(data []byte) (*big.Int, error) { + out, err := _L3.abi.Unpack("Do", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TODO: convert this type to value type after everything works. +// L4MetaData contains all meta data concerning the L4 contract. +var L4MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "5f33a1fab8ea7d932b4bc8c5e7dcd90bc2", + Bin: "0x6102d161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d91906101a9565b610068565b60405161005f91906101e3565b60405180910390f35b5f600173__$d03b97f5e1a564374023a72ac7d1806773$__632ad11272846040518263ffffffff1660e01b81526004016100a291906101e3565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610210565b73__$2ce896a6dd38932d354f317286f90bc675$__632ad11272856040518263ffffffff1660e01b815260040161011891906101e3565b602060405180830381865af4158015610133573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101579190610210565b6101619190610268565b61016b9190610268565b9050919050565b5f80fd5b5f819050919050565b61018881610176565b8114610192575f80fd5b50565b5f813590506101a38161017f565b92915050565b5f602082840312156101be576101bd610172565b5b5f6101cb84828501610195565b91505092915050565b6101dd81610176565b82525050565b5f6020820190506101f65f8301846101d4565b92915050565b5f8151905061020a8161017f565b92915050565b5f6020828403121561022557610224610172565b5b5f610232848285016101fc565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61027282610176565b915061027d83610176565b92508282019050808211156102955761029461023b565b5b9291505056fea2646970667358221220e49c024cf6cef8343d5af652ab39f89e7edf1930ba53e986741ac84a03a709ff64736f6c634300081a0033", + Deps: []*bind.MetaData{ + L2MetaData, + L3MetaData, + }, +} + +// L4 is an auto generated Go binding around an Ethereum contract. +type L4 struct { + abi abi.ABI +} + +// NewL4 creates a new instance of L4. +func NewL4() (*L4, error) { + parsed, err := L4MetaData.GetAbi() + if err != nil { + return nil, err + } + return &L4{abi: *parsed}, nil +} + +func (_L4 *L4) PackConstructor() []byte { + res, _ := _L4.abi.Pack("") + return res +} + +// Do is a free data retrieval call binding the contract method 0x2ad11272. +// +// Solidity: function Do(uint256 val) pure returns(uint256) +func (_L4 *L4) PackDo(val *big.Int) ([]byte, error) { + return _L4.abi.Pack("Do", val) +} + +func (_L4 *L4) UnpackDo(data []byte) (*big.Int, error) { + out, err := _L4.abi.Unpack("Do", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TODO: convert this type to value type after everything works. +// L4bMetaData contains all meta data concerning the L4b contract. +var L4bMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "6070639404c39b5667691bb1f9177e1eac", + Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$fd1474cf57f7ed48491e8bfdfd0d172adf$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220819bc379f2acc661e3dba3915bee83164e666ab39a92d0bcbf56b2438c35f2e164736f6c634300081a0033", + Deps: []*bind.MetaData{ + L2bMetaData, + }, +} + +// L4b is an auto generated Go binding around an Ethereum contract. +type L4b struct { + abi abi.ABI +} + +// NewL4b creates a new instance of L4b. +func NewL4b() (*L4b, error) { + parsed, err := L4bMetaData.GetAbi() + if err != nil { + return nil, err + } + return &L4b{abi: *parsed}, nil +} + +func (_L4b *L4b) PackConstructor() []byte { + res, _ := _L4b.abi.Pack("") + return res +} + +// Do is a free data retrieval call binding the contract method 0x2ad11272. +// +// Solidity: function Do(uint256 val) pure returns(uint256) +func (_L4b *L4b) PackDo(val *big.Int) ([]byte, error) { + return _L4b.abi.Pack("Do", val) +} + +func (_L4b *L4b) UnpackDo(data []byte) (*big.Int, error) { + out, err := _L4b.abi.Unpack("Do", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} diff --git a/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go b/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go index 652a48be4ff9..a31877a837bc 100644 --- a/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go @@ -22,3 +22,165 @@ var ( _ = types.BloomLookup _ = abi.ConvertType ) + +// TODO: convert this type to value type after everything works. +// CMetaData contains all meta data concerning the C contract. +var CMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"arg1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg3\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"arg4\",\"type\":\"bool\"}],\"name\":\"BadThing\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"arg1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg3\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg4\",\"type\":\"uint256\"}],\"name\":\"BadThing2\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Bar\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"Foo\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "55ef3c19a0ab1c1845f9e347540c1e51f5", + Bin: "0x6080604052348015600e575f80fd5b506101c58061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063b0a378b014610038578063bfb4ebcf14610042575b5f80fd5b61004061004c565b005b61004a610092565b005b5f6001600260036040517fd233a24f00000000000000000000000000000000000000000000000000000000815260040161008994939291906100ef565b60405180910390fd5b5f600160025f6040517fbb6a82f10000000000000000000000000000000000000000000000000000000081526004016100ce949392919061014c565b60405180910390fd5b5f819050919050565b6100e9816100d7565b82525050565b5f6080820190506101025f8301876100e0565b61010f60208301866100e0565b61011c60408301856100e0565b61012960608301846100e0565b95945050505050565b5f8115159050919050565b61014681610132565b82525050565b5f60808201905061015f5f8301876100e0565b61016c60208301866100e0565b61017960408301856100e0565b610186606083018461013d565b9594505050505056fea264697066735822122043974fbdd5c75b36bb8fe9dd68c112de4d094a0d8626d74e03edd5e48f18118164736f6c634300081a0033", +} + +// C is an auto generated Go binding around an Ethereum contract. +type C struct { + abi abi.ABI +} + +// NewC creates a new instance of C. +func NewC() (*C, error) { + parsed, err := CMetaData.GetAbi() + if err != nil { + return nil, err + } + return &C{abi: *parsed}, nil +} + +func (_C *C) PackConstructor() []byte { + res, _ := _C.abi.Pack("") + return res +} + +// Bar is a free data retrieval call binding the contract method 0xb0a378b0. +// +// Solidity: function Bar() pure returns() +func (_C *C) PackBar() ([]byte, error) { + return _C.abi.Pack("Bar") +} + +// Foo is a free data retrieval call binding the contract method 0xbfb4ebcf. +// +// Solidity: function Foo() pure returns() +func (_C *C) PackFoo() ([]byte, error) { + return _C.abi.Pack("Foo") +} + +func (_C *C) UnpackError(raw []byte) any { + + if val, err := _C.UnpackBadThingError(raw); err == nil { + return val + + } else if val, err := _C.UnpackBadThing2Error(raw); err == nil { + return val + + } + return nil +} + +// CBadThing represents a BadThing error raised by the C contract. +type CBadThing struct { + Arg1 *big.Int + Arg2 *big.Int + Arg3 *big.Int + Arg4 bool +} + +func CBadThingErrorID() common.Hash { + return common.HexToHash("0xbb6a82f123854747ef4381e30e497f934a3854753fec99a69c35c30d4b46714d") +} + +func (_C *C) UnpackBadThingError(raw []byte) (*CBadThing, error) { + errName := "BadThing" + out := new(CBadThing) + if err := _C.abi.UnpackIntoInterface(out, errName, raw); err != nil { + // TODO: output can be non-pointer type. + return nil, err + } + return out, nil +} + +// CBadThing2 represents a BadThing2 error raised by the C contract. +type CBadThing2 struct { + Arg1 *big.Int + Arg2 *big.Int + Arg3 *big.Int + Arg4 *big.Int +} + +func CBadThing2ErrorID() common.Hash { + return common.HexToHash("0xd233a24f02271fe7c9470e060d0fda6447a142bf12ab31fed7ab65affd546175") +} + +func (_C *C) UnpackBadThing2Error(raw []byte) (*CBadThing2, error) { + errName := "BadThing2" + out := new(CBadThing2) + if err := _C.abi.UnpackIntoInterface(out, errName, raw); err != nil { + // TODO: output can be non-pointer type. + return nil, err + } + return out, nil +} + +// TODO: convert this type to value type after everything works. +// C2MetaData contains all meta data concerning the C2 contract. +var C2MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"arg1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"arg3\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"arg4\",\"type\":\"bool\"}],\"name\":\"BadThing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Foo\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "78ef2840de5b706112ca2dbfa765501a89", + Bin: "0x6080604052348015600e575f80fd5b506101148061001c5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c8063bfb4ebcf14602a575b5f80fd5b60306032565b005b5f600160025f6040517fbb6a82f1000000000000000000000000000000000000000000000000000000008152600401606c949392919060a3565b60405180910390fd5b5f819050919050565b6085816075565b82525050565b5f8115159050919050565b609d81608b565b82525050565b5f60808201905060b45f830187607e565b60bf6020830186607e565b60ca6040830185607e565b60d560608301846096565b9594505050505056fea264697066735822122073ad1e2383066bba44481ee5aaadd9a60a3e08e602e13ebf1c67c51ef47d191564736f6c634300081a0033", +} + +// C2 is an auto generated Go binding around an Ethereum contract. +type C2 struct { + abi abi.ABI +} + +// NewC2 creates a new instance of C2. +func NewC2() (*C2, error) { + parsed, err := C2MetaData.GetAbi() + if err != nil { + return nil, err + } + return &C2{abi: *parsed}, nil +} + +func (_C2 *C2) PackConstructor() []byte { + res, _ := _C2.abi.Pack("") + return res +} + +// Foo is a free data retrieval call binding the contract method 0xbfb4ebcf. +// +// Solidity: function Foo() pure returns() +func (_C2 *C2) PackFoo() ([]byte, error) { + return _C2.abi.Pack("Foo") +} + +func (_C2 *C2) UnpackError(raw []byte) any { + + if val, err := _C2.UnpackBadThingError(raw); err == nil { + return val + + } + return nil +} + +// C2BadThing represents a BadThing error raised by the C2 contract. +type C2BadThing struct { + Arg1 *big.Int + Arg2 *big.Int + Arg3 *big.Int + Arg4 bool +} + +func C2BadThingErrorID() common.Hash { + return common.HexToHash("0xbb6a82f123854747ef4381e30e497f934a3854753fec99a69c35c30d4b46714d") +} + +func (_C2 *C2) UnpackBadThingError(raw []byte) (*C2BadThing, error) { + errName := "BadThing" + out := new(C2BadThing) + if err := _C2.abi.UnpackIntoInterface(out, errName, raw); err != nil { + // TODO: output can be non-pointer type. + return nil, err + } + return out, nil +}