From 0830ae4421baff3fb3b03051e86ff9c4688c86a0 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Fri, 6 Jan 2023 12:58:43 +0100 Subject: [PATCH 001/104] accounts/abi: abigen v2 --- accounts/abi/bind/base.go | 69 +++++++++------ accounts/abi/bind/bind.go | 125 ++++++++++++++++++++------ accounts/abi/bind/lib.go | 152 +++++++++++++++++++++++++++++++ accounts/abi/bind/template.go | 4 + accounts/abi/bind/template2.go | 157 +++++++++++++++++++++++++++++++++ cmd/abigen/main.go | 15 +++- 6 files changed, 469 insertions(+), 53 deletions(-) create mode 100644 accounts/abi/bind/lib.go create mode 100644 accounts/abi/bind/template2.go diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index 0504089c7173..eb47e49989aa 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -156,10 +156,6 @@ func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend Co // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method string, params ...interface{}) error { - // Don't crash on a lazy user - if opts == nil { - opts = new(CallOpts) - } if results == nil { results = new([]interface{}) } @@ -168,68 +164,82 @@ func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method stri if err != nil { return err } + + output, err := c.call(opts, input) + if err != nil { + return err + } + + if len(*results) == 0 { + res, err := c.abi.Unpack(method, output) + *results = res + return err + } + res := *results + return c.abi.UnpackIntoInterface(res[0], method, output) +} + +func (c *BoundContract) call(opts *CallOpts, input []byte) ([]byte, error) { + // Don't crash on a lazy user + if opts == nil { + opts = new(CallOpts) + } var ( msg = ethereum.CallMsg{From: opts.From, To: &c.address, Data: input} ctx = ensureContext(opts.Context) code []byte output []byte + err error ) if opts.Pending { pb, ok := c.caller.(PendingContractCaller) if !ok { - return ErrNoPendingState + return nil, ErrNoPendingState } output, err = pb.PendingCallContract(ctx, msg) if err != nil { - return err + return nil, err } if len(output) == 0 { // Make sure we have a contract to operate on, and bail out otherwise. if code, err = pb.PendingCodeAt(ctx, c.address); err != nil { - return err + return nil, err } else if len(code) == 0 { - return ErrNoCode + return nil, ErrNoCode } } } else if opts.BlockHash != (common.Hash{}) { bh, ok := c.caller.(BlockHashContractCaller) if !ok { - return ErrNoBlockHashState + return nil, ErrNoBlockHashState } output, err = bh.CallContractAtHash(ctx, msg, opts.BlockHash) if err != nil { - return err + return nil, err } if len(output) == 0 { // Make sure we have a contract to operate on, and bail out otherwise. if code, err = bh.CodeAtHash(ctx, c.address, opts.BlockHash); err != nil { - return err + return nil, err } else if len(code) == 0 { - return ErrNoCode + return nil, ErrNoCode } } } else { output, err = c.caller.CallContract(ctx, msg, opts.BlockNumber) if err != nil { - return err + return nil, err } if len(output) == 0 { // Make sure we have a contract to operate on, and bail out otherwise. if code, err = c.caller.CodeAt(ctx, c.address, opts.BlockNumber); err != nil { - return err + return nil, err } else if len(code) == 0 { - return ErrNoCode + return nil, ErrNoCode } } } - - if len(*results) == 0 { - res, err := c.abi.Unpack(method, output) - *results = res - return err - } - res := *results - return c.abi.UnpackIntoInterface(res[0], method, output) + return output, nil } // Transact invokes the (paid) contract method with params as input values. @@ -434,13 +444,16 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i // FilterLogs filters contract logs for past blocks, returning the necessary // channels to construct a strongly typed bound iterator on top of them. func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + return c.filterLogs(opts, c.abi.Events[name].ID, query...) +} + +func (c *BoundContract) filterLogs(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { // Don't crash on a lazy user if opts == nil { opts = new(FilterOpts) } // Append the event selector to the query parameters and construct the topic set - query = append([][]interface{}{{c.abi.Events[name].ID}}, query...) - + query = append([][]interface{}{{eventID}}, query...) topics, err := abi.MakeTopics(query...) if err != nil { return nil, nil, err @@ -480,12 +493,16 @@ func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]int // WatchLogs filters subscribes to contract logs for future blocks, returning a // subscription object that can be used to tear down the watcher. func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + return c.watchLogs(opts, c.abi.Events[name].ID, query...) +} + +func (c *BoundContract) watchLogs(opts *WatchOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { // Don't crash on a lazy user if opts == nil { opts = new(WatchOpts) } // Append the event selector to the query parameters and construct the topic set - query = append([][]interface{}{{c.abi.Events[name].ID}}, query...) + query = append([][]interface{}{{eventID}}, query...) topics, err := abi.MakeTopics(query...) if err != nil { diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 71357c7a8c70..4c4ad28173ea 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -82,6 +82,100 @@ func isKeyWord(arg string) bool { // enforces compile time type safety and naming convention as opposed to having to // manually maintain hard coded strings that break on runtime. func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (string, error) { + data, err := bind(types, abis, bytecodes, fsigs, pkg, lang, libs, aliases) + if err != nil { + return "", err + } + buffer := new(bytes.Buffer) + + funcs := map[string]interface{}{ + "bindtype": bindType[lang], + "bindtopictype": bindTopicType[lang], + "namedtype": namedType[lang], + "capitalise": capitalise, + "decapitalise": decapitalise, + } + tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang])) + if err := tmpl.Execute(buffer, data); err != nil { + return "", err + } + // For Go bindings pass the code through gofmt to clean it up + if lang == LangGo { + code, err := format.Source(buffer.Bytes()) + if err != nil { + return "", fmt.Errorf("%v\n%s", err, buffer) + } + return string(code), nil + } + // For all others just return as is for now + return buffer.String(), nil +} + +func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (string, error) { + data, err := bind(types, abis, bytecodes, fsigs, pkg, lang, libs, aliases) + if err != nil { + return "", err + } + for _, c := range data.Contracts { + // We want pack/unpack methods for all existing methods. + for name, t := range c.Transacts { + c.Calls[name] = t + } + c.Transacts = nil + + // Make sure we return one argument. If multiple exist + // merge them into a struct. + for _, call := range c.Calls { + if call.Structured { + continue + } + if len(call.Normalized.Outputs) == 1 { + continue + } + // Build up dictionary of existing arg names. + keys := make(map[string]struct{}) + for _, o := range call.Normalized.Outputs { + if o.Name != "" { + keys[strings.ToLower(o.Name)] = struct{}{} + } + } + // Assign names to anonymous fields. + for i, o := range call.Normalized.Outputs { + if o.Name != "" { + continue + } + o.Name = capitalise(abi.ResolveNameConflict("arg", func(name string) bool { _, ok := keys[name]; return ok })) + call.Normalized.Outputs[i] = o + keys[strings.ToLower(o.Name)] = struct{}{} + } + call.Structured = true + } + } + buffer := new(bytes.Buffer) + funcs := map[string]interface{}{ + "bindtype": bindType[lang], + "bindtopictype": bindTopicType[lang], + "namedtype": namedType[lang], + "capitalise": capitalise, + "decapitalise": decapitalise, + } + tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSourceV2[lang])) + if err := tmpl.Execute(buffer, data); err != nil { + return "", err + } + // For Go bindings pass the code through gofmt to clean it up + if lang == LangGo { + code, err := format.Source(buffer.Bytes()) + if err != nil { + return "", fmt.Errorf("%v\n%s", err, buffer) + } + return string(code), nil + } + // For all others just return as is for now + return buffer.String(), nil +} + +func bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (*tmplData, error) { var ( // contracts is the map of each individual contract requested binding contracts = make(map[string]*tmplContract) @@ -96,7 +190,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] // Parse the actual ABI to generate the binding for evmABI, err := abi.JSON(strings.NewReader(abis[i])) if err != nil { - return "", err + return nil, err } // Strip any whitespace from the JSON ABI strippedABI := strings.Map(func(r rune) rune { @@ -147,7 +241,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] }) } if identifiers[normalizedName] { - return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + return nil, fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) } identifiers[normalizedName] = true @@ -198,7 +292,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] }) } if eventIdentifiers[normalizedName] { - return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + return nil, fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) } eventIdentifiers[normalizedName] = true normalized.Name = normalizedName @@ -233,6 +327,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] if evmABI.HasReceive() { receive = &tmplMethod{Original: evmABI.Receive} } + contracts[types[i]] = &tmplContract{ Type: capitalise(types[i]), InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), @@ -277,29 +372,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] Libraries: libs, Structs: structs, } - buffer := new(bytes.Buffer) - - funcs := map[string]interface{}{ - "bindtype": bindType[lang], - "bindtopictype": bindTopicType[lang], - "namedtype": namedType[lang], - "capitalise": capitalise, - "decapitalise": decapitalise, - } - tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang])) - if err := tmpl.Execute(buffer, data); err != nil { - return "", err - } - // For Go bindings pass the code through gofmt to clean it up - if lang == LangGo { - code, err := format.Source(buffer.Bytes()) - if err != nil { - return "", fmt.Errorf("%v\n%s", err, buffer) - } - return string(code), nil - } - // For all others just return as is for now - return buffer.String(), nil + return data, nil } // bindType is a set of type binders that convert Solidity types to some supported diff --git a/accounts/abi/bind/lib.go b/accounts/abi/bind/lib.go new file mode 100644 index 000000000000..27a8c604b26c --- /dev/null +++ b/accounts/abi/bind/lib.go @@ -0,0 +1,152 @@ +package bind + +import ( + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/event" +) + +func DeployContract2(opts *TransactOpts, bytecode []byte, input []byte, backend ContractBackend) (common.Address, *types.Transaction, error) { + c := NewBoundContract(common.Address{}, abi.ABI{}, backend, backend, backend) + tx, err := c.transact(opts, nil, append(bytecode, input...)) + if err != nil { + return common.Address{}, nil, err + } + address := crypto.CreateAddress(opts.From, tx.Nonce()) + return address, tx, nil +} + +func Call2[T any](opts *CallOpts, addr common.Address, input []byte, backend ContractBackend, unpack func([]byte) (T, error)) (arg T, err error) { + var data []byte + data, err = CallRaw(opts, addr, input, backend) + if err != nil { + return + } + return unpack(data) +} + +func CallRaw(opts *CallOpts, addr common.Address, input []byte, backend ContractBackend) ([]byte, error) { + c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) + return c.call(opts, input) +} + +func Transact2(opts *TransactOpts, addr common.Address, input []byte, backend ContractBackend) (*types.Transaction, error) { + c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) + return c.transact(opts, &addr, input) +} + +func Transfer2(opts *TransactOpts, addr common.Address, backend ContractBackend) (*types.Transaction, error) { + c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) + return c.Transfer(opts) +} + +func FilterLogs[T any](opts *FilterOpts, addr common.Address, backend ContractBackend, eventID common.Hash, unpack func(types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { + c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) + logs, sub, err := c.filterLogs(opts, eventID, topics...) + if err != nil { + return nil, err + } + return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil +} + +func WatchLogs[T any](opts *WatchOpts, addr common.Address, backend ContractBackend, eventID common.Hash, unpack func(types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { + c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) + logs, sub, err := c.watchLogs(opts, eventID, topics...) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + ev, err := unpack(log) + if err != nil { + return err + } + + select { + case sink <- ev: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// EventIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for events. +type EventIterator[T any] struct { + Event *T // Event containing the contract specifics and raw log + + unpack func(types.Log) (*T, error) // Unpack function for the event + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *EventIterator[T]) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + res, err := it.unpack(log) + if err != nil { + it.fail = err + return false + } + it.Event = res + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + res, err := it.unpack(log) + if err != nil { + it.fail = err + return false + } + it.Event = res + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *EventIterator[T]) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EventIterator[T]) Close() error { + it.sub.Unsubscribe() + return nil +} diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index 4a0062af0a80..f48d54e0567c 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -82,6 +82,10 @@ var tmplSource = map[Lang]string{ LangGo: tmplSourceGo, } +var tmplSourceV2 = map[Lang]string{ + LangGo: tmplSourceGoV2, +} + // tmplSourceGo is the Go source template that the generated Go contract binding // is based on. // diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go new file mode 100644 index 000000000000..23e3f9d2b33a --- /dev/null +++ b/accounts/abi/bind/template2.go @@ -0,0 +1,157 @@ +package bind + +// tmplSourceGo is the Go source template that the generated Go contract binding +// is based on. +const tmplSourceGoV2 = ` +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package {{.Package}} + +import ( + "fmt" + "math/big" + "strings" + "errors" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +{{$structs := .Structs}} +{{range $structs}} + // {{.Name}} is an auto generated low-level Go binding around an user-defined struct. + type {{.Name}} struct { + {{range $field := .Fields}} + {{$field.Name}} {{$field.Type}}{{end}} + } +{{end}} + +{{range $contract := .Contracts}} + // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract. + var {{.Type}}MetaData = &bind.MetaData{ + ABI: "{{.InputABI}}", + {{if $contract.FuncSigs -}} + Sigs: map[string]string{ + {{range $strsig, $binsig := .FuncSigs}}"{{$binsig}}": "{{$strsig}}", + {{end}} + }, + {{end -}} + {{if .InputBin -}} + Bin: "0x{{.InputBin}}", + {{end}} + } + + // {{.Type}} is an auto generated Go binding around an Ethereum contract. + type {{.Type}} struct { + abi abi.ABI + } + + // {{.Type}}Instance represents a deployed instance of the {{.Type}} contract. + type {{.Type}}Instance struct { + {{.Type}} + address common.Address + } + + func (i *{{$contract.Type}}Instance) Address() common.Address { + return i.address + } + + // New{{.Type}} creates a new instance of {{.Type}}. + func New{{.Type}}() (*{{.Type}}, error) { + parsed, err := {{.Type}}MetaData.GetAbi() + if err != nil { + return nil, err + } + + return &{{.Type}}{abi: *parsed}, nil + } + + func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ([]byte, error) { + return _{{$contract.Type}}.abi.Pack("" {{range .Constructor.Inputs}}, {{.Name}}{{end}}) + } + + {{range .Calls}} + // {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}) Pack{{.Normalized.Name}}({{range .Normalized.Inputs}} {{.Name}} {{bindtype .Type $structs}}, {{end}}) ([]byte, error) { + return _{{$contract.Type}}.abi.Pack("{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}}) + } + + func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}(data []byte) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) { + out, err := _{{$contract.Type}}.abi.Unpack("{{.Original.Name}}", data) + {{if .Structured}} + outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} }) + if err != nil { + return *outstruct, err + } + {{range $i, $t := .Normalized.Outputs}} + outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} + + return *outstruct, err + {{else}} + if err != nil { + return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err + } + {{range $i, $t := .Normalized.Outputs}} + out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} + + return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err + {{end}} + } + {{end}} + + {{range .Events}} + // {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} event raised by the {{$contract.Type}} contract. + type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}} + {{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}} + Raw types.Log // Blockchain specific contextual infos + } + func (_{{$contract.Type}} *{{$contract.Type}}) {{.Normalized.Name}}EventID() common.Hash { + return common.HexToHash("{{.Original.ID}}") + } + + func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { + event := "{{.Normalized.Name}}" + if log.Topics[0] != _{{$contract.Type}}.abi.Events[event].ID { + return nil, fmt.Errorf("event signature mismatch") + } + out := new({{$contract.Type}}{{.Normalized.Name}}) + if len(log.Data) > 0 { + if err := _{{$contract.Type}}.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _{{$contract.Type}}.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 + } + {{end}} +{{end}} +` diff --git a/cmd/abigen/main.go b/cmd/abigen/main.go index 0149dec52772..9f636292c394 100644 --- a/cmd/abigen/main.go +++ b/cmd/abigen/main.go @@ -72,6 +72,10 @@ var ( Name: "alias", Usage: "Comma separated aliases for function and event renaming, e.g. original1=alias1, original2=alias2", } + v2Flag = &cli.BoolFlag{ + Name: "v2", + Usage: "Generates v2 bindings", + } ) var app = flags.NewApp("Ethereum ABI wrapper code generator") @@ -88,6 +92,7 @@ func init() { outFlag, langFlag, aliasFlag, + v2Flag, } app.Action = abigen } @@ -216,7 +221,15 @@ func abigen(c *cli.Context) error { } } // Generate the contract binding - code, err := bind.Bind(types, abis, bins, sigs, c.String(pkgFlag.Name), lang, libs, aliases) + var ( + code string + err error + ) + if c.IsSet(v2Flag.Name) { + code, err = bind.BindV2(types, abis, bins, sigs, c.String(pkgFlag.Name), lang, libs, aliases) + } else { + code, err = bind.Bind(types, abis, bins, sigs, c.String(pkgFlag.Name), lang, libs, aliases) + } if err != nil { utils.Fatalf("Failed to generate ABI binding: %v", err) } From 7024b98da6a5d443c3f71820d0481f0ebd960745 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Wed, 1 Mar 2023 12:35:07 +0330 Subject: [PATCH 002/104] add copyright header to lib.go --- accounts/abi/bind/lib.go | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/accounts/abi/bind/lib.go b/accounts/abi/bind/lib.go index 27a8c604b26c..45cd0a412f1a 100644 --- a/accounts/abi/bind/lib.go +++ b/accounts/abi/bind/lib.go @@ -1,3 +1,19 @@ +// Copyright 2023 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + package bind import ( From cf6d5adcf4025da97b7ab23d3d3f783f663c2fb3 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Wed, 1 Mar 2023 13:07:00 +0330 Subject: [PATCH 003/104] drop unnecessary imports --- accounts/abi/bind/template2.go | 6 ------ 1 file changed, 6 deletions(-) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 23e3f9d2b33a..34ce763626ae 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -11,27 +11,21 @@ package {{.Package}} import ( "fmt" "math/big" - "strings" "errors" - ethereum "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" ) // Reference imports to suppress errors if they are not otherwise used. var ( _ = errors.New _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound _ = bind.Bind _ = common.Big1 _ = types.BloomLookup - _ = event.NewSubscription _ = abi.ConvertType ) From 8ad40f72eaf042cf4d35a37919fa34a42a53e984 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi <1591639+s1na@users.noreply.github.com> Date: Wed, 1 Mar 2023 13:03:08 +0330 Subject: [PATCH 004/104] replace fmt with errors Co-authored-by: Marius van der Wijden --- accounts/abi/bind/template2.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 34ce763626ae..bbd6d0ad6350 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -126,7 +126,7 @@ var ( func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { event := "{{.Normalized.Name}}" if log.Topics[0] != _{{$contract.Type}}.abi.Events[event].ID { - return nil, fmt.Errorf("event signature mismatch") + return nil, errors.New("event signature mismatch") } out := new({{$contract.Type}}{{.Normalized.Name}}) if len(log.Data) > 0 { From 33560ae103f6daae633ae6e5fda4edbd95e6e9a1 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Wed, 1 Mar 2023 13:09:28 +0330 Subject: [PATCH 005/104] drop fmt --- accounts/abi/bind/template2.go | 1 - 1 file changed, 1 deletion(-) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index bbd6d0ad6350..f5d41d2634fb 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -9,7 +9,6 @@ const tmplSourceGoV2 = ` package {{.Package}} import ( - "fmt" "math/big" "errors" From 6b37f7a8302a12c1d24a2c2a72de0a86693b42a3 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Wed, 1 Mar 2023 13:32:34 +0330 Subject: [PATCH 006/104] skip unpack method when no return args --- accounts/abi/bind/bind.go | 2 +- accounts/abi/bind/template2.go | 39 ++++++++++++++++++---------------- 2 files changed, 22 insertions(+), 19 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 4c4ad28173ea..94bc8c963ab8 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -129,7 +129,7 @@ func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[strin if call.Structured { continue } - if len(call.Normalized.Outputs) == 1 { + if len(call.Normalized.Outputs) < 2 { continue } // Build up dictionary of existing arg names. diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index f5d41d2634fb..8f40523cd59d 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -89,27 +89,30 @@ var ( return _{{$contract.Type}}.abi.Pack("{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}}) } - func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}(data []byte) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) { - out, err := _{{$contract.Type}}.abi.Unpack("{{.Original.Name}}", data) - {{if .Structured}} - outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} }) - if err != nil { + {{/* Unpack method is needed only when there are return args */}} + {{if .Normalized.Outputs }} + func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}(data []byte) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) { + out, err := _{{$contract.Type}}.abi.Unpack("{{.Original.Name}}", data) + {{if .Structured}} + outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} }) + if err != nil { + return *outstruct, err + } + {{range $i, $t := .Normalized.Outputs}} + outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} + return *outstruct, err - } - {{range $i, $t := .Normalized.Outputs}} - outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} + {{else}} + if err != nil { + return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err + } + {{range $i, $t := .Normalized.Outputs}} + out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} - return *outstruct, err - {{else}} - if err != nil { - return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err + return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err + {{end}} } - {{range $i, $t := .Normalized.Outputs}} - out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}} - - return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err - {{end}} - } + {{end}} {{end}} {{range .Events}} From 1da0b788fd699da36b26b6195b0d6d1721f398ba Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Wed, 1 Mar 2023 15:45:45 +0330 Subject: [PATCH 007/104] define contract instance type --- accounts/abi/bind/lib.go | 37 ++++++++++++++++++++++++---------- accounts/abi/bind/template2.go | 9 +++++++++ 2 files changed, 35 insertions(+), 11 deletions(-) diff --git a/accounts/abi/bind/lib.go b/accounts/abi/bind/lib.go index 45cd0a412f1a..0b9cc2bf1901 100644 --- a/accounts/abi/bind/lib.go +++ b/accounts/abi/bind/lib.go @@ -25,6 +25,13 @@ import ( "github.com/ethereum/go-ethereum/event" ) +// ContractInstance provides means to interact with +// a deployed contract. +type ContractInstance interface { + Address() common.Address + Backend() ContractBackend +} + func DeployContract2(opts *TransactOpts, bytecode []byte, input []byte, backend ContractBackend) (common.Address, *types.Transaction, error) { c := NewBoundContract(common.Address{}, abi.ABI{}, backend, backend, backend) tx, err := c.transact(opts, nil, append(bytecode, input...)) @@ -35,32 +42,39 @@ func DeployContract2(opts *TransactOpts, bytecode []byte, input []byte, backend return address, tx, nil } -func Call2[T any](opts *CallOpts, addr common.Address, input []byte, backend ContractBackend, unpack func([]byte) (T, error)) (arg T, err error) { +func Call2[T any](instance ContractInstance, opts *CallOpts, input []byte, unpack func([]byte) (T, error)) (arg T, err error) { var data []byte - data, err = CallRaw(opts, addr, input, backend) + data, err = CallRaw(instance, opts, input) if err != nil { return } return unpack(data) } -func CallRaw(opts *CallOpts, addr common.Address, input []byte, backend ContractBackend) ([]byte, error) { - c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) +func CallRaw(instance ContractInstance, opts *CallOpts, input []byte) ([]byte, error) { + backend := instance.Backend() + c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) return c.call(opts, input) } -func Transact2(opts *TransactOpts, addr common.Address, input []byte, backend ContractBackend) (*types.Transaction, error) { +func Transact2(instance ContractInstance, opts *TransactOpts, input []byte) (*types.Transaction, error) { + var ( + addr = instance.Address() + backend = instance.Backend() + ) c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) return c.transact(opts, &addr, input) } -func Transfer2(opts *TransactOpts, addr common.Address, backend ContractBackend) (*types.Transaction, error) { - c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) +func Transfer2(instance ContractInstance, opts *TransactOpts) (*types.Transaction, error) { + backend := instance.Backend() + c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) return c.Transfer(opts) } -func FilterLogs[T any](opts *FilterOpts, addr common.Address, backend ContractBackend, eventID common.Hash, unpack func(types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { - c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) +func FilterLogs[T any](instance ContractInstance, opts *FilterOpts, eventID common.Hash, unpack func(types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { + backend := instance.Backend() + c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) logs, sub, err := c.filterLogs(opts, eventID, topics...) if err != nil { return nil, err @@ -68,8 +82,9 @@ func FilterLogs[T any](opts *FilterOpts, addr common.Address, backend ContractBa return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil } -func WatchLogs[T any](opts *WatchOpts, addr common.Address, backend ContractBackend, eventID common.Hash, unpack func(types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { - c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) +func WatchLogs[T any](instance ContractInstance, opts *WatchOpts, eventID common.Hash, unpack func(types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { + backend := instance.Backend() + c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) logs, sub, err := c.watchLogs(opts, eventID, topics...) if err != nil { return nil, err diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 8f40523cd59d..4c5aae7654a8 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -61,12 +61,21 @@ var ( type {{.Type}}Instance struct { {{.Type}} address common.Address + backend bind.ContractBackend + } + + func New{{.Type}}Instance(c *{{.Type}}, address common.Address, backend bind.ContractBackend) *{{.Type}}Instance { + return &{{.Type}}Instance{Db: *c, address: address, backend: backend} } func (i *{{$contract.Type}}Instance) Address() common.Address { return i.address } + func (i *{{$contract.Type}}Instance) Backend() bind.ContractBackend { + return i.backend + } + // New{{.Type}} creates a new instance of {{.Type}}. func New{{.Type}}() (*{{.Type}}, error) { parsed, err := {{.Type}}MetaData.GetAbi() From 1850e4ac2bbb61c74c0e5a08e9e5466249cbddf0 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Thu, 2 Mar 2023 15:50:26 +0330 Subject: [PATCH 008/104] Add deploy code to contract struct --- accounts/abi/bind/template2.go | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 4c5aae7654a8..c5bd3a71b3ea 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -52,11 +52,6 @@ var ( {{end}} } - // {{.Type}} is an auto generated Go binding around an Ethereum contract. - type {{.Type}} struct { - abi abi.ABI - } - // {{.Type}}Instance represents a deployed instance of the {{.Type}} contract. type {{.Type}}Instance struct { {{.Type}} @@ -76,14 +71,24 @@ var ( return i.backend } + // {{.Type}} is an auto generated Go binding around an Ethereum contract. + type {{.Type}} struct { + abi abi.ABI + deployCode []byte + } + // New{{.Type}} creates a new instance of {{.Type}}. func New{{.Type}}() (*{{.Type}}, error) { - parsed, err := {{.Type}}MetaData.GetAbi() - if err != nil { - return nil, err - } + parsed, err := {{.Type}}MetaData.GetAbi() + if err != nil { + return nil, err + } + code := common.Hex2Bytes({{.Type}}MetaData.Bin) + return &{{.Type}}{abi: *parsed, deployCode: code}, nil + } - return &{{.Type}}{abi: *parsed}, nil + func (_{{$contract.Type}} *{{$contract.Type}}) DeployCode() []byte { + return _{{$contract.Type}}.deployCode } func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ([]byte, error) { From 4611b5c4aa9c02a8f9ebaff00957ebae98d53315 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Thu, 2 Mar 2023 15:59:01 +0330 Subject: [PATCH 009/104] Pass pointer to log for unpack --- accounts/abi/bind/lib.go | 12 ++++++------ accounts/abi/bind/template2.go | 5 +++-- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/accounts/abi/bind/lib.go b/accounts/abi/bind/lib.go index 0b9cc2bf1901..6d3ea71264a4 100644 --- a/accounts/abi/bind/lib.go +++ b/accounts/abi/bind/lib.go @@ -72,7 +72,7 @@ func Transfer2(instance ContractInstance, opts *TransactOpts) (*types.Transactio return c.Transfer(opts) } -func FilterLogs[T any](instance ContractInstance, opts *FilterOpts, eventID common.Hash, unpack func(types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { +func FilterLogs[T any](instance ContractInstance, opts *FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { backend := instance.Backend() c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) logs, sub, err := c.filterLogs(opts, eventID, topics...) @@ -82,7 +82,7 @@ func FilterLogs[T any](instance ContractInstance, opts *FilterOpts, eventID comm return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil } -func WatchLogs[T any](instance ContractInstance, opts *WatchOpts, eventID common.Hash, unpack func(types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { +func WatchLogs[T any](instance ContractInstance, opts *WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { backend := instance.Backend() c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) logs, sub, err := c.watchLogs(opts, eventID, topics...) @@ -95,7 +95,7 @@ func WatchLogs[T any](instance ContractInstance, opts *WatchOpts, eventID common select { case log := <-logs: // New log arrived, parse the event and forward to the user - ev, err := unpack(log) + ev, err := unpack(&log) if err != nil { return err } @@ -120,7 +120,7 @@ func WatchLogs[T any](instance ContractInstance, opts *WatchOpts, eventID common type EventIterator[T any] struct { Event *T // Event containing the contract specifics and raw log - unpack func(types.Log) (*T, error) // Unpack function for the event + unpack func(*types.Log) (*T, error) // Unpack function for the event logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination @@ -140,7 +140,7 @@ func (it *EventIterator[T]) Next() bool { if it.done { select { case log := <-it.logs: - res, err := it.unpack(log) + res, err := it.unpack(&log) if err != nil { it.fail = err return false @@ -155,7 +155,7 @@ func (it *EventIterator[T]) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - res, err := it.unpack(log) + res, err := it.unpack(&log) if err != nil { it.fail = err return false diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index c5bd3a71b3ea..f9e53d65eae0 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -133,13 +133,14 @@ var ( // {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} event raised by the {{$contract.Type}} contract. type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}} {{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}} - Raw types.Log // Blockchain specific contextual infos + Raw *types.Log // Blockchain specific contextual infos } + func (_{{$contract.Type}} *{{$contract.Type}}) {{.Normalized.Name}}EventID() common.Hash { return common.HexToHash("{{.Original.ID}}") } - func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { + func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log *types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { event := "{{.Normalized.Name}}" if log.Topics[0] != _{{$contract.Type}}.abi.Events[event].ID { return nil, errors.New("event signature mismatch") From a31d1914eca14a5676f298fa4c282e9a9aad1121 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Thu, 2 Mar 2023 16:35:06 +0330 Subject: [PATCH 010/104] clean lang selection leftovers --- accounts/abi/bind/bind.go | 141 +++++++++++---------------------- accounts/abi/bind/template.go | 14 +--- accounts/abi/bind/template2.go | 6 +- cmd/abigen/main.go | 17 +--- 4 files changed, 52 insertions(+), 126 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 94bc8c963ab8..53f7e9dace5c 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -33,13 +33,6 @@ import ( "github.com/ethereum/go-ethereum/log" ) -// Lang is a target programming language selector to generate bindings for. -type Lang int - -const ( - LangGo Lang = iota -) - func isKeyWord(arg string) bool { switch arg { case "break": @@ -81,38 +74,33 @@ func isKeyWord(arg string) bool { // to be used as is in client code, but rather as an intermediate struct which // enforces compile time type safety and naming convention as opposed to having to // manually maintain hard coded strings that break on runtime. -func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (string, error) { - data, err := bind(types, abis, bytecodes, fsigs, pkg, lang, libs, aliases) +func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { + data, err := bind(types, abis, bytecodes, fsigs, pkg, libs, aliases) if err != nil { return "", err } buffer := new(bytes.Buffer) funcs := map[string]interface{}{ - "bindtype": bindType[lang], - "bindtopictype": bindTopicType[lang], - "namedtype": namedType[lang], + "bindtype": bindType, + "bindtopictype": bindTopicType, "capitalise": capitalise, "decapitalise": decapitalise, } - tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang])) + tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource)) if err := tmpl.Execute(buffer, data); err != nil { return "", err } - // For Go bindings pass the code through gofmt to clean it up - if lang == LangGo { - code, err := format.Source(buffer.Bytes()) - if err != nil { - return "", fmt.Errorf("%v\n%s", err, buffer) - } - return string(code), nil + // Pass the code through gofmt to clean it up + code, err := format.Source(buffer.Bytes()) + if err != nil { + return "", fmt.Errorf("%v\n%s", err, buffer) } - // For all others just return as is for now - return buffer.String(), nil + return string(code), nil } -func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (string, error) { - data, err := bind(types, abis, bytecodes, fsigs, pkg, lang, libs, aliases) +func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { + data, err := bind(types, abis, bytecodes, fsigs, pkg, libs, aliases) if err != nil { return "", err } @@ -153,29 +141,24 @@ func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[strin } buffer := new(bytes.Buffer) funcs := map[string]interface{}{ - "bindtype": bindType[lang], - "bindtopictype": bindTopicType[lang], - "namedtype": namedType[lang], + "bindtype": bindType, + "bindtopictype": bindTopicType, "capitalise": capitalise, "decapitalise": decapitalise, } - tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSourceV2[lang])) + tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSourceV2)) if err := tmpl.Execute(buffer, data); err != nil { return "", err } - // For Go bindings pass the code through gofmt to clean it up - if lang == LangGo { - code, err := format.Source(buffer.Bytes()) - if err != nil { - return "", fmt.Errorf("%v\n%s", err, buffer) - } - return string(code), nil + // Pass the code through gofmt to clean it up + code, err := format.Source(buffer.Bytes()) + if err != nil { + return "", fmt.Errorf("%v\n%s", err, buffer) } - // For all others just return as is for now - return buffer.String(), nil + return string(code), nil } -func bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string, aliases map[string]string) (*tmplData, error) { +func bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (*tmplData, error) { var ( // contracts is the map of each individual contract requested binding contracts = make(map[string]*tmplContract) @@ -219,14 +202,14 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] for _, input := range evmABI.Constructor.Inputs { if hasStruct(input.Type) { - bindStructType[lang](input.Type, structs) + bindStructType(input.Type, structs) } } for _, original := range evmABI.Methods { // Normalize the method for capital cases and non-anonymous inputs/outputs normalized := original - normalizedName := methodNormalizer[lang](alias(aliases, original.Name)) + normalizedName := methodNormalizer(alias(aliases, original.Name)) // Ensure there is no duplicated identifier var identifiers = callIdentifiers if !original.IsConstant() { @@ -253,7 +236,7 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) } if hasStruct(input.Type) { - bindStructType[lang](input.Type, structs) + bindStructType(input.Type, structs) } } normalized.Outputs = make([]abi.Argument, len(original.Outputs)) @@ -263,7 +246,7 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] normalized.Outputs[j].Name = capitalise(output.Name) } if hasStruct(output.Type) { - bindStructType[lang](output.Type, structs) + bindStructType(output.Type, structs) } } // Append the methods to the call or transact lists @@ -282,15 +265,7 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] normalized := original // Ensure there is no duplicated identifier - normalizedName := methodNormalizer[lang](alias(aliases, original.Name)) - // Name shouldn't start with a digit. It will make the generated code invalid. - if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { - normalizedName = fmt.Sprintf("E%s", normalizedName) - normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { - _, ok := eventIdentifiers[name] - return ok - }) - } + normalizedName := methodNormalizer(alias(aliases, original.Name)) if eventIdentifiers[normalizedName] { return nil, fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) } @@ -314,7 +289,7 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index) } if hasStruct(input.Type) { - bindStructType[lang](input.Type, structs) + bindStructType(input.Type, structs) } } // Append the event to the accumulator list @@ -375,14 +350,8 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] return data, nil } -// bindType is a set of type binders that convert Solidity types to some supported -// programming language types. -var bindType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{ - LangGo: bindTypeGo, -} - -// bindBasicTypeGo converts basic solidity types(except array, slice and tuple) to Go ones. -func bindBasicTypeGo(kind abi.Type) string { +// bindBasicType converts basic solidity types(except array, slice and tuple) to Go ones. +func bindBasicType(kind abi.Type) string { switch kind.T { case abi.AddressTy: return "common.Address" @@ -405,32 +374,26 @@ func bindBasicTypeGo(kind abi.Type) string { } } -// bindTypeGo converts solidity types to Go ones. Since there is no clear mapping +// bindType converts solidity types to Go ones. Since there is no clear mapping // from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly // mapped will use an upscaled type (e.g. BigDecimal). -func bindTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { +func bindType(kind abi.Type, structs map[string]*tmplStruct) string { switch kind.T { case abi.TupleTy: return structs[kind.TupleRawName+kind.String()].Name case abi.ArrayTy: - return fmt.Sprintf("[%d]", kind.Size) + bindTypeGo(*kind.Elem, structs) + return fmt.Sprintf("[%d]", kind.Size) + bindType(*kind.Elem, structs) case abi.SliceTy: - return "[]" + bindTypeGo(*kind.Elem, structs) + return "[]" + bindType(*kind.Elem, structs) default: - return bindBasicTypeGo(kind) + return bindBasicType(kind) } } -// bindTopicType is a set of type binders that convert Solidity types to some -// supported programming language topic types. -var bindTopicType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{ - LangGo: bindTopicTypeGo, -} - -// bindTopicTypeGo converts a Solidity topic type to a Go one. It is almost the same +// bindTopicType converts a Solidity topic type to a Go one. It is almost the same // functionality as for simple types, but dynamic types get converted to hashes. -func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { - bound := bindTypeGo(kind, structs) +func bindTopicType(kind abi.Type, structs map[string]*tmplStruct) string { + bound := bindType(kind, structs) // todo(rjl493456442) according solidity documentation, indexed event // parameters that are not value types i.e. arrays and structs are not @@ -444,16 +407,10 @@ func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { return bound } -// bindStructType is a set of type binders that convert Solidity tuple types to some supported -// programming language struct definition. -var bindStructType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{ - LangGo: bindStructTypeGo, -} - -// bindStructTypeGo converts a Solidity tuple type to a Go one and records the mapping +// bindStructType converts a Solidity tuple type to a Go one and records the mapping // in the given map. // Notably, this function will resolve and record nested struct recursively. -func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { +func bindStructType(kind abi.Type, structs map[string]*tmplStruct) string { switch kind.T { case abi.TupleTy: // We compose a raw struct name and a canonical parameter expression @@ -474,7 +431,7 @@ func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { name := capitalise(kind.TupleRawNames[i]) name = abi.ResolveNameConflict(name, func(s string) bool { return names[s] }) names[name] = true - fields = append(fields, &tmplField{Type: bindStructTypeGo(*elem, structs), Name: name, SolKind: *elem}) + fields = append(fields, &tmplField{Type: bindStructType(*elem, structs), Name: name, SolKind: *elem}) } name := kind.TupleRawName if name == "" { @@ -488,20 +445,14 @@ func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string { } return name case abi.ArrayTy: - return fmt.Sprintf("[%d]", kind.Size) + bindStructTypeGo(*kind.Elem, structs) + return fmt.Sprintf("[%d]", kind.Size) + bindStructType(*kind.Elem, structs) case abi.SliceTy: - return "[]" + bindStructTypeGo(*kind.Elem, structs) + return "[]" + bindStructType(*kind.Elem, structs) default: - return bindBasicTypeGo(kind) + return bindBasicType(kind) } } -// namedType is a set of functions that transform language specific types to -// named versions that may be used inside method names. -var namedType = map[Lang]func(string, abi.Type) string{ - LangGo: func(string, abi.Type) string { panic("this shouldn't be needed") }, -} - // alias returns an alias of the given string based on the aliasing rules // or returns itself if no rule is matched. func alias(aliases map[string]string, n string) string { @@ -512,10 +463,8 @@ func alias(aliases map[string]string, n string) string { } // methodNormalizer is a name transformer that modifies Solidity method names to -// conform to target language naming conventions. -var methodNormalizer = map[Lang]func(string) string{ - LangGo: abi.ToCamelCase, -} +// conform to Go naming conventions. +var methodNormalizer = abi.ToCamelCase // capitalise makes a camel-case string which starts with an upper case character. var capitalise = abi.ToCamelCase diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index f48d54e0567c..fa7528106903 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -76,18 +76,8 @@ type tmplStruct struct { Fields []*tmplField // Struct fields definition depends on the binding language. } -// tmplSource is language to template mapping containing all the supported -// programming languages the package can generate to. -var tmplSource = map[Lang]string{ - LangGo: tmplSourceGo, -} - -var tmplSourceV2 = map[Lang]string{ - LangGo: tmplSourceGoV2, -} - -// tmplSourceGo is the Go source template that the generated Go contract binding +// tmplSource is the Go source template that the generated Go contract binding // is based on. // //go:embed source.go.tpl -var tmplSourceGo string +var tmplSource string diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index f9e53d65eae0..f4acbd9b4793 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -1,8 +1,8 @@ package bind -// tmplSourceGo is the Go source template that the generated Go contract binding -// is based on. -const tmplSourceGoV2 = ` +// tmplSourceV2 is the Go source template that the generated +// Go contract binding V2 is based on. +const tmplSourceV2 = ` // Code generated via abigen V2 - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. diff --git a/cmd/abigen/main.go b/cmd/abigen/main.go index 9f636292c394..c182c42ab26c 100644 --- a/cmd/abigen/main.go +++ b/cmd/abigen/main.go @@ -63,11 +63,6 @@ var ( Name: "out", Usage: "Output file for the generated binding (default = stdout)", } - langFlag = &cli.StringFlag{ - Name: "lang", - Usage: "Destination language for the bindings (go)", - Value: "go", - } aliasFlag = &cli.StringFlag{ Name: "alias", Usage: "Comma separated aliases for function and event renaming, e.g. original1=alias1, original2=alias2", @@ -90,7 +85,6 @@ func init() { excFlag, pkgFlag, outFlag, - langFlag, aliasFlag, v2Flag, } @@ -103,13 +97,6 @@ func abigen(c *cli.Context) error { if c.String(pkgFlag.Name) == "" { utils.Fatalf("No destination package specified (--pkg)") } - var lang bind.Lang - switch c.String(langFlag.Name) { - case "go": - lang = bind.LangGo - default: - utils.Fatalf("Unsupported destination language \"%s\" (--lang)", c.String(langFlag.Name)) - } // If the entire solidity code was specified, build and bind based on that var ( abis []string @@ -226,9 +213,9 @@ func abigen(c *cli.Context) error { err error ) if c.IsSet(v2Flag.Name) { - code, err = bind.BindV2(types, abis, bins, sigs, c.String(pkgFlag.Name), lang, libs, aliases) + code, err = bind.BindV2(types, abis, bins, sigs, c.String(pkgFlag.Name), libs, aliases) } else { - code, err = bind.Bind(types, abis, bins, sigs, c.String(pkgFlag.Name), lang, libs, aliases) + code, err = bind.Bind(types, abis, bins, sigs, c.String(pkgFlag.Name), libs, aliases) } if err != nil { utils.Fatalf("Failed to generate ABI binding: %v", err) From 2cdb4ccc2ad8267024eeaac5fa2a4428c404e538 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Fri, 3 Mar 2023 12:59:50 +0330 Subject: [PATCH 011/104] fix test --- accounts/abi/bind/bind_test.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go index a390a3c47c7e..16b5c4f12af7 100644 --- a/accounts/abi/bind/bind_test.go +++ b/accounts/abi/bind/bind_test.go @@ -2072,8 +2072,7 @@ var bindTests = []struct { // Tests that packages generated by the binder can be successfully compiled and // the requested tester run against it. -func TestGolangBindings(t *testing.T) { - t.Parallel() +func TestBindings(t *testing.T) { // Skip the test if no Go command can be found gocmd := runtime.GOROOT() + "/bin/go" if !common.FileExist(gocmd) { @@ -2096,7 +2095,7 @@ func TestGolangBindings(t *testing.T) { types = []string{tt.name} } // Generate the binding and create a Go source file in the workspace - bind, err := Bind(types, tt.abi, tt.bytecode, tt.fsigs, "bindtest", LangGo, tt.libs, tt.aliases) + bind, err := Bind(types, tt.abi, tt.bytecode, tt.fsigs, "bindtest", tt.libs, tt.aliases) if err != nil { t.Fatalf("test %d: failed to generate binding: %v", i, err) } From fe2c5b3d094066589c0f82d3b666eec9c2bf6561 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 31 Oct 2024 15:04:53 +0900 Subject: [PATCH 012/104] add back code that got mistakenly removed in the rebase --- accounts/abi/bind/bind.go | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 53f7e9dace5c..d5aab35a5dcd 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -266,6 +266,14 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] // Ensure there is no duplicated identifier normalizedName := methodNormalizer(alias(aliases, original.Name)) + // Name shouldn't start with a digit. It will make the generated code invalid. + if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { + normalizedName = fmt.Sprintf("E%s", normalizedName) + normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { + _, ok := eventIdentifiers[name] + return ok + }) + } if eventIdentifiers[normalizedName] { return nil, fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) } From 6b8e25e28d6079cd280c2614b3094aa0f1a40c7b Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 31 Oct 2024 15:31:06 +0900 Subject: [PATCH 013/104] fix last rebase regression --- accounts/abi/bind/bind_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go index 16b5c4f12af7..a1533f689a16 100644 --- a/accounts/abi/bind/bind_test.go +++ b/accounts/abi/bind/bind_test.go @@ -2073,6 +2073,7 @@ var bindTests = []struct { // Tests that packages generated by the binder can be successfully compiled and // the requested tester run against it. func TestBindings(t *testing.T) { + t.Parallel() // Skip the test if no Go command can be found gocmd := runtime.GOROOT() + "/bin/go" if !common.FileExist(gocmd) { From fc979153dbdf0f7c231d7d0f5af44feacc6b4633 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 4 Nov 2024 19:32:26 +0900 Subject: [PATCH 014/104] isolate V2 contract interaction API into its own package --- accounts/abi/bind/v2/lib.go | 135 ++++++++++++++++++++++++++++++++++++ 1 file changed, 135 insertions(+) create mode 100644 accounts/abi/bind/v2/lib.go diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go new file mode 100644 index 000000000000..bd66202bef6e --- /dev/null +++ b/accounts/abi/bind/v2/lib.go @@ -0,0 +1,135 @@ +package v2 + +import ( + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +func FilterLogs[T any](instance bind.ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { + backend := instance.Backend() + c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) + logs, sub, err := c.FilterLogs(opts, eventID.String(), topics...) + if err != nil { + return nil, err + } + return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil +} + +func WatchLogs[T any](instance bind.ContractInstance, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { + backend := instance.Backend() + c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) + logs, sub, err := c.WatchLogs(opts, eventID.String(), topics...) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + ev, err := unpack(&log) + if err != nil { + return err + } + + select { + case sink <- ev: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// EventIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for events. +type EventIterator[T any] struct { + Event *T // Event containing the contract specifics and raw log + + unpack func(*types.Log) (*T, error) // Unpack function for the event + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *EventIterator[T]) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + res, err := it.unpack(&log) + if err != nil { + it.fail = err + return false + } + it.Event = res + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + res, err := it.unpack(&log) + if err != nil { + it.fail = err + return false + } + it.Event = res + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *EventIterator[T]) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EventIterator[T]) Close() error { + it.sub.Unsubscribe() + return nil +} + +func Transact(instance bind.ContractInstance, opts *bind.TransactOpts, input []byte) (*types.Transaction, error) { + var ( + addr = instance.Address() + backend = instance.Backend() + ) + c := bind.NewBoundContract(addr, abi.ABI{}, backend, backend, backend) + return c.RawTransact(opts, input) +} + +func Transfer(instance bind.ContractInstance, opts *bind.TransactOpts) (*types.Transaction, error) { + backend := instance.Backend() + c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) + return c.Transfer(opts) +} From cbdec2a0cf02eeaaee642775e1c2e7bec9a0dcc0 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 4 Nov 2024 22:50:47 +0900 Subject: [PATCH 015/104] move v2 contract interaction methods into v2 package. add test --- accounts/abi/bind/lib.go | 148 -------------------------------- accounts/abi/bind/v2/v2_test.go | 145 +++++++++++++++++++++++++++++++ 2 files changed, 145 insertions(+), 148 deletions(-) create mode 100644 accounts/abi/bind/v2/v2_test.go diff --git a/accounts/abi/bind/lib.go b/accounts/abi/bind/lib.go index 6d3ea71264a4..7570665f87bd 100644 --- a/accounts/abi/bind/lib.go +++ b/accounts/abi/bind/lib.go @@ -17,12 +17,8 @@ package bind import ( - "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/event" ) // ContractInstance provides means to interact with @@ -32,152 +28,8 @@ type ContractInstance interface { Backend() ContractBackend } -func DeployContract2(opts *TransactOpts, bytecode []byte, input []byte, backend ContractBackend) (common.Address, *types.Transaction, error) { - c := NewBoundContract(common.Address{}, abi.ABI{}, backend, backend, backend) - tx, err := c.transact(opts, nil, append(bytecode, input...)) - if err != nil { - return common.Address{}, nil, err - } - address := crypto.CreateAddress(opts.From, tx.Nonce()) - return address, tx, nil -} - -func Call2[T any](instance ContractInstance, opts *CallOpts, input []byte, unpack func([]byte) (T, error)) (arg T, err error) { - var data []byte - data, err = CallRaw(instance, opts, input) - if err != nil { - return - } - return unpack(data) -} - func CallRaw(instance ContractInstance, opts *CallOpts, input []byte) ([]byte, error) { backend := instance.Backend() c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) return c.call(opts, input) } - -func Transact2(instance ContractInstance, opts *TransactOpts, input []byte) (*types.Transaction, error) { - var ( - addr = instance.Address() - backend = instance.Backend() - ) - c := NewBoundContract(addr, abi.ABI{}, backend, backend, backend) - return c.transact(opts, &addr, input) -} - -func Transfer2(instance ContractInstance, opts *TransactOpts) (*types.Transaction, error) { - backend := instance.Backend() - c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) - return c.Transfer(opts) -} - -func FilterLogs[T any](instance ContractInstance, opts *FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { - backend := instance.Backend() - c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) - logs, sub, err := c.filterLogs(opts, eventID, topics...) - if err != nil { - return nil, err - } - return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil -} - -func WatchLogs[T any](instance ContractInstance, opts *WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { - backend := instance.Backend() - c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) - logs, sub, err := c.watchLogs(opts, eventID, topics...) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - ev, err := unpack(&log) - if err != nil { - return err - } - - select { - case sink <- ev: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// EventIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for events. -type EventIterator[T any] struct { - Event *T // Event containing the contract specifics and raw log - - unpack func(*types.Log) (*T, error) // Unpack function for the event - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *EventIterator[T]) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - res, err := it.unpack(&log) - if err != nil { - it.fail = err - return false - } - it.Event = res - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - res, err := it.unpack(&log) - if err != nil { - it.fail = err - return false - } - it.Event = res - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *EventIterator[T]) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *EventIterator[T]) Close() error { - it.sub.Unsubscribe() - return nil -} diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go new file mode 100644 index 000000000000..a6d16806f739 --- /dev/null +++ b/accounts/abi/bind/v2/v2_test.go @@ -0,0 +1,145 @@ +package v2 + +import ( + "context" + "encoding/json" + "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" + "io" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient/simulated" + "github.com/ethereum/go-ethereum/params" + "math/big" + "strings" + "testing" +) + +const deployer = "6080604052348015600e575f80fd5b506102098061001c5f395ff3fe608060405234801561000f575f80fd5b506004361061003f575f3560e01c80636da1cd55146100435780637b0cb83914610061578063bf54fad41461006b575b5f80fd5b61004b610087565b60405161005891906100e9565b60405180910390f35b61006961008f565b005b61008560048036038101906100809190610130565b6100c8565b005b5f8054905090565b607b7f72c79b1cb25b1b49ae522446226e1591b80634619cef7e71846da52b61b7061d6040516100be906101b5565b60405180910390a2565b805f8190555050565b5f819050919050565b6100e3816100d1565b82525050565b5f6020820190506100fc5f8301846100da565b92915050565b5f80fd5b61010f816100d1565b8114610119575f80fd5b50565b5f8135905061012a81610106565b92915050565b5f6020828403121561014557610144610102565b5b5f6101528482850161011c565b91505092915050565b5f82825260208201905092915050565b7f737472696e6700000000000000000000000000000000000000000000000000005f82015250565b5f61019f60068361015b565b91506101aa8261016b565b602082019050919050565b5f6020820190508181035f8301526101cc81610193565b905091905056fea2646970667358221220212a3a765a98254b596386fdfd10318f9a4bf19e8c9ca9ffa363f990c1798bf664736f6c634300081a0033" + +const contractABIStr = ` +[ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "firstArg", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "string", + "name": "secondArg", + "type": "string" + } + ], + "name": "ExampleEvent", + "type": "event" + }, + { + "inputs": [], + "name": "emitEvent", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "num", + "type": "uint256" + } + ], + "name": "mutateStorageVal", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "retrieveStorageVal", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + } +] +` + +var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + +// JSON returns a parsed ABI interface and error if it failed. +func JSON(reader io.Reader) (abi.ABI, error) { + dec := json.NewDecoder(reader) + + var instance abi.ABI + if err := dec.Decode(&instance); err != nil { + return abi.ABI{}, err + } + return instance, nil +} + +func TestV2(t *testing.T) { + testAddr := crypto.PubkeyToAddress(testKey.PublicKey) + backend := simulated.NewBackend( + types.GenesisAlloc{ + testAddr: {Balance: big.NewInt(10000000000000000)}, + }, + ) + defer backend.Close() + + contractABI, err := JSON(strings.NewReader(contractABIStr)) + if err != nil { + panic(err) + } + + signer := types.LatestSigner(params.AllDevChainProtocolChanges) + opts := bind.TransactOpts{ + From: testAddr, + Nonce: nil, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + signature, err := crypto.Sign(signer.Hash(tx).Bytes(), testKey) + if err != nil { + t.Fatal(err) + } + signedTx, err := tx.WithSignature(signer, signature) + if err != nil { + t.Fatal(err) + } + return signedTx, nil + }, + Context: context.Background(), + /* + Value: nil, + GasPrice: nil, + GasFeeCap: nil, + GasTipCap: nil, + GasLimit: 0, + AccessList: nil, + NoSend: false, + */ + } + // we should just be able to use the backend directly, instead of using + // this deprecated interface. However, the simulated backend no longer + // implements backends.SimulatedBackend... + bindBackend := backends.SimulatedBackend{ + Backend: backend, + Client: backend.Client(), + } + _, _, _, err = bind.DeployContract(&opts, contractABI, common.Hex2Bytes(deployer), &bindBackend) + if err != nil { + t.Fatal(err) + } + // send a balance to our contract (contract must accept ether by default) +} From 379f1524a36f436beb5faad0036927bfb6554580 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 6 Nov 2024 22:28:54 +0900 Subject: [PATCH 016/104] stage point before I try to dedup contract interaction api --- accounts/abi/abi.go | 1 + accounts/abi/bind/lib.go | 4 + accounts/abi/bind/template2.go | 13 +- accounts/abi/bind/v2/backend.go | 20 ++++ accounts/abi/bind/v2/lib.go | 205 +++++++++++++++++++++++++++++++- accounts/abi/bind/v2/v2_test.go | 97 +++++---------- 6 files changed, 257 insertions(+), 83 deletions(-) create mode 100644 accounts/abi/bind/v2/backend.go diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go index f75278c8b101..f92dd6c2c69c 100644 --- a/accounts/abi/abi.go +++ b/accounts/abi/abi.go @@ -50,6 +50,7 @@ func JSON(reader io.Reader) (ABI, error) { var abi ABI if err := dec.Decode(&abi); err != nil { + fmt.Println(err) return ABI{}, err } return abi, nil diff --git a/accounts/abi/bind/lib.go b/accounts/abi/bind/lib.go index 7570665f87bd..6d6dd7b52e59 100644 --- a/accounts/abi/bind/lib.go +++ b/accounts/abi/bind/lib.go @@ -28,6 +28,10 @@ type ContractInstance interface { Backend() ContractBackend } +type ContractInstanceV2 interface { + Address() common.Address +} + func CallRaw(instance ContractInstance, opts *CallOpts, input []byte) ([]byte, error) { backend := instance.Backend() c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index f4acbd9b4793..85f83605d951 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -55,22 +55,17 @@ var ( // {{.Type}}Instance represents a deployed instance of the {{.Type}} contract. type {{.Type}}Instance struct { {{.Type}} - address common.Address - backend bind.ContractBackend + address common.Address // consider removing this, not clear what it's used for now (and why did we need custom deploy method on previous abi?) } - func New{{.Type}}Instance(c *{{.Type}}, address common.Address, backend bind.ContractBackend) *{{.Type}}Instance { - return &{{.Type}}Instance{Db: *c, address: address, backend: backend} + func New{{.Type}}Instance(c *{{.Type}}, address common.Address) *{{.Type}}Instance { + return &{{.Type}}Instance{ {{$contract.Type}}: *c, address: address} } func (i *{{$contract.Type}}Instance) Address() common.Address { return i.address } - func (i *{{$contract.Type}}Instance) Backend() bind.ContractBackend { - return i.backend - } - // {{.Type}} is an auto generated Go binding around an Ethereum contract. type {{.Type}} struct { abi abi.ABI @@ -136,7 +131,7 @@ var ( Raw *types.Log // Blockchain specific contextual infos } - func (_{{$contract.Type}} *{{$contract.Type}}) {{.Normalized.Name}}EventID() common.Hash { + func {{$contract.Type}}{{.Normalized.Name}}EventID() common.Hash { return common.HexToHash("{{.Original.ID}}") } diff --git a/accounts/abi/bind/v2/backend.go b/accounts/abi/bind/v2/backend.go new file mode 100644 index 000000000000..73b420a27e5f --- /dev/null +++ b/accounts/abi/bind/v2/backend.go @@ -0,0 +1,20 @@ +package v2 + +import ( + "context" + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "math/big" +) + +type V2Backend interface { + SuggestGasPrice(ctx context.Context) (*big.Int, error) + PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) + PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) + SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) + HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) + SendTransaction(ctx context.Context, tx *types.Transaction) error + SuggestGasTipCap(ctx context.Context) (*big.Int, error) + EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error) +} diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index bd66202bef6e..9b350fb4a349 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -1,12 +1,16 @@ package v2 import ( + "context" + "errors" + "fmt" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/event" + "math/big" ) func FilterLogs[T any](instance bind.ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { @@ -19,10 +23,44 @@ func FilterLogs[T any](instance bind.ContractInstance, opts *bind.FilterOpts, ev return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil } -func WatchLogs[T any](instance bind.ContractInstance, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { - backend := instance.Backend() - c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) - logs, sub, err := c.WatchLogs(opts, eventID.String(), topics...) +// WatchOpts is the collection of options to fine tune subscribing for events +// within a bound contract. +type WatchOpts struct { + Start *uint64 // Start of the queried range (nil = latest) + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +func watchLogs(backend V2Backend, address common.Address, opts *WatchOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + // Don't crash on a lazy user + if opts == nil { + opts = new(WatchOpts) + } + // Append the event selector to the query parameters and construct the topic set + query = append([][]interface{}{{eventID}}, query...) + + topics, err := abi.MakeTopics(query...) + if err != nil { + return nil, nil, err + } + // Start the background filtering + logs := make(chan types.Log, 128) + + config := ethereum.FilterQuery{ + Addresses: []common.Address{address}, + Topics: topics, + } + if opts.Start != nil { + config.FromBlock = new(big.Int).SetUint64(*opts.Start) + } + sub, err := backend.SubscribeFilterLogs(ensureContext(opts.Context), config, logs) + if err != nil { + return nil, nil, err + } + return logs, sub, nil +} + +func WatchLogs[T any](address common.Address, backend V2Backend, opts *WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { + logs, sub, err := watchLogs(backend, address, opts, eventID, topics...) if err != nil { return nil, err } @@ -128,6 +166,165 @@ func Transact(instance bind.ContractInstance, opts *bind.TransactOpts, input []b return c.RawTransact(opts, input) } +// ensureContext is a helper method to ensure a context is not nil, even if the +// user specified it as such. +func ensureContext(ctx context.Context) context.Context { + if ctx == nil { + return context.Background() + } + return ctx +} + +// SignerFn is a signer function callback when a contract requires a method to +// sign the transaction before submission. +type SignerFn func(common.Address, *types.Transaction) (*types.Transaction, error) + +// TransactOpts is the collection of authorization data required to create a +// valid Ethereum transaction. +type TransactOpts struct { + From common.Address // Ethereum account to send the transaction from + Nonce *big.Int // Nonce to use for the transaction execution (nil = use pending state) + Signer SignerFn // Method to use for signing the transaction (mandatory) + + Value *big.Int // Funds to transfer along the transaction (nil = 0 = no funds) + GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) + GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle) + GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle) + GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate) + AccessList types.AccessList // Access list to set for the transaction execution (nil = no access list) + + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) + + NoSend bool // Do all transact steps but do not send the transaction +} + +func estimateGasLimit(backend V2Backend, address common.Hash, opts *TransactOpts, contract *common.Address, input []byte, gasPrice, gasTipCap, gasFeeCap, value *big.Int) (uint64, error) { + if contract != nil { + // Gas estimation cannot succeed without code for method invocations. + if code, err := backend.PendingCodeAt(ensureContext(opts.Context), address); err != nil { + return 0, err + } else if len(code) == 0 { + return 0, ErrNoCode + } + } + msg := ethereum.CallMsg{ + From: opts.From, + To: contract, + GasPrice: gasPrice, + GasTipCap: gasTipCap, + GasFeeCap: gasFeeCap, + Value: value, + Data: input, + } + return backend.EstimateGas(ensureContext(opts.Context), msg) +} + +func getNonce(backend V2Backend, opts *TransactOpts) (uint64, error) { + if opts.Nonce == nil { + return backend.PendingNonceAt(ensureContext(opts.Context), opts.From) + } else { + return opts.Nonce.Uint64(), nil + } +} + +func createLegacyTx(backend V2Backend, address common.Hash, opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) { + if opts.GasFeeCap != nil || opts.GasTipCap != nil || opts.AccessList != nil { + return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas or accessList specified but london is not active yet") + } + // Normalize value + value := opts.Value + if value == nil { + value = new(big.Int) + } + // Estimate GasPrice + gasPrice := opts.GasPrice + if gasPrice == nil { + price, err := backend.SuggestGasPrice(ensureContext(opts.Context)) + if err != nil { + return nil, err + } + gasPrice = price + } + // Estimate GasLimit + gasLimit := opts.GasLimit + if opts.GasLimit == 0 { + var err error + gasLimit, err = estimateGasLimit(backend, address, opts, contract, input, gasPrice, nil, nil, value) + if err != nil { + return nil, err + } + } + // create the transaction + nonce, err := getNonce(backend, opts) + if err != nil { + return nil, err + } + baseTx := &types.LegacyTx{ + To: contract, + Nonce: nonce, + GasPrice: gasPrice, + Gas: gasLimit, + Value: value, + Data: input, + } + return types.NewTx(baseTx), nil +} + +const basefeeWiggleMultiplier = 2 + +func createDynamicTx(backend V2Backend, opts *TransactOpts, contract *common.Address, input []byte, head *types.Header) (*types.Transaction, error) { + // Normalize value + value := opts.Value + if value == nil { + value = new(big.Int) + } + // Estimate TipCap + gasTipCap := opts.GasTipCap + if gasTipCap == nil { + tip, err := backend.SuggestGasTipCap(ensureContext(opts.Context)) + if err != nil { + return nil, err + } + gasTipCap = tip + } + // Estimate FeeCap + gasFeeCap := opts.GasFeeCap + if gasFeeCap == nil { + gasFeeCap = new(big.Int).Add( + gasTipCap, + new(big.Int).Mul(head.BaseFee, big.NewInt(basefeeWiggleMultiplier)), + ) + } + if gasFeeCap.Cmp(gasTipCap) < 0 { + return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", gasFeeCap, gasTipCap) + } + // Estimate GasLimit + gasLimit := opts.GasLimit + if opts.GasLimit == 0 { + var err error + gasLimit, err = c.estimateGasLimit(opts, contract, input, nil, gasTipCap, gasFeeCap, value) + if err != nil { + return nil, err + } + } + // create the transaction + nonce, err := c.getNonce(opts) + if err != nil { + return nil, err + } + baseTx := &types.DynamicFeeTx{ + To: contract, + Nonce: nonce, + GasFeeCap: gasFeeCap, + GasTipCap: gasTipCap, + Gas: gasLimit, + Value: value, + Data: input, + AccessList: opts.AccessList, + } + return types.NewTx(baseTx), nil +} + func Transfer(instance bind.ContractInstance, opts *bind.TransactOpts) (*types.Transaction, error) { backend := instance.Backend() c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index a6d16806f739..c232bd0cff4e 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -4,6 +4,9 @@ import ( "context" "encoding/json" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" + "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2_generated_testcase" + "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/node" "io" "github.com/ethereum/go-ethereum/accounts/abi" @@ -18,65 +21,6 @@ import ( "testing" ) -const deployer = "6080604052348015600e575f80fd5b506102098061001c5f395ff3fe608060405234801561000f575f80fd5b506004361061003f575f3560e01c80636da1cd55146100435780637b0cb83914610061578063bf54fad41461006b575b5f80fd5b61004b610087565b60405161005891906100e9565b60405180910390f35b61006961008f565b005b61008560048036038101906100809190610130565b6100c8565b005b5f8054905090565b607b7f72c79b1cb25b1b49ae522446226e1591b80634619cef7e71846da52b61b7061d6040516100be906101b5565b60405180910390a2565b805f8190555050565b5f819050919050565b6100e3816100d1565b82525050565b5f6020820190506100fc5f8301846100da565b92915050565b5f80fd5b61010f816100d1565b8114610119575f80fd5b50565b5f8135905061012a81610106565b92915050565b5f6020828403121561014557610144610102565b5b5f6101528482850161011c565b91505092915050565b5f82825260208201905092915050565b7f737472696e6700000000000000000000000000000000000000000000000000005f82015250565b5f61019f60068361015b565b91506101aa8261016b565b602082019050919050565b5f6020820190508181035f8301526101cc81610193565b905091905056fea2646970667358221220212a3a765a98254b596386fdfd10318f9a4bf19e8c9ca9ffa363f990c1798bf664736f6c634300081a0033" - -const contractABIStr = ` -[ - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "uint256", - "name": "firstArg", - "type": "uint256" - }, - { - "indexed": false, - "internalType": "string", - "name": "secondArg", - "type": "string" - } - ], - "name": "ExampleEvent", - "type": "event" - }, - { - "inputs": [], - "name": "emitEvent", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "num", - "type": "uint256" - } - ], - "name": "mutateStorageVal", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "retrieveStorageVal", - "outputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "stateMutability": "view", - "type": "function" - } -] -` - var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") // JSON returns a parsed ABI interface and error if it failed. @@ -96,10 +40,13 @@ func TestV2(t *testing.T) { types.GenesisAlloc{ testAddr: {Balance: big.NewInt(10000000000000000)}, }, + func(nodeConf *node.Config, ethConf *ethconfig.Config) { + ethConf.Genesis.Difficulty = big.NewInt(0) + }, ) defer backend.Close() - contractABI, err := JSON(strings.NewReader(contractABIStr)) + contractABI, err := JSON(strings.NewReader(v2_generated_testcase.V2GeneratedTestcaseMetaData.ABI)) if err != nil { panic(err) } @@ -120,15 +67,6 @@ func TestV2(t *testing.T) { return signedTx, nil }, Context: context.Background(), - /* - Value: nil, - GasPrice: nil, - GasFeeCap: nil, - GasTipCap: nil, - GasLimit: 0, - AccessList: nil, - NoSend: false, - */ } // we should just be able to use the backend directly, instead of using // this deprecated interface. However, the simulated backend no longer @@ -137,9 +75,28 @@ func TestV2(t *testing.T) { Backend: backend, Client: backend.Client(), } - _, _, _, err = bind.DeployContract(&opts, contractABI, common.Hex2Bytes(deployer), &bindBackend) + address, _, boundContract, err := bind.DeployContract(&opts, contractABI, common.Hex2Bytes(v2_generated_testcase.V2GeneratedTestcaseMetaData.Bin), &bindBackend) + if err != nil { + t.Fatal(err) + } + contract, err := v2_generated_testcase.NewV2GeneratedTestcase() + if err != nil { + t.Fatal(err) // can't happen here with the example used. consider removing this block + } + contractInstance := v2_generated_testcase.NewV2GeneratedTestcaseInstance(contract, address) + sinkCh := make(chan *v2_generated_testcase.V2GeneratedTestcase) + // q: what extra functionality is given by specifying this as a custom method, instead of catching emited methods + // from the sync channel? + unpackStruct := func(log *types.Log) (v2_generated_testcase.V2GeneratedTestcaseStruct, error) { + res, err := contract.UnpackStructEvent(log) + return *res, err + } + // TODO: test using various topics + // q: does nil topics mean to accept any? + sub, err := WatchLogs[v2_generated_testcase.V2GeneratedTestcaseStruct](contractInstance, v2_generated_testcase.V2GeneratedTestcaseStructEventID(), unpackStruct, sinkCh) if err != nil { t.Fatal(err) } + defer sub.Unsubscribe() // send a balance to our contract (contract must accept ether by default) } From e6af3fe22425109b82aab32db248cc990a2e7b66 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 20 Nov 2024 18:57:03 +0700 Subject: [PATCH 017/104] still in a wip state --- accounts/abi/bind/base.go | 16 ++ accounts/abi/bind/bind.go | 72 ++++- accounts/abi/bind/lib.go | 8 +- accounts/abi/bind/template.go | 25 +- accounts/abi/bind/template2.go | 23 +- .../testdata/v2_testcase_library/contract.sol | 44 +++ accounts/abi/bind/v2/lib.go | 260 ++++-------------- accounts/abi/bind/v2/v2_test.go | 36 ++- 8 files changed, 234 insertions(+), 250 deletions(-) create mode 100644 accounts/abi/bind/testdata/v2_testcase_library/contract.sol diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index eb47e49989aa..f103910c17a7 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -151,6 +151,18 @@ func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend Co return c.address, tx, c, nil } +func DeployContractRaw(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, packedParams []byte) (common.Address, *types.Transaction, *BoundContract, error) { + // Otherwise try to deploy the contract + c := NewBoundContract(common.Address{}, abi, backend, backend, backend) + + tx, err := c.transact(opts, nil, append(bytecode, packedParams...)) + if err != nil { + return common.Address{}, nil, nil, err + } + c.address = crypto.CreateAddress(opts.From, tx.Nonce()) + return c.address, tx, c, nil +} + // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named @@ -179,6 +191,10 @@ func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method stri return c.abi.UnpackIntoInterface(res[0], method, output) } +func (c *BoundContract) CallRaw(opts *CallOpts, input []byte) ([]byte, error) { + return c.call(opts, input) +} + func (c *BoundContract) call(opts *CallOpts, input []byte) ([]byte, error) { // Don't crash on a lazy user if opts == nil { diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index d5aab35a5dcd..1f5d598e616d 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -312,17 +312,19 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] } contracts[types[i]] = &tmplContract{ - Type: capitalise(types[i]), - InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), - InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), - Constructor: evmABI.Constructor, - Calls: calls, - Transacts: transacts, - Fallback: fallback, - Receive: receive, - Events: events, - Libraries: make(map[string]string), + Type: capitalise(types[i]), + InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), + InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), + Constructor: evmABI.Constructor, + Calls: calls, + Transacts: transacts, + Fallback: fallback, + Receive: receive, + Events: events, + Libraries: make(map[string]string), + AllLibraries: make(map[string]string), } + // Function 4-byte signatures are stored in the same sequence // as types, if available. if len(fsigs) > i { @@ -340,14 +342,54 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] if _, ok := isLib[name]; !ok { isLib[name] = struct{}{} } + } } + // Check if that type has already been identified as a library + for i := 0; i < len(types); i++ { + _, ok := isLib[types[i]] + contracts[types[i]].Library = ok + } + + // recursively traverse the library dependency graph + // of the contract, flattening it into a list. + // + // For abigenv2, we do not generate contract deploy + // methods (which in v1 recursively deploy their + // library dependencies). So, the entire set of + // library dependencies is required, and we will + // the order to deploy and link them at runtime. + var findDeps func(contract *tmplContract) map[string]struct{} + findDeps = func(contract *tmplContract) map[string]struct{} { + // 1) match all libraries that this contract depends on + re, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") + if err != nil { + panic(err) + } + libBin := contracts[contract.Type].InputBin + matches := re.FindAllStringSubmatch(libBin, -1) + var result map[string]struct{} + + // 2) recurse, gathering nested library dependencies + for _, match := range matches { + pattern := match[1] + result[pattern] = struct{}{} + depContract := contracts[pattern] + for subPattern, _ := range findDeps(depContract) { + result[subPattern] = struct{}{} + } + } + return result + } + // take the set of library patterns, convert it to a map of pattern -> type + deps := findDeps(contracts[types[i]]) + contracts[types[i]].AllLibraries = make(map[string]string) + for contractPattern, _ := range deps { + contractType := libs[contractPattern] + contracts[types[i]].AllLibraries[contractType] = contractPattern + } } - // Check if that type has already been identified as a library - for i := 0; i < len(types); i++ { - _, ok := isLib[types[i]] - contracts[types[i]].Library = ok - } + // Generate the contract template data content and render it data := &tmplData{ Package: pkg, diff --git a/accounts/abi/bind/lib.go b/accounts/abi/bind/lib.go index 6d6dd7b52e59..3ab6a8aee634 100644 --- a/accounts/abi/bind/lib.go +++ b/accounts/abi/bind/lib.go @@ -17,7 +17,6 @@ package bind import ( - "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" ) @@ -30,10 +29,5 @@ type ContractInstance interface { type ContractInstanceV2 interface { Address() common.Address -} - -func CallRaw(instance ContractInstance, opts *CallOpts, input []byte) ([]byte, error) { - backend := instance.Backend() - c := NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) - return c.call(opts, input) + Backend() ContractBackend } diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index fa7528106903..2e7ff7f4f57c 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -32,18 +32,19 @@ type tmplData struct { // tmplContract contains the data needed to generate an individual contract binding. type tmplContract struct { - Type string // Type name of the main contract binding - InputABI string // JSON ABI used as the input to generate the binding from - InputBin string // Optional EVM bytecode used to generate deploy code from - FuncSigs map[string]string // Optional map: string signature -> 4-byte signature - Constructor abi.Method // Contract constructor for deploy parametrization - Calls map[string]*tmplMethod // Contract calls that only read state data - Transacts map[string]*tmplMethod // Contract calls that write state data - Fallback *tmplMethod // Additional special fallback function - Receive *tmplMethod // Additional special receive function - Events map[string]*tmplEvent // Contract events accessors - Libraries map[string]string // Same as tmplData, but filtered to only keep what the contract needs - Library bool // Indicator whether the contract is a library + Type string // Type name of the main contract binding + InputABI string // JSON ABI used as the input to generate the binding from + InputBin string // Optional EVM bytecode used to generate deploy code from + FuncSigs map[string]string // Optional map: string signature -> 4-byte signature + Constructor abi.Method // Contract constructor for deploy parametrization + Calls map[string]*tmplMethod // Contract calls that only read state data + Transacts map[string]*tmplMethod // Contract calls that write state data + Fallback *tmplMethod // Additional special fallback function + Receive *tmplMethod // Additional special receive function + Events map[string]*tmplEvent // Contract events accessors + Libraries map[string]string // Same as tmplData, but filtered to only keep direct deps that the contract needs + AllLibraries map[string]string // same as Libraries, but all direct/indirect library dependencies + Library bool // Indicator whether the contract is a library } // tmplMethod is a wrapper around an abi.Method that contains a few preprocessed diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 85f83605d951..9c1396ba69bd 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -38,6 +38,12 @@ var ( {{end}} {{range $contract := .Contracts}} + var {{$contract.Type}}LibraryDeps = map[string]*bind.MetaData{ + {{range $pattern, $name := .Libraries}} + "{{$pattern}}": &{{$name}}MetaData, + {{end}} + } + // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract. var {{.Type}}MetaData = &bind.MetaData{ ABI: "{{.InputABI}}", @@ -52,20 +58,14 @@ var ( {{end}} } - // {{.Type}}Instance represents a deployed instance of the {{.Type}} contract. - type {{.Type}}Instance struct { - {{.Type}} - address common.Address // consider removing this, not clear what it's used for now (and why did we need custom deploy method on previous abi?) - } - - func New{{.Type}}Instance(c *{{.Type}}, address common.Address) *{{.Type}}Instance { - return &{{.Type}}Instance{ {{$contract.Type}}: *c, address: address} - } - func (i *{{$contract.Type}}Instance) Address() common.Address { return i.address } + func (i *{{$contract.Type}}Instance) Backend() bind.ContractBackend { + return i.backend + } + // {{.Type}} is an auto generated Go binding around an Ethereum contract. type {{.Type}} struct { abi abi.ABI @@ -86,7 +86,8 @@ var ( return _{{$contract.Type}}.deployCode } - func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ([]byte, error) { + // TODO: test constructor with inputs + func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ([]byte, error) { return _{{$contract.Type}}.abi.Pack("" {{range .Constructor.Inputs}}, {{.Name}}{{end}}) } diff --git a/accounts/abi/bind/testdata/v2_testcase_library/contract.sol b/accounts/abi/bind/testdata/v2_testcase_library/contract.sol new file mode 100644 index 000000000000..399f5c41cd22 --- /dev/null +++ b/accounts/abi/bind/testdata/v2_testcase_library/contract.sol @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.26; + +library RecursiveDep { + function AddOne(uint256 val) public pure returns (uint256 ret) { + return val + 1; + } +} + +// Array function to delete element at index and re-organize the array +// so that there are no gaps between the elements. +library Array { + using RecursiveDep for uint256; + + function remove(uint256[] storage arr, uint256 index) public { + // Move the last element into the place to delete + require(arr.length > 0, "Can't remove from empty array"); + arr[index] = arr[arr.length - 1]; + arr[index] = arr[index].AddOne(); + arr.pop(); + } +} + +contract TestArray { + using Array for uint256[]; + + uint256[] public arr; + + function testArrayRemove(uint256 value) public { + for (uint256 i = 0; i < 3; i++) { + arr.push(i); + } + + arr.remove(1); + + assert(arr.length == 2); + assert(arr[0] == 0); + assert(arr[1] == 2); + } + + constructor(uint256 foobar) { + + } +} diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 9b350fb4a349..eb049b77b691 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -1,8 +1,6 @@ package v2 import ( - "context" - "errors" "fmt" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" @@ -10,57 +8,74 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/event" - "math/big" + "regexp" + "strings" ) -func FilterLogs[T any](instance bind.ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { - backend := instance.Backend() - c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) - logs, sub, err := c.FilterLogs(opts, eventID.String(), topics...) - if err != nil { - return nil, err - } - return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil +type ContractInstance struct { + Address common.Address + Backend bind.ContractBackend } -// WatchOpts is the collection of options to fine tune subscribing for events -// within a bound contract. -type WatchOpts struct { - Start *uint64 // Start of the queried range (nil = latest) - Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) -} - -func watchLogs(backend V2Backend, address common.Address, opts *WatchOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { - // Don't crash on a lazy user - if opts == nil { - opts = new(WatchOpts) - } - // Append the event selector to the query parameters and construct the topic set - query = append([][]interface{}{{eventID}}, query...) - - topics, err := abi.MakeTopics(query...) +func DeployContracts(auth *bind.TransactOpts, backend bind.ContractBackend, constructorInput []byte, contracts map[string]*bind.MetaData) { + // match if the contract has dynamic libraries that need to be linked + hasDepsMatcher, err := regexp.Compile("__\\$.*\\$__") if err != nil { - return nil, nil, err + panic(err) } - // Start the background filtering - logs := make(chan types.Log, 128) - config := ethereum.FilterQuery{ - Addresses: []common.Address{address}, - Topics: topics, + // deps we are linking + wipDeps := make(map[string]string) + for id, metadata := range contracts { + wipDeps[id] = metadata.Bin } - if opts.Start != nil { - config.FromBlock = new(big.Int).SetUint64(*opts.Start) + + // nested iteration: find contracts without library dependencies first, + // deploy them, link them into any other contracts that depend on them. + // repeat this until there are no more contracts to link/deploy + for { + for id, contractBin := range wipDeps { + if !hasDepsMatcher.MatchString(contractBin) { + // this library/contract doesn't depend on any others + // it can be deployed as-is. + abi, err := contracts[id].GetAbi() + if err != nil { + panic(err) + } + addr, _, _, err := bind.DeployContractRaw(auth, *abi, []byte(contractBin), backend, constructorInput) + if err != nil { + panic(err) + } + delete(wipDeps, id) + + // embed the address of the deployed contract into any + // libraries/contracts that depend on it. + for id, contractBin := range wipDeps { + contractBin = strings.ReplaceAll(contractBin, fmt.Sprintf("__$%s%__", id), fmt.Sprintf("__$%s$__", addr.String())) + wipDeps[id] = contractBin + } + } + } + if len(wipDeps) == 0 { + break + } } - sub, err := backend.SubscribeFilterLogs(ensureContext(opts.Context), config, logs) +} + +func FilterLogs[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { + backend := instance.Backend + c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) + logs, sub, err := c.FilterLogs(opts, eventID.String(), topics...) if err != nil { - return nil, nil, err + return nil, err } - return logs, sub, nil + return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil } -func WatchLogs[T any](address common.Address, backend V2Backend, opts *WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { - logs, sub, err := watchLogs(backend, address, opts, eventID, topics...) +func WatchLogs[T any](instance *ContractInstance, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { + backend := instance.Backend + c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) + logs, sub, err := c.WatchLogs(opts, eventID.String(), topics...) if err != nil { return nil, err } @@ -166,167 +181,14 @@ func Transact(instance bind.ContractInstance, opts *bind.TransactOpts, input []b return c.RawTransact(opts, input) } -// ensureContext is a helper method to ensure a context is not nil, even if the -// user specified it as such. -func ensureContext(ctx context.Context) context.Context { - if ctx == nil { - return context.Background() - } - return ctx -} - -// SignerFn is a signer function callback when a contract requires a method to -// sign the transaction before submission. -type SignerFn func(common.Address, *types.Transaction) (*types.Transaction, error) - -// TransactOpts is the collection of authorization data required to create a -// valid Ethereum transaction. -type TransactOpts struct { - From common.Address // Ethereum account to send the transaction from - Nonce *big.Int // Nonce to use for the transaction execution (nil = use pending state) - Signer SignerFn // Method to use for signing the transaction (mandatory) - - Value *big.Int // Funds to transfer along the transaction (nil = 0 = no funds) - GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) - GasFeeCap *big.Int // Gas fee cap to use for the 1559 transaction execution (nil = gas price oracle) - GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle) - GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate) - AccessList types.AccessList // Access list to set for the transaction execution (nil = no access list) - - Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) - - NoSend bool // Do all transact steps but do not send the transaction -} - -func estimateGasLimit(backend V2Backend, address common.Hash, opts *TransactOpts, contract *common.Address, input []byte, gasPrice, gasTipCap, gasFeeCap, value *big.Int) (uint64, error) { - if contract != nil { - // Gas estimation cannot succeed without code for method invocations. - if code, err := backend.PendingCodeAt(ensureContext(opts.Context), address); err != nil { - return 0, err - } else if len(code) == 0 { - return 0, ErrNoCode - } - } - msg := ethereum.CallMsg{ - From: opts.From, - To: contract, - GasPrice: gasPrice, - GasTipCap: gasTipCap, - GasFeeCap: gasFeeCap, - Value: value, - Data: input, - } - return backend.EstimateGas(ensureContext(opts.Context), msg) -} - -func getNonce(backend V2Backend, opts *TransactOpts) (uint64, error) { - if opts.Nonce == nil { - return backend.PendingNonceAt(ensureContext(opts.Context), opts.From) - } else { - return opts.Nonce.Uint64(), nil - } -} - -func createLegacyTx(backend V2Backend, address common.Hash, opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) { - if opts.GasFeeCap != nil || opts.GasTipCap != nil || opts.AccessList != nil { - return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas or accessList specified but london is not active yet") - } - // Normalize value - value := opts.Value - if value == nil { - value = new(big.Int) - } - // Estimate GasPrice - gasPrice := opts.GasPrice - if gasPrice == nil { - price, err := backend.SuggestGasPrice(ensureContext(opts.Context)) - if err != nil { - return nil, err - } - gasPrice = price - } - // Estimate GasLimit - gasLimit := opts.GasLimit - if opts.GasLimit == 0 { - var err error - gasLimit, err = estimateGasLimit(backend, address, opts, contract, input, gasPrice, nil, nil, value) - if err != nil { - return nil, err - } - } - // create the transaction - nonce, err := getNonce(backend, opts) - if err != nil { - return nil, err - } - baseTx := &types.LegacyTx{ - To: contract, - Nonce: nonce, - GasPrice: gasPrice, - Gas: gasLimit, - Value: value, - Data: input, - } - return types.NewTx(baseTx), nil -} - -const basefeeWiggleMultiplier = 2 - -func createDynamicTx(backend V2Backend, opts *TransactOpts, contract *common.Address, input []byte, head *types.Header) (*types.Transaction, error) { - // Normalize value - value := opts.Value - if value == nil { - value = new(big.Int) - } - // Estimate TipCap - gasTipCap := opts.GasTipCap - if gasTipCap == nil { - tip, err := backend.SuggestGasTipCap(ensureContext(opts.Context)) - if err != nil { - return nil, err - } - gasTipCap = tip - } - // Estimate FeeCap - gasFeeCap := opts.GasFeeCap - if gasFeeCap == nil { - gasFeeCap = new(big.Int).Add( - gasTipCap, - new(big.Int).Mul(head.BaseFee, big.NewInt(basefeeWiggleMultiplier)), - ) - } - if gasFeeCap.Cmp(gasTipCap) < 0 { - return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", gasFeeCap, gasTipCap) - } - // Estimate GasLimit - gasLimit := opts.GasLimit - if opts.GasLimit == 0 { - var err error - gasLimit, err = c.estimateGasLimit(opts, contract, input, nil, gasTipCap, gasFeeCap, value) - if err != nil { - return nil, err - } - } - // create the transaction - nonce, err := c.getNonce(opts) - if err != nil { - return nil, err - } - baseTx := &types.DynamicFeeTx{ - To: contract, - Nonce: nonce, - GasFeeCap: gasFeeCap, - GasTipCap: gasTipCap, - Gas: gasLimit, - Value: value, - Data: input, - AccessList: opts.AccessList, - } - return types.NewTx(baseTx), nil -} - func Transfer(instance bind.ContractInstance, opts *bind.TransactOpts) (*types.Transaction, error) { backend := instance.Backend() c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) return c.Transfer(opts) } + +func CallRaw(instance bind.ContractInstance, opts *bind.CallOpts, input []byte) ([]byte, error) { + backend := instance.Backend() + c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) + return c.CallRaw(opts, input) +} diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index c232bd0cff4e..61b5ac1844ad 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -75,28 +75,52 @@ func TestV2(t *testing.T) { Backend: backend, Client: backend.Client(), } - address, _, boundContract, err := bind.DeployContract(&opts, contractABI, common.Hex2Bytes(v2_generated_testcase.V2GeneratedTestcaseMetaData.Bin), &bindBackend) + address, tx, _, err := bind.DeployContract(&opts, contractABI, common.Hex2Bytes(v2_generated_testcase.V2GeneratedTestcaseMetaData.Bin), &bindBackend) if err != nil { t.Fatal(err) } + + _, err = bind.WaitDeployed(context.Background(), &bindBackend, tx) + if err != nil { + t.Fatalf("error deploying bound contract: %+v", err) + } + contract, err := v2_generated_testcase.NewV2GeneratedTestcase() if err != nil { t.Fatal(err) // can't happen here with the example used. consider removing this block } - contractInstance := v2_generated_testcase.NewV2GeneratedTestcaseInstance(contract, address) - sinkCh := make(chan *v2_generated_testcase.V2GeneratedTestcase) + //contractInstance := v2_generated_testcase.NewV2GeneratedTestcaseInstance(contract, address, bindBackend) + contractInstance := ContractInstance{ + Address: address, + Backend: bindBackend, + } + sinkCh := make(chan *v2_generated_testcase.V2GeneratedTestcaseStruct) // q: what extra functionality is given by specifying this as a custom method, instead of catching emited methods // from the sync channel? - unpackStruct := func(log *types.Log) (v2_generated_testcase.V2GeneratedTestcaseStruct, error) { + unpackStruct := func(log *types.Log) (*v2_generated_testcase.V2GeneratedTestcaseStruct, error) { res, err := contract.UnpackStructEvent(log) - return *res, err + return res, err + } + watchOpts := bind.WatchOpts{ + Start: nil, + Context: context.Background(), } // TODO: test using various topics // q: does nil topics mean to accept any? - sub, err := WatchLogs[v2_generated_testcase.V2GeneratedTestcaseStruct](contractInstance, v2_generated_testcase.V2GeneratedTestcaseStructEventID(), unpackStruct, sinkCh) + sub, err := WatchLogs[v2_generated_testcase.V2GeneratedTestcaseStruct](&contractInstance, &watchOpts, v2_generated_testcase.V2GeneratedTestcaseStructEventID(), unpackStruct, sinkCh, nil) if err != nil { t.Fatal(err) } defer sub.Unsubscribe() // send a balance to our contract (contract must accept ether by default) } + +func TestDeployment(t *testing.T) { + DeployContracts +} + +/* test-cases that should be extracted from v1 tests + +* EventChecker + + */ From 59731ca260624213910b01ac946606b85eb00d31 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 20 Nov 2024 20:48:43 +0700 Subject: [PATCH 018/104] dependency graph calculation working --- accounts/abi/bind/bind.go | 32 +++++++++++++++++++------------- accounts/abi/bind/template2.go | 4 ++-- 2 files changed, 21 insertions(+), 15 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 1f5d598e616d..e7e31e6b03f3 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -342,17 +342,23 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] if _, ok := isLib[name]; !ok { isLib[name] = struct{}{} } - } } - // Check if that type has already been identified as a library - for i := 0; i < len(types); i++ { - _, ok := isLib[types[i]] - contracts[types[i]].Library = ok - } + } + // Check if that type has already been identified as a library + for i := 0; i < len(types); i++ { + _, ok := isLib[types[i]] + contracts[types[i]].Library = ok + } + + // compute the full set of libraries that each contract depends on. + for _, contract := range contracts { + if contract.Library { + continue + } // recursively traverse the library dependency graph - // of the contract, flattening it into a list. + // of the contract, flattening it into a set. // // For abigenv2, we do not generate contract deploy // methods (which in v1 recursively deploy their @@ -368,25 +374,25 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] } libBin := contracts[contract.Type].InputBin matches := re.FindAllStringSubmatch(libBin, -1) - var result map[string]struct{} + result := make(map[string]struct{}) // 2) recurse, gathering nested library dependencies for _, match := range matches { pattern := match[1] result[pattern] = struct{}{} - depContract := contracts[pattern] + depContract := contracts[libs[pattern]] for subPattern, _ := range findDeps(depContract) { result[subPattern] = struct{}{} } } return result } - // take the set of library patterns, convert it to a map of pattern -> type - deps := findDeps(contracts[types[i]]) - contracts[types[i]].AllLibraries = make(map[string]string) + // take the set of library patterns, convert it to a map of type -> pattern + deps := findDeps(contract) + contract.AllLibraries = make(map[string]string) for contractPattern, _ := range deps { contractType := libs[contractPattern] - contracts[types[i]].AllLibraries[contractType] = contractPattern + contract.AllLibraries[contractType] = contractPattern } } diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 9c1396ba69bd..e63de89b9555 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -39,9 +39,9 @@ var ( {{range $contract := .Contracts}} var {{$contract.Type}}LibraryDeps = map[string]*bind.MetaData{ - {{range $pattern, $name := .Libraries}} + {{range $pattern, $name := .AllLibraries -}} "{{$pattern}}": &{{$name}}MetaData, - {{end}} + {{ end}} } // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract. From 403329b779baa8aeb5b68c99ac33abbf8d18427a Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Sun, 24 Nov 2024 19:35:16 +0700 Subject: [PATCH 019/104] commit of wip-code: rework the contract deployment code to be cleaner --- accounts/abi/bind/base.go | 7 +- accounts/abi/bind/template2.go | 20 ++---- accounts/abi/bind/v2/lib.go | 119 +++++++++++++++++++++++--------- accounts/abi/bind/v2/v2_test.go | 60 +++++++++++++++- 4 files changed, 153 insertions(+), 53 deletions(-) diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index f103910c17a7..bb7301e965cb 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -151,9 +151,10 @@ func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend Co return c.address, tx, c, nil } -func DeployContractRaw(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, packedParams []byte) (common.Address, *types.Transaction, *BoundContract, error) { - // Otherwise try to deploy the contract - c := NewBoundContract(common.Address{}, abi, backend, backend, backend) +func DeployContractRaw(opts *TransactOpts, bytecode []byte, backend ContractBackend, packedParams []byte) (common.Address, *types.Transaction, *BoundContract, error) { + // TODO: it's weird to instantiate a bound contract (implies existence of contract) in order to deploy a contract + // that doesn't yet exist + c := NewBoundContract(common.Address{}, abi.ABI{}, backend, backend, backend) tx, err := c.transact(opts, nil, append(bytecode, packedParams...)) if err != nil { diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index e63de89b9555..9c85a466a7ee 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -39,8 +39,8 @@ var ( {{range $contract := .Contracts}} var {{$contract.Type}}LibraryDeps = map[string]*bind.MetaData{ - {{range $pattern, $name := .AllLibraries -}} - "{{$pattern}}": &{{$name}}MetaData, + {{range $name, $pattern := .AllLibraries -}} + "{{$pattern}}": {{$name}}MetaData, {{ end}} } @@ -58,18 +58,9 @@ var ( {{end}} } - func (i *{{$contract.Type}}Instance) Address() common.Address { - return i.address - } - - func (i *{{$contract.Type}}Instance) Backend() bind.ContractBackend { - return i.backend - } - // {{.Type}} is an auto generated Go binding around an Ethereum contract. type {{.Type}} struct { abi abi.ABI - deployCode []byte } // New{{.Type}} creates a new instance of {{.Type}}. @@ -78,13 +69,10 @@ var ( if err != nil { return nil, err } - code := common.Hex2Bytes({{.Type}}MetaData.Bin) - return &{{.Type}}{abi: *parsed, deployCode: code}, nil + return &{{.Type}}{abi: *parsed}, nil } - func (_{{$contract.Type}} *{{$contract.Type}}) DeployCode() []byte { - return _{{$contract.Type}}.deployCode - } + // TODO: create custom exported types where unpack would generate a struct return. // TODO: test constructor with inputs func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ([]byte, error) { diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index eb049b77b691..f00df1b9e733 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -1,6 +1,7 @@ package v2 import ( + "encoding/hex" "fmt" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" @@ -17,49 +18,101 @@ type ContractInstance struct { Backend bind.ContractBackend } -func DeployContracts(auth *bind.TransactOpts, backend bind.ContractBackend, constructorInput []byte, contracts map[string]*bind.MetaData) { - // match if the contract has dynamic libraries that need to be linked - hasDepsMatcher, err := regexp.Compile("__\\$.*\\$__") +func deployDeps(backend bind.ContractBackend, auth *bind.TransactOpts, constructorInputs map[string][]byte, contracts map[string]string) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[common.Address]struct{}, err error) { + for pattern, contractBin := range contracts { + contractBinBytes, err := hex.DecodeString(contractBin[2:]) + if err != nil { + return deploymentTxs, deployAddrs, fmt.Errorf("contract bytecode is not a hex string: %s", contractBin[2:]) + } + var constructorInput []byte + if inp, ok := constructorInputs[pattern]; ok { + constructorInput = inp + } else { + constructorInput = make([]byte, 0) // TODO check if we can pass a nil byte slice here. + } + addr, tx, _, err := bind.DeployContractRaw(auth, contractBinBytes, backend, constructorInput) + if err != nil { + return deploymentTxs, deployAddrs, fmt.Errorf("failed to deploy contract: %v", err) + } + deploymentTxs[addr] = tx + deployAddrs[addr] = struct{}{} + } + + return deploymentTxs, deployAddrs, nil +} + +func linkDeps(deps *map[string]string, linked *map[string]common.Address) (deployableDeps map[string]string) { + reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") if err != nil { panic(err) } - - // deps we are linking - wipDeps := make(map[string]string) - for id, metadata := range contracts { - wipDeps[id] = metadata.Bin + reMatchAnyPattern, err := regexp.Compile("__\\$.*\\$__") + if err != nil { + panic(err) + } + deployableDeps = make(map[string]string) + + for pattern, dep := range *deps { + // attempt to replace references to every single linked dep + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(dep, -1) { + matchingPattern := match[1] + addr, ok := (*linked)[matchingPattern] + if !ok { + continue + } + (*deps)[pattern] = strings.ReplaceAll(dep, matchingPattern, addr.String()) + } + // if we linked something into this dep, see if it can be deployed + if !reMatchAnyPattern.MatchString((*deps)[pattern]) { + deployableDeps[pattern] = (*deps)[pattern] + delete(*deps, pattern) + } } - // nested iteration: find contracts without library dependencies first, - // deploy them, link them into any other contracts that depend on them. - // repeat this until there are no more contracts to link/deploy - for { - for id, contractBin := range wipDeps { - if !hasDepsMatcher.MatchString(contractBin) { - // this library/contract doesn't depend on any others - // it can be deployed as-is. - abi, err := contracts[id].GetAbi() - if err != nil { - panic(err) - } - addr, _, _, err := bind.DeployContractRaw(auth, *abi, []byte(contractBin), backend, constructorInput) - if err != nil { - panic(err) - } - delete(wipDeps, id) + return deployableDeps +} - // embed the address of the deployed contract into any - // libraries/contracts that depend on it. - for id, contractBin := range wipDeps { - contractBin = strings.ReplaceAll(contractBin, fmt.Sprintf("__$%s%__", id), fmt.Sprintf("__$%s$__", addr.String())) - wipDeps[id] = contractBin - } - } +func LinkAndDeployContractsWithOverride(auth *bind.TransactOpts, backend bind.ContractBackend, constructorInputs map[string][]byte, contracts, libs map[string]string, overrides map[string]common.Address) (allDeployTxs map[common.Address]*types.Transaction, allDeployAddrs map[common.Address]struct{}, err error) { + var depsToDeploy map[string]string // map of pattern -> unlinked binary for deps we will deploy + + // initialize the set of already-deployed contracts with given override addresses + linked := make(map[string]common.Address) + for pattern, deployAddr := range overrides { + linked[pattern] = deployAddr + if _, ok := contracts[pattern]; ok { + delete(contracts, pattern) } - if len(wipDeps) == 0 { + } + + // link and deploy dynamic libraries + for { + deployableDeps := linkDeps(&depsToDeploy, &linked) + if len(deployableDeps) == 0 { break } + deployTxs, deployAddrs, err := deployDeps(backend, auth, constructorInputs, deployableDeps) + for addr, _ := range deployAddrs { + allDeployAddrs[addr] = struct{}{} + } + for addr, tx := range deployTxs { + allDeployTxs[addr] = tx + } + if err != nil { + return deployTxs, allDeployAddrs, err + } + } + + // link and deploy the contracts + contractBins := make(map[string]string) + linkedContracts := linkDeps(&contractBins, &linked) + deployTxs, deployAddrs, err := deployDeps(backend, auth, constructorInputs, linkedContracts) + for addr, _ := range deployAddrs { + allDeployAddrs[addr] = struct{}{} + } + for addr, tx := range deployTxs { + allDeployTxs[addr] = tx } + return allDeployTxs, allDeployAddrs, err } func FilterLogs[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index 61b5ac1844ad..9250093939b4 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -3,11 +3,15 @@ package v2 import ( "context" "encoding/json" + "fmt" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2_generated_testcase" + "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2_testcase_library" "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/node" "io" + "os" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" @@ -116,7 +120,61 @@ func TestV2(t *testing.T) { } func TestDeployment(t *testing.T) { - DeployContracts + testAddr := crypto.PubkeyToAddress(testKey.PublicKey) + backend := simulated.NewBackend( + types.GenesisAlloc{ + testAddr: {Balance: big.NewInt(10000000000000000)}, + }, + func(nodeConf *node.Config, ethConf *ethconfig.Config) { + ethConf.Genesis.Difficulty = big.NewInt(0) + }, + ) + defer backend.Close() + + _, err := JSON(strings.NewReader(v2_generated_testcase.V2GeneratedTestcaseMetaData.ABI)) + if err != nil { + panic(err) + } + + signer := types.LatestSigner(params.AllDevChainProtocolChanges) + opts := bind.TransactOpts{ + From: testAddr, + Nonce: nil, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + signature, err := crypto.Sign(signer.Hash(tx).Bytes(), testKey) + if err != nil { + t.Fatal(err) + } + signedTx, err := tx.WithSignature(signer, signature) + if err != nil { + t.Fatal(err) + } + return signedTx, nil + }, + Context: context.Background(), + } + // we should just be able to use the backend directly, instead of using + // this deprecated interface. However, the simulated backend no longer + // implements backends.SimulatedBackend... + bindBackend := backends.SimulatedBackend{ + Backend: backend, + Client: backend.Client(), + } + + log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stdout, log.LevelDebug, true))) + + ///LinkAndDeployContractsWithOverride(&opts, bindBackend, v2_test) + deployTxs, err := DeployContracts(&opts, bindBackend, []byte{}, v2_testcase_library.TestArrayLibraryDeps) + if err != nil { + t.Fatalf("err: %+v\n", err) + } + for _, tx := range deployTxs { + fmt.Println("waiting for deployment") + _, err = bind.WaitDeployed(context.Background(), &bindBackend, tx) + if err != nil { + t.Fatalf("error deploying bound contract: %+v", err) + } + } } /* test-cases that should be extracted from v1 tests From bab050c2356d751290c939236f5ec98474cd9038 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Sun, 24 Nov 2024 21:00:26 +0700 Subject: [PATCH 020/104] rework contract deployment API --- accounts/abi/bind/template2.go | 4 +- accounts/abi/bind/v2/lib.go | 71 ++++++++++++++++++++------------- accounts/abi/bind/v2/v2_test.go | 7 ++-- 3 files changed, 50 insertions(+), 32 deletions(-) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 9c85a466a7ee..ef0b8b5d0d7e 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -38,9 +38,9 @@ var ( {{end}} {{range $contract := .Contracts}} - var {{$contract.Type}}LibraryDeps = map[string]*bind.MetaData{ + var {{$contract.Type}}LibraryDeps = map[string]string{ {{range $name, $pattern := .AllLibraries -}} - "{{$pattern}}": {{$name}}MetaData, + "{{$name}}": "{{$pattern}}", {{ end}} } diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index f00df1b9e733..7c74b441f3eb 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -18,19 +18,26 @@ type ContractInstance struct { Backend bind.ContractBackend } -func deployDeps(backend bind.ContractBackend, auth *bind.TransactOpts, constructorInputs map[string][]byte, contracts map[string]string) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[common.Address]struct{}, err error) { - for pattern, contractBin := range contracts { +func deployContract(backend bind.ContractBackend, auth *bind.TransactOpts, constructor []byte, contract string) (deploymentTx *types.Transaction, deploymentAddr common.Address, err error) { + contractBinBytes, err := hex.DecodeString(contract[2:]) + if err != nil { + return nil, common.Address{}, fmt.Errorf("contract bytecode is not a hex string: %s", contractBinBytes[2:]) + } + addr, tx, _, err := bind.DeployContractRaw(auth, contractBinBytes, backend, constructor) + if err != nil { + return nil, common.Address{}, fmt.Errorf("failed to deploy contract: %v", err) + } + return tx, addr, nil +} + +func deployLibs(backend bind.ContractBackend, auth *bind.TransactOpts, contracts map[string]string) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[common.Address]struct{}, err error) { + for _, contractBin := range contracts { contractBinBytes, err := hex.DecodeString(contractBin[2:]) if err != nil { return deploymentTxs, deployAddrs, fmt.Errorf("contract bytecode is not a hex string: %s", contractBin[2:]) } - var constructorInput []byte - if inp, ok := constructorInputs[pattern]; ok { - constructorInput = inp - } else { - constructorInput = make([]byte, 0) // TODO check if we can pass a nil byte slice here. - } - addr, tx, _, err := bind.DeployContractRaw(auth, contractBinBytes, backend, constructorInput) + // TODO: can pass nil for constructor? + addr, tx, _, err := bind.DeployContractRaw(auth, contractBinBytes, backend, []byte{}) if err != nil { return deploymentTxs, deployAddrs, fmt.Errorf("failed to deploy contract: %v", err) } @@ -41,7 +48,22 @@ func deployDeps(backend bind.ContractBackend, auth *bind.TransactOpts, construct return deploymentTxs, deployAddrs, nil } -func linkDeps(deps *map[string]string, linked *map[string]common.Address) (deployableDeps map[string]string) { +func linkContract(contract string, linkedLibs map[string]common.Address) (deployableContract string, err error) { + reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") + if err != nil { + return "", err + } + + // link in any library the contract depends on + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { + matchingPattern := match[1] + addr := linkedLibs[matchingPattern] + contract = strings.ReplaceAll(contract, matchingPattern, addr.String()) + } + return contract, nil +} + +func linkLibs(deps *map[string]string, linked *map[string]common.Address) (deployableDeps map[string]string) { reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") if err != nil { panic(err) @@ -72,25 +94,23 @@ func linkDeps(deps *map[string]string, linked *map[string]common.Address) (deplo return deployableDeps } -func LinkAndDeployContractsWithOverride(auth *bind.TransactOpts, backend bind.ContractBackend, constructorInputs map[string][]byte, contracts, libs map[string]string, overrides map[string]common.Address) (allDeployTxs map[common.Address]*types.Transaction, allDeployAddrs map[common.Address]struct{}, err error) { - var depsToDeploy map[string]string // map of pattern -> unlinked binary for deps we will deploy - +func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.ContractBackend, constructorInputs []byte, contract *bind.MetaData, libs map[string]string, overrides map[string]common.Address) (allDeployTxs map[common.Address]*types.Transaction, allDeployAddrs map[common.Address]struct{}, err error) { // initialize the set of already-deployed contracts with given override addresses linked := make(map[string]common.Address) for pattern, deployAddr := range overrides { linked[pattern] = deployAddr - if _, ok := contracts[pattern]; ok { - delete(contracts, pattern) + if _, ok := libs[pattern]; ok { + delete(libs, pattern) } } // link and deploy dynamic libraries for { - deployableDeps := linkDeps(&depsToDeploy, &linked) + deployableDeps := linkLibs(&libs, &linked) if len(deployableDeps) == 0 { break } - deployTxs, deployAddrs, err := deployDeps(backend, auth, constructorInputs, deployableDeps) + deployTxs, deployAddrs, err := deployLibs(backend, auth, deployableDeps) for addr, _ := range deployAddrs { allDeployAddrs[addr] = struct{}{} } @@ -101,17 +121,14 @@ func LinkAndDeployContractsWithOverride(auth *bind.TransactOpts, backend bind.Co return deployTxs, allDeployAddrs, err } } - - // link and deploy the contracts - contractBins := make(map[string]string) - linkedContracts := linkDeps(&contractBins, &linked) - deployTxs, deployAddrs, err := deployDeps(backend, auth, constructorInputs, linkedContracts) - for addr, _ := range deployAddrs { - allDeployAddrs[addr] = struct{}{} - } - for addr, tx := range deployTxs { - allDeployTxs[addr] = tx + linkedContract, err := linkContract(contract.Bin, linked) + if err != nil { + return allDeployTxs, allDeployAddrs, err } + // link and deploy the contracts + contractTx, contractAddr, err := deployContract(backend, auth, constructorInputs, linkedContract) + allDeployAddrs[contractAddr] = struct{}{} + allDeployTxs[contractAddr] = contractTx return allDeployTxs, allDeployAddrs, err } diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index 9250093939b4..585dfd2642ea 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -163,12 +163,13 @@ func TestDeployment(t *testing.T) { log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stdout, log.LevelDebug, true))) - ///LinkAndDeployContractsWithOverride(&opts, bindBackend, v2_test) - deployTxs, err := DeployContracts(&opts, bindBackend, []byte{}, v2_testcase_library.TestArrayLibraryDeps) + // TODO: add public interface for deploy library, deploy contract (or make them same method?) + // want to allow more flexibility. + txs, _, err := LinkAndDeployContractWithOverrides(&opts, bindBackend, []byte{}, v2_testcase_library.TestArrayMetaData, v2_testcase_library.TestArrayLibraryDeps, nil) if err != nil { t.Fatalf("err: %+v\n", err) } - for _, tx := range deployTxs { + for _, tx := range txs { fmt.Println("waiting for deployment") _, err = bind.WaitDeployed(context.Background(), &bindBackend, tx) if err != nil { From 3fa52cdfa08d3b198ea06c025f94ca4c6200be5c Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Sun, 24 Nov 2024 21:53:31 +0700 Subject: [PATCH 021/104] closer to test passing now... --- accounts/abi/bind/template2.go | 5 +++-- accounts/abi/bind/v2/lib.go | 34 ++++++++++++++++++++++++++------- accounts/abi/bind/v2/v2_test.go | 6 ++++++ 3 files changed, 36 insertions(+), 9 deletions(-) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index ef0b8b5d0d7e..14cc08cafb2e 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -38,12 +38,13 @@ var ( {{end}} {{range $contract := .Contracts}} - var {{$contract.Type}}LibraryDeps = map[string]string{ + var {{$contract.Type}}LibraryDeps = map[string]*bind.MetaData{ {{range $name, $pattern := .AllLibraries -}} - "{{$name}}": "{{$pattern}}", + "{{$pattern}}": {{$name}}MetaData, {{ end}} } + // TODO: convert this type to value type after everything works. // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract. var {{.Type}}MetaData = &bind.MetaData{ ABI: "{{.InputABI}}", diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 7c74b441f3eb..47555da37848 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -30,8 +30,11 @@ func deployContract(backend bind.ContractBackend, auth *bind.TransactOpts, const return tx, addr, nil } -func deployLibs(backend bind.ContractBackend, auth *bind.TransactOpts, contracts map[string]string) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[common.Address]struct{}, err error) { - for _, contractBin := range contracts { +func deployLibs(backend bind.ContractBackend, auth *bind.TransactOpts, contracts map[string]string) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[string]common.Address, err error) { + deploymentTxs = make(map[common.Address]*types.Transaction) + deployAddrs = make(map[string]common.Address) + + for pattern, contractBin := range contracts { contractBinBytes, err := hex.DecodeString(contractBin[2:]) if err != nil { return deploymentTxs, deployAddrs, fmt.Errorf("contract bytecode is not a hex string: %s", contractBin[2:]) @@ -42,7 +45,7 @@ func deployLibs(backend bind.ContractBackend, auth *bind.TransactOpts, contracts return deploymentTxs, deployAddrs, fmt.Errorf("failed to deploy contract: %v", err) } deploymentTxs[addr] = tx - deployAddrs[addr] = struct{}{} + deployAddrs[pattern] = addr } return deploymentTxs, deployAddrs, nil @@ -58,7 +61,7 @@ func linkContract(contract string, linkedLibs map[string]common.Address) (deploy for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { matchingPattern := match[1] addr := linkedLibs[matchingPattern] - contract = strings.ReplaceAll(contract, matchingPattern, addr.String()) + contract = strings.ReplaceAll(contract, "__$"+matchingPattern+"$__", addr.String()[2:]) } return contract, nil } @@ -75,17 +78,22 @@ func linkLibs(deps *map[string]string, linked *map[string]common.Address) (deplo deployableDeps = make(map[string]string) for pattern, dep := range *deps { + fmt.Printf("dep is:\n%s\n", dep) + fmt.Println(pattern) // attempt to replace references to every single linked dep for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(dep, -1) { matchingPattern := match[1] + fmt.Printf("has matching pattern %s\n", matchingPattern) addr, ok := (*linked)[matchingPattern] if !ok { continue } - (*deps)[pattern] = strings.ReplaceAll(dep, matchingPattern, addr.String()) + (*deps)[pattern] = strings.ReplaceAll(dep, "__$"+matchingPattern+"$__", addr.String()[2:]) + fmt.Printf("lib after linking:\n%s\n", (*deps)[pattern]) } // if we linked something into this dep, see if it can be deployed if !reMatchAnyPattern.MatchString((*deps)[pattern]) { + fmt.Printf("is deployable %s\n", pattern) deployableDeps[pattern] = (*deps)[pattern] delete(*deps, pattern) } @@ -94,8 +102,18 @@ func linkLibs(deps *map[string]string, linked *map[string]common.Address) (deplo return deployableDeps } -func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.ContractBackend, constructorInputs []byte, contract *bind.MetaData, libs map[string]string, overrides map[string]common.Address) (allDeployTxs map[common.Address]*types.Transaction, allDeployAddrs map[common.Address]struct{}, err error) { +func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.ContractBackend, constructorInputs []byte, contract *bind.MetaData, libMetas map[string]*bind.MetaData, overrides map[string]common.Address) (allDeployTxs map[common.Address]*types.Transaction, allDeployAddrs map[common.Address]struct{}, err error) { // initialize the set of already-deployed contracts with given override addresses + + allDeployAddrs = make(map[common.Address]struct{}) + allDeployTxs = make(map[common.Address]*types.Transaction) + + // re-express libraries as a map of pattern -> pre-linking binary + libs := make(map[string]string) + for pattern, meta := range libMetas { + libs[pattern] = meta.Bin + } + linked := make(map[string]common.Address) for pattern, deployAddr := range overrides { linked[pattern] = deployAddr @@ -111,8 +129,10 @@ func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.Co break } deployTxs, deployAddrs, err := deployLibs(backend, auth, deployableDeps) - for addr, _ := range deployAddrs { + for pattern, addr := range deployAddrs { allDeployAddrs[addr] = struct{}{} + linked[pattern] = addr + fmt.Printf("we've linked %s\n", pattern) } for addr, tx := range deployTxs { allDeployTxs[addr] = tx diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index 585dfd2642ea..f756f384111c 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -165,6 +165,12 @@ func TestDeployment(t *testing.T) { // TODO: add public interface for deploy library, deploy contract (or make them same method?) // want to allow more flexibility. + + // also, i kind of hate this conversion. But the API of LinkAndDeployContractWithOverrides feels cleaner this way... idk. + libMetas := make(map[string]*bind.MetaData) + for pattern, metadata := range v2_testcase_library.TestArrayLibraryDeps { + libMetas[pattern] = metadata + } txs, _, err := LinkAndDeployContractWithOverrides(&opts, bindBackend, []byte{}, v2_testcase_library.TestArrayMetaData, v2_testcase_library.TestArrayLibraryDeps, nil) if err != nil { t.Fatalf("err: %+v\n", err) From b45d532a015b780b26392477371524750ab8890b Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Sun, 24 Nov 2024 22:32:11 +0700 Subject: [PATCH 022/104] fix contract --- accounts/abi/bind/base.go | 7 ++++++- .../abi/bind/testdata/v2_testcase_library/contract.sol | 4 ---- accounts/abi/bind/v2/lib.go | 1 + accounts/abi/bind/v2/v2_test.go | 9 ++++----- core/vm/interpreter.go | 1 + 5 files changed, 12 insertions(+), 10 deletions(-) diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index bb7301e965cb..4d16d675ffbf 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -401,7 +401,12 @@ func (c *BoundContract) estimateGasLimit(opts *TransactOpts, contract *common.Ad Value: value, Data: input, } - return c.transactor.EstimateGas(ensureContext(opts.Context), msg) + res, err := c.transactor.EstimateGas(ensureContext(opts.Context), msg) + if err != nil { + fmt.Printf("msg data is %x\n", msg.Data) + panic(err) + } + return res, nil } func (c *BoundContract) getNonce(opts *TransactOpts) (uint64, error) { diff --git a/accounts/abi/bind/testdata/v2_testcase_library/contract.sol b/accounts/abi/bind/testdata/v2_testcase_library/contract.sol index 399f5c41cd22..6eca029fddfd 100644 --- a/accounts/abi/bind/testdata/v2_testcase_library/contract.sol +++ b/accounts/abi/bind/testdata/v2_testcase_library/contract.sol @@ -37,8 +37,4 @@ contract TestArray { assert(arr[0] == 0); assert(arr[1] == 2); } - - constructor(uint256 foobar) { - - } } diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 47555da37848..288f0bcce504 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -23,6 +23,7 @@ func deployContract(backend bind.ContractBackend, auth *bind.TransactOpts, const if err != nil { return nil, common.Address{}, fmt.Errorf("contract bytecode is not a hex string: %s", contractBinBytes[2:]) } + fmt.Println("before DeployContractRaw") addr, tx, _, err := bind.DeployContractRaw(auth, contractBinBytes, backend, constructor) if err != nil { return nil, common.Address{}, fmt.Errorf("failed to deploy contract: %v", err) diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index f756f384111c..245800a9effe 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -3,7 +3,6 @@ package v2 import ( "context" "encoding/json" - "fmt" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2_generated_testcase" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2_testcase_library" @@ -163,20 +162,20 @@ func TestDeployment(t *testing.T) { log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stdout, log.LevelDebug, true))) - // TODO: add public interface for deploy library, deploy contract (or make them same method?) - // want to allow more flexibility. - + // TODO: allow for the flexibility of deploying only libraries. // also, i kind of hate this conversion. But the API of LinkAndDeployContractWithOverrides feels cleaner this way... idk. libMetas := make(map[string]*bind.MetaData) for pattern, metadata := range v2_testcase_library.TestArrayLibraryDeps { libMetas[pattern] = metadata } + + // TODO: test case with arguments-containing constructor txs, _, err := LinkAndDeployContractWithOverrides(&opts, bindBackend, []byte{}, v2_testcase_library.TestArrayMetaData, v2_testcase_library.TestArrayLibraryDeps, nil) if err != nil { t.Fatalf("err: %+v\n", err) } + bindBackend.Commit() for _, tx := range txs { - fmt.Println("waiting for deployment") _, err = bind.WaitDeployed(context.Background(), &bindBackend, tx) if err != nil { t.Fatalf("error deploying bound contract: %+v", err) diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index c40899440174..a23025fe5586 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -241,6 +241,7 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) ( // Get the operation from the jump table and validate the stack to ensure there are // enough stack items available to perform the operation. op = contract.GetOp(pc) + fmt.Printf("op name is: %s\n", op.String()) operation := in.table[op] cost = operation.constantGas // For tracing // Validate stack From 9e388bd35a3385e2fb5b8bd257d1b6348f1d747b Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 25 Nov 2024 14:30:29 +0700 Subject: [PATCH 023/104] update library test contract to have constructor with inputs. remove some debug print statements --- accounts/abi/bind/template2.go | 2 +- .../bind/testdata/v2_testcase_library/contract.sol | 5 +++++ accounts/abi/bind/v2/lib.go | 13 ++----------- accounts/abi/bind/v2/v2_test.go | 10 +++++++++- core/vm/interpreter.go | 1 - 5 files changed, 17 insertions(+), 14 deletions(-) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 14cc08cafb2e..3cf663c96e72 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -76,7 +76,7 @@ var ( // TODO: create custom exported types where unpack would generate a struct return. // TODO: test constructor with inputs - func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ([]byte, error) { + func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}} {{.Name}} {{bindtype .Type $structs}}, {{end}}) ([]byte, error) { return _{{$contract.Type}}.abi.Pack("" {{range .Constructor.Inputs}}, {{.Name}}{{end}}) } diff --git a/accounts/abi/bind/testdata/v2_testcase_library/contract.sol b/accounts/abi/bind/testdata/v2_testcase_library/contract.sol index 6eca029fddfd..1636c8b00bc4 100644 --- a/accounts/abi/bind/testdata/v2_testcase_library/contract.sol +++ b/accounts/abi/bind/testdata/v2_testcase_library/contract.sol @@ -37,4 +37,9 @@ contract TestArray { assert(arr[0] == 0); assert(arr[1] == 2); } + + // a constructor with parameters + constructor(uint256 foo) { + + } } diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 288f0bcce504..34a0f16ada27 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -23,7 +23,6 @@ func deployContract(backend bind.ContractBackend, auth *bind.TransactOpts, const if err != nil { return nil, common.Address{}, fmt.Errorf("contract bytecode is not a hex string: %s", contractBinBytes[2:]) } - fmt.Println("before DeployContractRaw") addr, tx, _, err := bind.DeployContractRaw(auth, contractBinBytes, backend, constructor) if err != nil { return nil, common.Address{}, fmt.Errorf("failed to deploy contract: %v", err) @@ -79,42 +78,35 @@ func linkLibs(deps *map[string]string, linked *map[string]common.Address) (deplo deployableDeps = make(map[string]string) for pattern, dep := range *deps { - fmt.Printf("dep is:\n%s\n", dep) - fmt.Println(pattern) // attempt to replace references to every single linked dep for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(dep, -1) { matchingPattern := match[1] - fmt.Printf("has matching pattern %s\n", matchingPattern) addr, ok := (*linked)[matchingPattern] if !ok { continue } (*deps)[pattern] = strings.ReplaceAll(dep, "__$"+matchingPattern+"$__", addr.String()[2:]) - fmt.Printf("lib after linking:\n%s\n", (*deps)[pattern]) } // if we linked something into this dep, see if it can be deployed if !reMatchAnyPattern.MatchString((*deps)[pattern]) { - fmt.Printf("is deployable %s\n", pattern) deployableDeps[pattern] = (*deps)[pattern] delete(*deps, pattern) } } - return deployableDeps } func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.ContractBackend, constructorInputs []byte, contract *bind.MetaData, libMetas map[string]*bind.MetaData, overrides map[string]common.Address) (allDeployTxs map[common.Address]*types.Transaction, allDeployAddrs map[common.Address]struct{}, err error) { - // initialize the set of already-deployed contracts with given override addresses - allDeployAddrs = make(map[common.Address]struct{}) allDeployTxs = make(map[common.Address]*types.Transaction) - // re-express libraries as a map of pattern -> pre-linking binary + // re-express libraries as a map of pattern -> pre-link binary libs := make(map[string]string) for pattern, meta := range libMetas { libs[pattern] = meta.Bin } + // initialize the set of already-deployed contracts with given override addresses linked := make(map[string]common.Address) for pattern, deployAddr := range overrides { linked[pattern] = deployAddr @@ -133,7 +125,6 @@ func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.Co for pattern, addr := range deployAddrs { allDeployAddrs[addr] = struct{}{} linked[pattern] = addr - fmt.Printf("we've linked %s\n", pattern) } for addr, tx := range deployTxs { allDeployTxs[addr] = tx diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index 245800a9effe..5ac61c916f15 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -169,8 +169,16 @@ func TestDeployment(t *testing.T) { libMetas[pattern] = metadata } + ctrct, err := v2_testcase_library.NewTestArray() + if err != nil { + panic(err) + } + constructorInput, err := ctrct.PackConstructor(big.NewInt(42), false) + if err != nil { + t.Fatalf("fack %v", err) + } // TODO: test case with arguments-containing constructor - txs, _, err := LinkAndDeployContractWithOverrides(&opts, bindBackend, []byte{}, v2_testcase_library.TestArrayMetaData, v2_testcase_library.TestArrayLibraryDeps, nil) + txs, _, err := LinkAndDeployContractWithOverrides(&opts, bindBackend, constructorInput, v2_testcase_library.TestArrayMetaData, v2_testcase_library.TestArrayLibraryDeps, nil) if err != nil { t.Fatalf("err: %+v\n", err) } diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index a23025fe5586..c40899440174 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -241,7 +241,6 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) ( // Get the operation from the jump table and validate the stack to ensure there are // enough stack items available to perform the operation. op = contract.GetOp(pc) - fmt.Printf("op name is: %s\n", op.String()) operation := in.table[op] cost = operation.constantGas // For tracing // Validate stack From e552b8b1d2f992292014db07c6243ec5236177f8 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 25 Nov 2024 14:36:22 +0700 Subject: [PATCH 024/104] format improvements --- accounts/abi/abi.go | 1 - accounts/abi/bind/v2/lib.go | 1 - 2 files changed, 2 deletions(-) diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go index f92dd6c2c69c..f75278c8b101 100644 --- a/accounts/abi/abi.go +++ b/accounts/abi/abi.go @@ -50,7 +50,6 @@ func JSON(reader io.Reader) (ABI, error) { var abi ABI if err := dec.Decode(&abi); err != nil { - fmt.Println(err) return ABI{}, err } return abi, nil diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 34a0f16ada27..57795de2ecf3 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -56,7 +56,6 @@ func linkContract(contract string, linkedLibs map[string]common.Address) (deploy if err != nil { return "", err } - // link in any library the contract depends on for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { matchingPattern := match[1] From 46908d018875e5c261026e4ca7135752e83d61e1 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 26 Nov 2024 15:54:18 +0700 Subject: [PATCH 025/104] add missing files from testdata. refactor contract deployment API to be cleaner --- accounts/abi/bind/base.go | 11 +- accounts/abi/bind/bind.go | 18 +- accounts/abi/bind/template.go | 9 +- accounts/abi/bind/template2.go | 2 + .../abi/bind/testdata/v2/events/contract.sol | 0 .../testdata/v2/nested_libraries/abi.json | 1 + .../testdata/v2/nested_libraries/bindings.go | 501 ++++++++++++++++++ .../v2/nested_libraries/combined-abi.json | 1 + .../testdata/v2/nested_libraries/contract.sol | 82 +++ .../v2/v2_generated_testcase/abi.json | 2 + .../v2/v2_generated_testcase/contract.bin | 1 + .../v2/v2_generated_testcase/contract.sol | 51 ++ .../v2_generated_testcase/example_contract.go | 199 +++++++ .../testdata/v2_testcase_library/contract.sol | 45 -- accounts/abi/bind/v2/lib.go | 71 ++- accounts/abi/bind/v2/v2_test.go | 80 ++- 16 files changed, 990 insertions(+), 84 deletions(-) create mode 100644 accounts/abi/bind/testdata/v2/events/contract.sol create mode 100644 accounts/abi/bind/testdata/v2/nested_libraries/abi.json create mode 100644 accounts/abi/bind/testdata/v2/nested_libraries/bindings.go create mode 100644 accounts/abi/bind/testdata/v2/nested_libraries/combined-abi.json create mode 100644 accounts/abi/bind/testdata/v2/nested_libraries/contract.sol create mode 100644 accounts/abi/bind/testdata/v2/v2_generated_testcase/abi.json create mode 100644 accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.bin create mode 100644 accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.sol create mode 100644 accounts/abi/bind/testdata/v2/v2_generated_testcase/example_contract.go delete mode 100644 accounts/abi/bind/testdata/v2_testcase_library/contract.sol diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index 4d16d675ffbf..eb24b4b977c2 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -89,11 +89,12 @@ type WatchOpts struct { // MetaData collects all metadata for a bound contract. type MetaData struct { - mu sync.Mutex - Sigs map[string]string - Bin string - ABI string - ab *abi.ABI + mu sync.Mutex + Sigs map[string]string + Bin string + ABI string + ab *abi.ABI + Pattern string } func (m *MetaData) GetAbi() (*abi.ABI, error) { diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index e7e31e6b03f3..a4655bb64a54 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -101,6 +101,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { data, err := bind(types, abis, bytecodes, fsigs, pkg, libs, aliases) + if err != nil { return "", err } @@ -396,12 +397,21 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] } } + // map of contract name -> pattern + invertedLibs := make(map[string]string) + // assume that this is invertible/onto because I assume library names are unique now + // TODO: check that they've been sanitized at this point. + for pattern, name := range libs { + invertedLibs[name] = pattern + } + // Generate the contract template data content and render it data := &tmplData{ - Package: pkg, - Contracts: contracts, - Libraries: libs, - Structs: structs, + Package: pkg, + Contracts: contracts, + Libraries: libs, + InvertedLibs: invertedLibs, + Structs: structs, } return data, nil } diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index 2e7ff7f4f57c..f304286ffbe6 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -24,10 +24,11 @@ import ( // tmplData is the data structure required to fill the binding template. type tmplData struct { - Package string // Name of the package to place the generated file in - Contracts map[string]*tmplContract // List of contracts to generate into this file - Libraries map[string]string // Map the bytecode's link pattern to the library name - Structs map[string]*tmplStruct // Contract struct type definitions + Package string // Name of the package to place the generated file in + Contracts map[string]*tmplContract // List of contracts to generate into this file + Libraries map[string]string // Map the bytecode's link pattern to the library name + InvertedLibs map[string]string // map of the contract's name to the link pattern + Structs map[string]*tmplStruct // Contract struct type definitions } // tmplContract contains the data needed to generate an individual contract binding. diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 3cf663c96e72..42ea61e88a2d 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -38,6 +38,7 @@ var ( {{end}} {{range $contract := .Contracts}} + // TODO: turn this into a list, now that the pattern is embedded in each MetaData object var {{$contract.Type}}LibraryDeps = map[string]*bind.MetaData{ {{range $name, $pattern := .AllLibraries -}} "{{$pattern}}": {{$name}}MetaData, @@ -48,6 +49,7 @@ var ( // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract. var {{.Type}}MetaData = &bind.MetaData{ ABI: "{{.InputABI}}", + Pattern: "{{index $.InvertedLibs .Type}}", {{if $contract.FuncSigs -}} Sigs: map[string]string{ {{range $strsig, $binsig := .FuncSigs}}"{{$binsig}}": "{{$strsig}}", diff --git a/accounts/abi/bind/testdata/v2/events/contract.sol b/accounts/abi/bind/testdata/v2/events/contract.sol new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/abi.json b/accounts/abi/bind/testdata/v2/nested_libraries/abi.json new file mode 100644 index 000000000000..7cfcdaa93a4d --- /dev/null +++ b/accounts/abi/bind/testdata/v2/nested_libraries/abi.json @@ -0,0 +1 @@ +{"contracts":{"contract.sol:Array":{"abi":[],"bin":"61044261004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c8063677ca2d814610038575b5f80fd5b818015610043575f80fd5b5061005e60048036038101906100599190610235565b610060565b005b5f8280549050116100a6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161009d906102cd565b60405180910390fd5b81600183805490506100b89190610318565b815481106100c9576100c861034b565b5b905f5260205f2001548282815481106100e5576100e461034b565b5b905f5260205f2001819055508181815481106101045761010361034b565b5b905f5260205f20015473__$e0273646c631009d12385ab5282af2d432$__63ee05608590916040518263ffffffff1660e01b81526004016101459190610387565b602060405180830381865af4158015610160573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061018491906103b4565b8282815481106101975761019661034b565b5b905f5260205f200181905550818054806101b4576101b36103df565b5b600190038181905f5260205f20015f905590555050565b5f80fd5b5f819050919050565b6101e1816101cf565b81146101eb575f80fd5b50565b5f813590506101fc816101d8565b92915050565b5f819050919050565b61021481610202565b811461021e575f80fd5b50565b5f8135905061022f8161020b565b92915050565b5f806040838503121561024b5761024a6101cb565b5b5f610258858286016101ee565b925050602061026985828601610221565b9150509250929050565b5f82825260208201905092915050565b7f43616e27742072656d6f76652066726f6d20656d7074792061727261790000005f82015250565b5f6102b7601d83610273565b91506102c282610283565b602082019050919050565b5f6020820190508181035f8301526102e4816102ab565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61032282610202565b915061032d83610202565b9250828203905081811115610345576103446102eb565b5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b61038181610202565b82525050565b5f60208201905061039a5f830184610378565b92915050565b5f815190506103ae8161020b565b92915050565b5f602082840312156103c9576103c86101cb565b5b5f6103d6848285016103a0565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603160045260245ffdfea26469706673582212200680afb351728e7eaa7168f68e59cd7151eff98288314447ad7638a444ed11de64736f6c634300081a0033"},"contract.sol:RecursiveDep":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"AddOne","outputs":[{"internalType":"uint256","name":"ret","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61019d61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c8063ee05608514610038575b5f80fd5b610052600480360381019061004d91906100b4565b610068565b60405161005f91906100ee565b60405180910390f35b5f6001826100769190610134565b9050919050565b5f80fd5b5f819050919050565b61009381610081565b811461009d575f80fd5b50565b5f813590506100ae8161008a565b92915050565b5f602082840312156100c9576100c861007d565b5b5f6100d6848285016100a0565b91505092915050565b6100e881610081565b82525050565b5f6020820190506101015f8301846100df565b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61013e82610081565b915061014983610081565b925082820190508082111561016157610160610107565b5b9291505056fea2646970667358221220d392325a1e387a65c76bff6fecec456650b48856b1e00afc4fa76fb9181da23c64736f6c634300081a0033"},"contract.sol:TestArray":{"abi":[{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"arr","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"testArrayRemove","outputs":[],"stateMutability":"nonpayable","type":"function"}],"bin":"6080604052348015600e575f80fd5b506103438061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c806371e5ee5f14610038578063807fc49a14610068575b5f80fd5b610052600480360381019061004d91906101f0565b610084565b60405161005f919061022a565b60405180910390f35b610082600480360381019061007d91906101f0565b6100a3565b005b5f8181548110610092575f80fd5b905f5260205f20015f915090505481565b5f5b60038110156100e0575f81908060018154018082558091505060019003905f5260205f20015f909190919091505580806001019150506100a5565b505f73__$37f5055d0d00ca8ab20a50453e6986094c$__63677ca2d8909160016040518363ffffffff1660e01b815260040161011d92919061028c565b5f6040518083038186803b158015610133575f80fd5b505af4158015610145573d5f803e3d5ffd5b5050505060025f805490501461015e5761015d6102b3565b5b5f805f81548110610172576101716102e0565b5b905f5260205f20015414610189576101886102b3565b5b60025f60018154811061019f5761019e6102e0565b5b905f5260205f200154146101b6576101b56102b3565b5b50565b5f80fd5b5f819050919050565b6101cf816101bd565b81146101d9575f80fd5b50565b5f813590506101ea816101c6565b92915050565b5f60208284031215610205576102046101b9565b5b5f610212848285016101dc565b91505092915050565b610224816101bd565b82525050565b5f60208201905061023d5f83018461021b565b92915050565b8082525050565b5f819050919050565b5f819050919050565b5f61027661027161026c8461024a565b610253565b6101bd565b9050919050565b6102868161025c565b82525050565b5f60408201905061029f5f830185610243565b6102ac602083018461027d565b9392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52600160045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffdfea26469706673582212204be2c6230af664b290f016e88cfac62bf7c08823b1fd1bcce8bdcd7fbb785b8a64736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go new file mode 100644 index 000000000000..6f0b525acc62 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go @@ -0,0 +1,501 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package nested_libraries + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: turn this into a list, now that the pattern is embedded in each MetaData object +var C1LibraryDeps = map[string]*bind.MetaData{ + "ffc1393672b8ed81d0c8093ffcb0e7fbe8": L1MetaData, + "d03b97f5e1a564374023a72ac7d1806773": L3MetaData, + "d600bc30c225801bf5b413866ae334453d": L5MetaData, +} + +// 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__$d600bc30c225801bf5b413866ae334453d$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea264697066735822122068ad2fa18c18d049dd707b5914a0aa9abd5c5f624e2f4886a07f9440f05fb91864736f6c634300081a0033", +} + +// 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 +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_C1 *C1) PackConstructor(v1 *big.Int, v2 *big.Int) ([]byte, error) { + return _C1.abi.Pack("", v1, v2) +} + +// 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: turn this into a list, now that the pattern is embedded in each MetaData object +var C2LibraryDeps = map[string]*bind.MetaData{ + "ffc1393672b8ed81d0c8093ffcb0e7fbe8": L1MetaData, + "fd1474cf57f7ed48491e8bfdfd0d172adf": L2bMetaData, + "6070639404c39b5667691bb1f9177e1eac": L4bMetaData, +} + +// 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$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea2646970667358221220607a5019c269337b096c81ff7e87c99fc5415a2b6f40cc072d5e88396706090e64736f6c634300081a0033", +} + +// 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 +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_C2 *C2) PackConstructor(v1 *big.Int, v2 *big.Int) ([]byte, error) { + return _C2.abi.Pack("", v1, v2) +} + +// 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: turn this into a list, now that the pattern is embedded in each MetaData object +var L1LibraryDeps = map[string]*bind.MetaData{} + +// 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: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea264697066735822122078914f7e9af117523b8392de05343b4af49014337eaffc86ff537b0ff54fd1ed64736f6c634300081a0033", +} + +// 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 +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_L1 *L1) PackConstructor() ([]byte, error) { + return _L1.abi.Pack("") +} + +// 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: turn this into a list, now that the pattern is embedded in each MetaData object +var L2LibraryDeps = map[string]*bind.MetaData{} + +// 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: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea26469706673582212205248bdbd4b939a2e899770a55b8b960ed9b95b22e949c50b4e0f94e27f1a764164736f6c634300081a0033", +} + +// 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 +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_L2 *L2) PackConstructor() ([]byte, error) { + return _L2.abi.Pack("") +} + +// 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: turn this into a list, now that the pattern is embedded in each MetaData object +var L2bLibraryDeps = map[string]*bind.MetaData{} + +// 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$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220f2bec4e215b51a06ae5161d6a1fa3130877fb447fe26cf7cc5d1791ed58ec8ba64736f6c634300081a0033", +} + +// 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 +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_L2b *L2b) PackConstructor() ([]byte, error) { + return _L2b.abi.Pack("") +} + +// 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: turn this into a list, now that the pattern is embedded in each MetaData object +var L3LibraryDeps = map[string]*bind.MetaData{} + +// 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: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea26469706673582212201a3e05a0b6b9da6c9f39bee5a339d955347a2c736f2a1e6350c33c2c3ba9764864736f6c634300081a0033", +} + +// 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 +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_L3 *L3) PackConstructor() ([]byte, error) { + return _L3.abi.Pack("") +} + +// 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: turn this into a list, now that the pattern is embedded in each MetaData object +var L4LibraryDeps = map[string]*bind.MetaData{} + +// 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: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea2646970667358221220776962c71be9e15d17f5a247c2429fddd2e4b2a533e34d9c5e2e324ee6bd76af64736f6c634300081a0033", +} + +// 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 +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_L4 *L4) PackConstructor() ([]byte, error) { + return _L4.abi.Pack("") +} + +// 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: turn this into a list, now that the pattern is embedded in each MetaData object +var L4bLibraryDeps = map[string]*bind.MetaData{} + +// 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$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220efbb5a71ca406bdf7337c785a57fcc2211efa82182e9330541e41f7f3cbbfd6864736f6c634300081a0033", +} + +// 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 +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_L4b *L4b) PackConstructor() ([]byte, error) { + return _L4b.abi.Pack("") +} + +// 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 + +} + +// TODO: turn this into a list, now that the pattern is embedded in each MetaData object +var L5LibraryDeps = map[string]*bind.MetaData{} + +// TODO: convert this type to value type after everything works. +// L5MetaData contains all meta data concerning the L5 contract. +var L5MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "d600bc30c225801bf5b413866ae334453d", + Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$d03b97f5e1a564374023a72ac7d1806773$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea26469706673582212209c255a72b1a53a20d1e2234d9692aba8973d3aa7271f120c00fe0fde8226532f64736f6c634300081a0033", +} + +// L5 is an auto generated Go binding around an Ethereum contract. +type L5 struct { + abi abi.ABI +} + +// NewL5 creates a new instance of L5. +func NewL5() (*L5, error) { + parsed, err := L5MetaData.GetAbi() + if err != nil { + return nil, err + } + return &L5{abi: *parsed}, nil +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_L5 *L5) PackConstructor() ([]byte, error) { + return _L5.abi.Pack("") +} + +// Do is a free data retrieval call binding the contract method 0x2ad11272. +// +// Solidity: function Do(uint256 val) pure returns(uint256) +func (_L5 *L5) PackDo(val *big.Int) ([]byte, error) { + return _L5.abi.Pack("Do", val) +} + +func (_L5 *L5) UnpackDo(data []byte) (*big.Int, error) { + out, err := _L5.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/testdata/v2/nested_libraries/combined-abi.json b/accounts/abi/bind/testdata/v2/nested_libraries/combined-abi.json new file mode 100644 index 000000000000..5a67ee85fa8e --- /dev/null +++ b/accounts/abi/bind/testdata/v2/nested_libraries/combined-abi.json @@ -0,0 +1 @@ +{"contracts":{"contract.sol:C1":{"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"}],"bin":"6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$d600bc30c225801bf5b413866ae334453d$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea264697066735822122068ad2fa18c18d049dd707b5914a0aa9abd5c5f624e2f4886a07f9440f05fb91864736f6c634300081a0033"},"contract.sol:C2":{"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"}],"bin":"6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$6070639404c39b5667691bb1f9177e1eac$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea2646970667358221220607a5019c269337b096c81ff7e87c99fc5415a2b6f40cc072d5e88396706090e64736f6c634300081a0033"},"contract.sol:L1":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea264697066735822122078914f7e9af117523b8392de05343b4af49014337eaffc86ff537b0ff54fd1ed64736f6c634300081a0033"},"contract.sol:L2":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea26469706673582212205248bdbd4b939a2e899770a55b8b960ed9b95b22e949c50b4e0f94e27f1a764164736f6c634300081a0033"},"contract.sol:L2b":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220f2bec4e215b51a06ae5161d6a1fa3130877fb447fe26cf7cc5d1791ed58ec8ba64736f6c634300081a0033"},"contract.sol:L3":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea26469706673582212201a3e05a0b6b9da6c9f39bee5a339d955347a2c736f2a1e6350c33c2c3ba9764864736f6c634300081a0033"},"contract.sol:L4":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea2646970667358221220776962c71be9e15d17f5a247c2429fddd2e4b2a533e34d9c5e2e324ee6bd76af64736f6c634300081a0033"},"contract.sol:L4b":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$fd1474cf57f7ed48491e8bfdfd0d172adf$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220efbb5a71ca406bdf7337c785a57fcc2211efa82182e9330541e41f7f3cbbfd6864736f6c634300081a0033"},"contract.sol:L5":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$d03b97f5e1a564374023a72ac7d1806773$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea26469706673582212209c255a72b1a53a20d1e2234d9692aba8973d3aa7271f120c00fe0fde8226532f64736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/contract.sol b/accounts/abi/bind/testdata/v2/nested_libraries/contract.sol new file mode 100644 index 000000000000..b05d06f9f642 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/nested_libraries/contract.sol @@ -0,0 +1,82 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.26; + + +// L1 +// \ +// L2 L3 L1 +// \ / / +// L4 / +// \ / +// C1 +// +library L1 { + function Do(uint256 val) public pure returns (uint256) { + return uint256(1); + } +} + +library L2 { + function Do(uint256 val) public pure returns (uint256) { + return uint256(1); + } +} + +library L3 { + function Do(uint256 val) public pure returns (uint256) { + return L1.Do(uint256(val)) + uint256(1); + } +} + +library L4 { + function Do(uint256 val) public pure returns (uint256) { + return uint256(1); + } +} + +library L5 { + function Do(uint256 val) public pure returns (uint256) { + return L3.Do(uint256(val)) + uint256(1); + } +} + +contract C1 { + function Do(uint256 val) public pure returns (uint256 res) { + return L5.Do(uint256(val)) + L1.Do(uint256(0)) + uint256(1); + } + + constructor(uint256 v1, uint256 v2) { + // do something with these + } +} + +// second contract+libraries: slightly different library deps than V1, but sharing several +// L1 +// \ +// L2b L3 L1 +// \ / / +// L4b / +// \ / +// C2 +// +library L4b { + function Do(uint256 val) public pure returns (uint256) { + return L2b.Do(uint256(val)) + uint256(1); + } +} + +library L2b { + function Do(uint256 val) public pure returns (uint256) { + return L1.Do(uint256(val)) + uint256(1); + } +} + +contract C2 { + function Do(uint256 val) public pure returns (uint256 res) { + return L4b.Do(uint256(val)) + L1.Do(uint256(0)) + uint256(1); + } + + constructor(uint256 v1, uint256 v2) { + // do something with these + } +} \ No newline at end of file diff --git a/accounts/abi/bind/testdata/v2/v2_generated_testcase/abi.json b/accounts/abi/bind/testdata/v2/v2_generated_testcase/abi.json new file mode 100644 index 000000000000..d9d45d33a4e1 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/v2_generated_testcase/abi.json @@ -0,0 +1,2 @@ + +[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"firstArg","type":"uint256"},{"indexed":false,"internalType":"string","name":"secondArg","type":"string"}],"name":"Basic","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"firstArg","type":"uint256"},{"components":[{"internalType":"int256","name":"val1","type":"int256"},{"internalType":"int256","name":"val2","type":"int256"},{"internalType":"string","name":"val3","type":"string"}],"indexed":false,"internalType":"struct Example.exampleStruct","name":"secondArg","type":"tuple"}],"name":"Struct","type":"event"},{"inputs":[],"name":"emitEvent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emitEventsDiffTypes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emitTwoEvents","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"num","type":"uint256"}],"name":"mutateStorageVal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"retrieveStorageVal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}] diff --git a/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.bin b/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.bin new file mode 100644 index 000000000000..80fb73db5994 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.bin @@ -0,0 +1 @@ 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 diff --git a/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.sol b/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.sol new file mode 100644 index 000000000000..e48a07f8547f --- /dev/null +++ b/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.sol @@ -0,0 +1,51 @@ +// SPDX-License-Identifier: GPL-3.0 + +pragma solidity >=0.8.2 <0.9.0; + +/** + * @title Storage + * @dev Store & retrieve value in a variable + * @custom:dev-run-script ./scripts/deploy_with_ethers.ts + */ +contract Example { + + uint256 number; + struct exampleStruct { + int val1; + int val2; + string val3; + } + + event Basic(uint indexed firstArg, string secondArg); + event Struct(uint indexed firstArg, exampleStruct secondArg); + + /** + * @dev Store value in variable + * @param num value to store + */ + function mutateStorageVal(uint256 num) public { + number = num; + } + + /** + * @dev Return value + * @return value of 'number' + */ + function retrieveStorageVal() public view returns (uint256){ + return number; + } + + function emitEvent() public { + emit Basic(123, "event"); + } + + function emitTwoEvents() public { + emit Basic(123, "event1"); + emit Basic(123, "event2"); + } + + function emitEventsDiffTypes() public { + emit Basic(123, "event1"); + emit Struct(123, exampleStruct({val1: 1, val2: 2, val3: "string"})); + } +} diff --git a/accounts/abi/bind/testdata/v2/v2_generated_testcase/example_contract.go b/accounts/abi/bind/testdata/v2/v2_generated_testcase/example_contract.go new file mode 100644 index 000000000000..0aed0ddba891 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/v2_generated_testcase/example_contract.go @@ -0,0 +1,199 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package v2_generated_testcase + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// ExampleexampleStruct is an auto generated low-level Go binding around an user-defined struct. +type ExampleexampleStruct struct { + Val1 *big.Int + Val2 *big.Int + Val3 string +} + +// V2GeneratedTestcaseMetaData contains all meta data concerning the V2GeneratedTestcase contract. +var V2GeneratedTestcaseMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"firstArg\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"secondArg\",\"type\":\"string\"}],\"name\":\"Basic\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"firstArg\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"int256\",\"name\":\"val1\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"val2\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"val3\",\"type\":\"string\"}],\"indexed\":false,\"internalType\":\"structExample.exampleStruct\",\"name\":\"secondArg\",\"type\":\"tuple\"}],\"name\":\"Struct\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"emitEvent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"emitEventsDiffTypes\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"emitTwoEvents\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"}],\"name\":\"mutateStorageVal\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"retrieveStorageVal\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", +} + +// V2GeneratedTestcaseInstance represents a deployed instance of the V2GeneratedTestcase contract. +type V2GeneratedTestcaseInstance struct { + V2GeneratedTestcase + address common.Address // consider removing this, not clear what it's used for now (and why did we need custom deploy method on previous abi?) + backend bind.ContractBackend +} + +func NewV2GeneratedTestcaseInstance(c *V2GeneratedTestcase, address common.Address, backend bind.ContractBackend) *V2GeneratedTestcaseInstance { + return &V2GeneratedTestcaseInstance{V2GeneratedTestcase: *c, address: address} +} + +func (i *V2GeneratedTestcaseInstance) Address() common.Address { + return i.address +} + +func (i *V2GeneratedTestcaseInstance) Backend() bind.ContractBackend { + return i.backend +} + +// V2GeneratedTestcase is an auto generated Go binding around an Ethereum contract. +type V2GeneratedTestcase struct { + abi abi.ABI + deployCode []byte +} + +// NewV2GeneratedTestcase creates a new instance of V2GeneratedTestcase. +func NewV2GeneratedTestcase() (*V2GeneratedTestcase, error) { + parsed, err := V2GeneratedTestcaseMetaData.GetAbi() + if err != nil { + return nil, err + } + code := common.Hex2Bytes(V2GeneratedTestcaseMetaData.Bin) + return &V2GeneratedTestcase{abi: *parsed, deployCode: code}, nil +} + +func (_V2GeneratedTestcase *V2GeneratedTestcase) DeployCode() []byte { + return _V2GeneratedTestcase.deployCode +} + +func (_V2GeneratedTestcase *V2GeneratedTestcase) PackConstructor() ([]byte, error) { + return _V2GeneratedTestcase.abi.Pack("") +} + +// EmitEvent is a free data retrieval call binding the contract method 0x7b0cb839. +// +// Solidity: function emitEvent() returns() +func (_V2GeneratedTestcase *V2GeneratedTestcase) PackEmitEvent() ([]byte, error) { + return _V2GeneratedTestcase.abi.Pack("emitEvent") +} + +// EmitEventsDiffTypes is a free data retrieval call binding the contract method 0x79da6d70. +// +// Solidity: function emitEventsDiffTypes() returns() +func (_V2GeneratedTestcase *V2GeneratedTestcase) PackEmitEventsDiffTypes() ([]byte, error) { + return _V2GeneratedTestcase.abi.Pack("emitEventsDiffTypes") +} + +// EmitTwoEvents is a free data retrieval call binding the contract method 0x7216c333. +// +// Solidity: function emitTwoEvents() returns() +func (_V2GeneratedTestcase *V2GeneratedTestcase) PackEmitTwoEvents() ([]byte, error) { + return _V2GeneratedTestcase.abi.Pack("emitTwoEvents") +} + +// MutateStorageVal is a free data retrieval call binding the contract method 0xbf54fad4. +// +// Solidity: function mutateStorageVal(uint256 num) returns() +func (_V2GeneratedTestcase *V2GeneratedTestcase) PackMutateStorageVal(num *big.Int) ([]byte, error) { + return _V2GeneratedTestcase.abi.Pack("mutateStorageVal", num) +} + +// RetrieveStorageVal is a free data retrieval call binding the contract method 0x6da1cd55. +// +// Solidity: function retrieveStorageVal() view returns(uint256) +func (_V2GeneratedTestcase *V2GeneratedTestcase) PackRetrieveStorageVal() ([]byte, error) { + return _V2GeneratedTestcase.abi.Pack("retrieveStorageVal") +} + +func (_V2GeneratedTestcase *V2GeneratedTestcase) UnpackRetrieveStorageVal(data []byte) (*big.Int, error) { + out, err := _V2GeneratedTestcase.abi.Unpack("retrieveStorageVal", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// V2GeneratedTestcaseBasic represents a Basic event raised by the V2GeneratedTestcase contract. +type V2GeneratedTestcaseBasic struct { + FirstArg *big.Int + SecondArg string + Raw *types.Log // Blockchain specific contextual infos +} + +func V2GeneratedTestcaseBasicEventID() common.Hash { + return common.HexToHash("0x114f97f563bc13d79fae32f4746248fd563650659371fef0bc8a7011fdd7bc6a") +} + +func (_V2GeneratedTestcase *V2GeneratedTestcase) UnpackBasicEvent(log *types.Log) (*V2GeneratedTestcaseBasic, error) { + event := "Basic" + if log.Topics[0] != _V2GeneratedTestcase.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(V2GeneratedTestcaseBasic) + if len(log.Data) > 0 { + if err := _V2GeneratedTestcase.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _V2GeneratedTestcase.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 +} + +// V2GeneratedTestcaseStruct represents a Struct event raised by the V2GeneratedTestcase contract. +type V2GeneratedTestcaseStruct struct { + FirstArg *big.Int + SecondArg ExampleexampleStruct + Raw *types.Log // Blockchain specific contextual infos +} + +func V2GeneratedTestcaseStructEventID() common.Hash { + return common.HexToHash("0xaa0aa64a4dab26dbe87da2dcff945b2197f80de1903db7334b8f496a94428d39") +} + +func (_V2GeneratedTestcase *V2GeneratedTestcase) UnpackStructEvent(log *types.Log) (*V2GeneratedTestcaseStruct, error) { + event := "Struct" + if log.Topics[0] != _V2GeneratedTestcase.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(V2GeneratedTestcaseStruct) + if len(log.Data) > 0 { + if err := _V2GeneratedTestcase.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _V2GeneratedTestcase.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/testdata/v2_testcase_library/contract.sol b/accounts/abi/bind/testdata/v2_testcase_library/contract.sol deleted file mode 100644 index 1636c8b00bc4..000000000000 --- a/accounts/abi/bind/testdata/v2_testcase_library/contract.sol +++ /dev/null @@ -1,45 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.26; - -library RecursiveDep { - function AddOne(uint256 val) public pure returns (uint256 ret) { - return val + 1; - } -} - -// Array function to delete element at index and re-organize the array -// so that there are no gaps between the elements. -library Array { - using RecursiveDep for uint256; - - function remove(uint256[] storage arr, uint256 index) public { - // Move the last element into the place to delete - require(arr.length > 0, "Can't remove from empty array"); - arr[index] = arr[arr.length - 1]; - arr[index] = arr[index].AddOne(); - arr.pop(); - } -} - -contract TestArray { - using Array for uint256[]; - - uint256[] public arr; - - function testArrayRemove(uint256 value) public { - for (uint256 i = 0; i < 3; i++) { - arr.push(i); - } - - arr.remove(1); - - assert(arr.length == 2); - assert(arr[0] == 0); - assert(arr[1] == 2); - } - - // a constructor with parameters - constructor(uint256 foo) { - - } -} diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 57795de2ecf3..9db4595cbec4 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -77,7 +77,7 @@ func linkLibs(deps *map[string]string, linked *map[string]common.Address) (deplo deployableDeps = make(map[string]string) for pattern, dep := range *deps { - // attempt to replace references to every single linked dep + // link references to dependent libraries that have been deployed for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(dep, -1) { matchingPattern := match[1] addr, ok := (*linked)[matchingPattern] @@ -86,7 +86,7 @@ func linkLibs(deps *map[string]string, linked *map[string]common.Address) (deplo } (*deps)[pattern] = strings.ReplaceAll(dep, "__$"+matchingPattern+"$__", addr.String()[2:]) } - // if we linked something into this dep, see if it can be deployed + // if the library code became fully linked, deploy it if !reMatchAnyPattern.MatchString((*deps)[pattern]) { deployableDeps[pattern] = (*deps)[pattern] delete(*deps, pattern) @@ -95,9 +95,37 @@ func linkLibs(deps *map[string]string, linked *map[string]common.Address) (deplo return deployableDeps } -func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.ContractBackend, constructorInputs []byte, contract *bind.MetaData, libMetas map[string]*bind.MetaData, overrides map[string]common.Address) (allDeployTxs map[common.Address]*types.Transaction, allDeployAddrs map[common.Address]struct{}, err error) { - allDeployAddrs = make(map[common.Address]struct{}) - allDeployTxs = make(map[common.Address]*types.Transaction) +type ContractDeployParams struct { + Meta *bind.MetaData + Constructor []byte +} + +type DeploymentParams struct { + Contracts []ContractDeployParams + // map of library pattern -> metadata + Libraries map[string]*bind.MetaData + // map of library pattern -> address + Overrides map[string]common.Address +} + +type DeploymentResult struct { + // map of contract type name -> deploy transaction + Txs map[string]*types.Transaction + // map of contract type name -> deployed address + Addrs map[string]common.Address +} + +// TODO: * pass single set of contracts (dont differentiate between contract/lib in parameters) +// - return map of pattern->address +// - in template, export a pattern for each contract (whether library/contract). +func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.ContractBackend, deployParams DeploymentParams) (res *DeploymentResult, err error) { + libMetas := deployParams.Libraries + overrides := deployParams.Overrides + + res = &DeploymentResult{ + Txs: make(map[string]*types.Transaction), + Addrs: make(map[string]common.Address), + } // re-express libraries as a map of pattern -> pre-link binary libs := make(map[string]string) @@ -122,25 +150,31 @@ func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.Co } deployTxs, deployAddrs, err := deployLibs(backend, auth, deployableDeps) for pattern, addr := range deployAddrs { - allDeployAddrs[addr] = struct{}{} linked[pattern] = addr - } - for addr, tx := range deployTxs { - allDeployTxs[addr] = tx + + res.Addrs[pattern] = addr + res.Txs[pattern] = deployTxs[addr] } if err != nil { - return deployTxs, allDeployAddrs, err + return res, err } } - linkedContract, err := linkContract(contract.Bin, linked) - if err != nil { - return allDeployTxs, allDeployAddrs, err + + for _, contractParams := range deployParams.Contracts { + linkedContract, err := linkContract(contractParams.Meta.Bin, linked) + if err != nil { + return res, err + } + // link and deploy the contracts + contractTx, contractAddr, err := deployContract(backend, auth, contractParams.Constructor, linkedContract) + if err != nil { + return res, err + } + res.Txs[contractParams.Meta.Pattern] = contractTx + res.Addrs[contractParams.Meta.Pattern] = contractAddr } - // link and deploy the contracts - contractTx, contractAddr, err := deployContract(backend, auth, constructorInputs, linkedContract) - allDeployAddrs[contractAddr] = struct{}{} - allDeployTxs[contractAddr] = contractTx - return allDeployTxs, allDeployAddrs, err + + return res, nil } func FilterLogs[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { @@ -262,6 +296,7 @@ func Transact(instance bind.ContractInstance, opts *bind.TransactOpts, input []b return c.RawTransact(opts, input) } +// TODO: why do we need sepaarate transact/transfer methods? func Transfer(instance bind.ContractInstance, opts *bind.TransactOpts) (*types.Transaction, error) { backend := instance.Backend() c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index 5ac61c916f15..13223ced43d2 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -3,9 +3,10 @@ package v2 import ( "context" "encoding/json" + "fmt" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" - "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2_generated_testcase" - "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2_testcase_library" + "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/nested_libraries" + "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/v2_generated_testcase" "github.com/ethereum/go-ethereum/eth/ethconfig" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/node" @@ -165,30 +166,93 @@ func TestDeployment(t *testing.T) { // TODO: allow for the flexibility of deploying only libraries. // also, i kind of hate this conversion. But the API of LinkAndDeployContractWithOverrides feels cleaner this way... idk. libMetas := make(map[string]*bind.MetaData) - for pattern, metadata := range v2_testcase_library.TestArrayLibraryDeps { + for pattern, metadata := range nested_libraries.C1LibraryDeps { libMetas[pattern] = metadata } - ctrct, err := v2_testcase_library.NewTestArray() + ctrct, err := nested_libraries.NewC1() if err != nil { panic(err) } - constructorInput, err := ctrct.PackConstructor(big.NewInt(42), false) + + constructorInput, err := ctrct.PackConstructor(big.NewInt(42), big.NewInt(1)) if err != nil { t.Fatalf("fack %v", err) } // TODO: test case with arguments-containing constructor - txs, _, err := LinkAndDeployContractWithOverrides(&opts, bindBackend, constructorInput, v2_testcase_library.TestArrayMetaData, v2_testcase_library.TestArrayLibraryDeps, nil) + deploymentParams := DeploymentParams{ + Contracts: []ContractDeployParams{ + { + Meta: nested_libraries.C1MetaData, + Constructor: constructorInput, + }, + }, + Libraries: nested_libraries.C1LibraryDeps, + Overrides: nil, + } + res, err := LinkAndDeployContractWithOverrides(&opts, bindBackend, deploymentParams) if err != nil { t.Fatalf("err: %+v\n", err) } bindBackend.Commit() - for _, tx := range txs { + + // assert that only 4 txs were produced. + /* + if len(deployedLibs)+1 != 4 { + panic(fmt.Sprintf("whoops %d\n", len(deployedLibs))) + } + */ + for _, tx := range res.Txs { _, err = bind.WaitDeployed(context.Background(), &bindBackend, tx) if err != nil { - t.Fatalf("error deploying bound contract: %+v", err) + t.Fatalf("error deploying library: %+v", err) } } + c, err := nested_libraries.NewC1() + if err != nil { + t.Fatalf("err is %v", err) + } + doInput, err := c.PackDo(big.NewInt(1)) + if err != nil { + t.Fatalf("pack function input err: %v\n", doInput) + } + + cABI, err := nested_libraries.C1MetaData.GetAbi() + if err != nil { + t.Fatalf("error getting abi object: %v", err) + } + contractAddr := res.Addrs[nested_libraries.C1MetaData.Pattern] + boundC := bind.NewBoundContract(contractAddr, *cABI, &bindBackend, &bindBackend, &bindBackend) + callOpts := &bind.CallOpts{ + From: common.Address{}, + Context: context.Background(), + } + c1Code, err := bindBackend.PendingCodeAt(context.Background(), contractAddr) + if err != nil { + t.Fatalf("error getting pending code at %x: %v", contractAddr, err) + } + fmt.Printf("contract code:\n%x\n", c1Code) + fmt.Printf("contract input:\n%x\n", doInput) + callRes, err := boundC.CallRaw(callOpts, doInput) + if err != nil { + t.Fatalf("err calling contract: %v", err) + } + unpacked, err := c.UnpackDo(callRes) + if err != nil { + t.Fatalf("err unpacking result: %v", err) + } + + // TODO: test transact + fmt.Println(unpacked.String()) +} + +func TestDeploymentWithOverrides(t *testing.T) { + // test that libs sharing deps, if overrides not specified we will deploy multiple versions of the dependent deps + // test that libs sharing deps, if overrides specified... overrides work. +} + +func TestEvents(t *testing.T) { + // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) } /* test-cases that should be extracted from v1 tests From 9f5de95d91cbbd9e18e2dbff84cd1c5a4a13de68 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 26 Nov 2024 17:18:20 +0700 Subject: [PATCH 026/104] more docs. fix nested library contract. fix associated test case. --- .../abi/bind/testdata/v2/events/contract.sol | 6 ++ .../testdata/v2/nested_libraries/bindings.go | 71 ++----------- .../v2/nested_libraries/combined-abi.json | 2 +- .../testdata/v2/nested_libraries/contract.sol | 14 +-- accounts/abi/bind/v2/lib.go | 84 ++++++++++----- accounts/abi/bind/v2/v2_test.go | 100 +++++++++++------- 6 files changed, 137 insertions(+), 140 deletions(-) diff --git a/accounts/abi/bind/testdata/v2/events/contract.sol b/accounts/abi/bind/testdata/v2/events/contract.sol index e69de29bb2d1..1e26c0e04dc5 100644 --- a/accounts/abi/bind/testdata/v2/events/contract.sol +++ b/accounts/abi/bind/testdata/v2/events/contract.sol @@ -0,0 +1,6 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.26; + +contract C { + +} \ No newline at end of file diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go index 6f0b525acc62..6e91cfc690b5 100644 --- a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go +++ b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go @@ -26,8 +26,9 @@ var ( // TODO: turn this into a list, now that the pattern is embedded in each MetaData object var C1LibraryDeps = map[string]*bind.MetaData{ "ffc1393672b8ed81d0c8093ffcb0e7fbe8": L1MetaData, + "2ce896a6dd38932d354f317286f90bc675": L2MetaData, "d03b97f5e1a564374023a72ac7d1806773": L3MetaData, - "d600bc30c225801bf5b413866ae334453d": L5MetaData, + "5f33a1fab8ea7d932b4bc8c5e7dcd90bc2": L4MetaData, } // TODO: convert this type to value type after everything works. @@ -35,7 +36,7 @@ var C1LibraryDeps = map[string]*bind.MetaData{ 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__$d600bc30c225801bf5b413866ae334453d$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea264697066735822122068ad2fa18c18d049dd707b5914a0aa9abd5c5f624e2f4886a07f9440f05fb91864736f6c634300081a0033", + Bin: "0x6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$5f33a1fab8ea7d932b4bc8c5e7dcd90bc2$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea26469706673582212209d07b322f13a9a05a62ccf2e925d28587ba6709742c985a55dad244e25b5cdd564736f6c634300081a0033", } // C1 is an auto generated Go binding around an Ethereum contract. @@ -91,7 +92,7 @@ var C2LibraryDeps = map[string]*bind.MetaData{ 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$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea2646970667358221220607a5019c269337b096c81ff7e87c99fc5415a2b6f40cc072d5e88396706090e64736f6c634300081a0033", + Bin: "0x6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$6070639404c39b5667691bb1f9177e1eac$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea26469706673582212203f624c062b23db1417622d9d64f8bb382c9e4613e15338001e190945d6e7f2c864736f6c634300081a0033", } // C2 is an auto generated Go binding around an Ethereum contract. @@ -143,7 +144,7 @@ var L1LibraryDeps = map[string]*bind.MetaData{} 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: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea264697066735822122078914f7e9af117523b8392de05343b4af49014337eaffc86ff537b0ff54fd1ed64736f6c634300081a0033", + Bin: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea26469706673582212204b676b17ea48d7d33ea6c1612dfbcd963e273670638c919797e980a6e42d6e5a64736f6c634300081a0033", } // L1 is an auto generated Go binding around an Ethereum contract. @@ -195,7 +196,7 @@ var L2LibraryDeps = map[string]*bind.MetaData{} 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: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea26469706673582212205248bdbd4b939a2e899770a55b8b960ed9b95b22e949c50b4e0f94e27f1a764164736f6c634300081a0033", + Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220c6f7a5f2e4ef9458b4081d7a828ede24efb394c00dad7182493a56186a60b62f64736f6c634300081a0033", } // L2 is an auto generated Go binding around an Ethereum contract. @@ -247,7 +248,7 @@ var L2bLibraryDeps = map[string]*bind.MetaData{} 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$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220f2bec4e215b51a06ae5161d6a1fa3130877fb447fe26cf7cc5d1791ed58ec8ba64736f6c634300081a0033", + Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220a36a724bd2bb81778a0380d6d4b41d69d81d8b6d3d2a672e14cfa22a6e98253e64736f6c634300081a0033", } // L2b is an auto generated Go binding around an Ethereum contract. @@ -299,7 +300,7 @@ var L3LibraryDeps = map[string]*bind.MetaData{} 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: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea26469706673582212201a3e05a0b6b9da6c9f39bee5a339d955347a2c736f2a1e6350c33c2c3ba9764864736f6c634300081a0033", + Bin: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea264697066735822122061067055c16517eded3faafba31b658871b20986f922183b577ffe64c8290c9764736f6c634300081a0033", } // L3 is an auto generated Go binding around an Ethereum contract. @@ -351,7 +352,7 @@ var L4LibraryDeps = map[string]*bind.MetaData{} 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: "0x61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea2646970667358221220776962c71be9e15d17f5a247c2429fddd2e4b2a533e34d9c5e2e324ee6bd76af64736f6c634300081a0033", + Bin: "0x6102d161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d91906101a9565b610068565b60405161005f91906101e3565b60405180910390f35b5f600173__$d03b97f5e1a564374023a72ac7d1806773$__632ad11272846040518263ffffffff1660e01b81526004016100a291906101e3565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610210565b73__$2ce896a6dd38932d354f317286f90bc675$__632ad11272856040518263ffffffff1660e01b815260040161011891906101e3565b602060405180830381865af4158015610133573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101579190610210565b6101619190610268565b61016b9190610268565b9050919050565b5f80fd5b5f819050919050565b61018881610176565b8114610192575f80fd5b50565b5f813590506101a38161017f565b92915050565b5f602082840312156101be576101bd610172565b5b5f6101cb84828501610195565b91505092915050565b6101dd81610176565b82525050565b5f6020820190506101f65f8301846101d4565b92915050565b5f8151905061020a8161017f565b92915050565b5f6020828403121561022557610224610172565b5b5f610232848285016101fc565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61027282610176565b915061027d83610176565b92508282019050808211156102955761029461023b565b5b9291505056fea2646970667358221220e49c024cf6cef8343d5af652ab39f89e7edf1930ba53e986741ac84a03a709ff64736f6c634300081a0033", } // L4 is an auto generated Go binding around an Ethereum contract. @@ -403,7 +404,7 @@ var L4bLibraryDeps = map[string]*bind.MetaData{} 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$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220efbb5a71ca406bdf7337c785a57fcc2211efa82182e9330541e41f7f3cbbfd6864736f6c634300081a0033", + Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$fd1474cf57f7ed48491e8bfdfd0d172adf$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220819bc379f2acc661e3dba3915bee83164e666ab39a92d0bcbf56b2438c35f2e164736f6c634300081a0033", } // L4b is an auto generated Go binding around an Ethereum contract. @@ -447,55 +448,3 @@ func (_L4b *L4b) UnpackDo(data []byte) (*big.Int, error) { } -// TODO: turn this into a list, now that the pattern is embedded in each MetaData object -var L5LibraryDeps = map[string]*bind.MetaData{} - -// TODO: convert this type to value type after everything works. -// L5MetaData contains all meta data concerning the L5 contract. -var L5MetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"Do\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", - Pattern: "d600bc30c225801bf5b413866ae334453d", - Bin: "0x61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$d03b97f5e1a564374023a72ac7d1806773$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea26469706673582212209c255a72b1a53a20d1e2234d9692aba8973d3aa7271f120c00fe0fde8226532f64736f6c634300081a0033", -} - -// L5 is an auto generated Go binding around an Ethereum contract. -type L5 struct { - abi abi.ABI -} - -// NewL5 creates a new instance of L5. -func NewL5() (*L5, error) { - parsed, err := L5MetaData.GetAbi() - if err != nil { - return nil, err - } - return &L5{abi: *parsed}, nil -} - -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs -func (_L5 *L5) PackConstructor() ([]byte, error) { - return _L5.abi.Pack("") -} - -// Do is a free data retrieval call binding the contract method 0x2ad11272. -// -// Solidity: function Do(uint256 val) pure returns(uint256) -func (_L5 *L5) PackDo(val *big.Int) ([]byte, error) { - return _L5.abi.Pack("Do", val) -} - -func (_L5 *L5) UnpackDo(data []byte) (*big.Int, error) { - out, err := _L5.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/testdata/v2/nested_libraries/combined-abi.json b/accounts/abi/bind/testdata/v2/nested_libraries/combined-abi.json index 5a67ee85fa8e..a435c0d6e705 100644 --- a/accounts/abi/bind/testdata/v2/nested_libraries/combined-abi.json +++ b/accounts/abi/bind/testdata/v2/nested_libraries/combined-abi.json @@ -1 +1 @@ -{"contracts":{"contract.sol:C1":{"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"}],"bin":"6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$d600bc30c225801bf5b413866ae334453d$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea264697066735822122068ad2fa18c18d049dd707b5914a0aa9abd5c5f624e2f4886a07f9440f05fb91864736f6c634300081a0033"},"contract.sol:C2":{"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"}],"bin":"6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$6070639404c39b5667691bb1f9177e1eac$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea2646970667358221220607a5019c269337b096c81ff7e87c99fc5415a2b6f40cc072d5e88396706090e64736f6c634300081a0033"},"contract.sol:L1":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea264697066735822122078914f7e9af117523b8392de05343b4af49014337eaffc86ff537b0ff54fd1ed64736f6c634300081a0033"},"contract.sol:L2":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea26469706673582212205248bdbd4b939a2e899770a55b8b960ed9b95b22e949c50b4e0f94e27f1a764164736f6c634300081a0033"},"contract.sol:L2b":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220f2bec4e215b51a06ae5161d6a1fa3130877fb447fe26cf7cc5d1791ed58ec8ba64736f6c634300081a0033"},"contract.sol:L3":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea26469706673582212201a3e05a0b6b9da6c9f39bee5a339d955347a2c736f2a1e6350c33c2c3ba9764864736f6c634300081a0033"},"contract.sol:L4":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea2646970667358221220776962c71be9e15d17f5a247c2429fddd2e4b2a533e34d9c5e2e324ee6bd76af64736f6c634300081a0033"},"contract.sol:L4b":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$fd1474cf57f7ed48491e8bfdfd0d172adf$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220efbb5a71ca406bdf7337c785a57fcc2211efa82182e9330541e41f7f3cbbfd6864736f6c634300081a0033"},"contract.sol:L5":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$d03b97f5e1a564374023a72ac7d1806773$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea26469706673582212209c255a72b1a53a20d1e2234d9692aba8973d3aa7271f120c00fe0fde8226532f64736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} +{"contracts":{"contract.sol:C1":{"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"}],"bin":"6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$5f33a1fab8ea7d932b4bc8c5e7dcd90bc2$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea26469706673582212209d07b322f13a9a05a62ccf2e925d28587ba6709742c985a55dad244e25b5cdd564736f6c634300081a0033"},"contract.sol:C2":{"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"}],"bin":"6080604052348015600e575f80fd5b506040516103983803806103988339818101604052810190602e91906066565b5050609d565b5f80fd5b5f819050919050565b6048816038565b81146051575f80fd5b50565b5f815190506060816041565b92915050565b5f806040838503121560795760786034565b5b5f6084858286016054565b92505060206093858286016054565b9150509250929050565b6102ee806100aa5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c80632ad112721461002d575b5f80fd5b6100476004803603810190610042919061019e565b61005d565b60405161005491906101d8565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad112725f6040518263ffffffff1660e01b81526004016100979190610200565b602060405180830381865af41580156100b2573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d6919061022d565b73__$6070639404c39b5667691bb1f9177e1eac$__632ad11272856040518263ffffffff1660e01b815260040161010d9190610200565b602060405180830381865af4158015610128573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014c919061022d565b6101569190610285565b6101609190610285565b9050919050565b5f80fd5b5f819050919050565b61017d8161016b565b8114610187575f80fd5b50565b5f8135905061019881610174565b92915050565b5f602082840312156101b3576101b2610167565b5b5f6101c08482850161018a565b91505092915050565b6101d28161016b565b82525050565b5f6020820190506101eb5f8301846101c9565b92915050565b6101fa8161016b565b82525050565b5f6020820190506102135f8301846101f1565b92915050565b5f8151905061022781610174565b92915050565b5f6020828403121561024257610241610167565b5b5f61024f84828501610219565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61028f8261016b565b915061029a8361016b565b92508282019050808211156102b2576102b1610258565b5b9291505056fea26469706673582212203f624c062b23db1417622d9d64f8bb382c9e4613e15338001e190945d6e7f2c864736f6c634300081a0033"},"contract.sol:L1":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea26469706673582212204b676b17ea48d7d33ea6c1612dfbcd963e273670638c919797e980a6e42d6e5a64736f6c634300081a0033"},"contract.sol:L2":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220c6f7a5f2e4ef9458b4081d7a828ede24efb394c00dad7182493a56186a60b62f64736f6c634300081a0033"},"contract.sol:L2b":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$ffc1393672b8ed81d0c8093ffcb0e7fbe8$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220a36a724bd2bb81778a0380d6d4b41d69d81d8b6d3d2a672e14cfa22a6e98253e64736f6c634300081a0033"},"contract.sol:L3":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61011c61004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106032575f3560e01c80632ad11272146036575b5f80fd5b604c600480360381019060489190609c565b6060565b6040516057919060cf565b60405180910390f35b5f60019050919050565b5f80fd5b5f819050919050565b607e81606e565b81146087575f80fd5b50565b5f813590506096816077565b92915050565b5f6020828403121560ae5760ad606a565b5b5f60b984828501608a565b91505092915050565b60c981606e565b82525050565b5f60208201905060e05f83018460c2565b9291505056fea264697066735822122061067055c16517eded3faafba31b658871b20986f922183b577ffe64c8290c9764736f6c634300081a0033"},"contract.sol:L4":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"6102d161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d91906101a9565b610068565b60405161005f91906101e3565b60405180910390f35b5f600173__$d03b97f5e1a564374023a72ac7d1806773$__632ad11272846040518263ffffffff1660e01b81526004016100a291906101e3565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610210565b73__$2ce896a6dd38932d354f317286f90bc675$__632ad11272856040518263ffffffff1660e01b815260040161011891906101e3565b602060405180830381865af4158015610133573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101579190610210565b6101619190610268565b61016b9190610268565b9050919050565b5f80fd5b5f819050919050565b61018881610176565b8114610192575f80fd5b50565b5f813590506101a38161017f565b92915050565b5f602082840312156101be576101bd610172565b5b5f6101cb84828501610195565b91505092915050565b6101dd81610176565b82525050565b5f6020820190506101f65f8301846101d4565b92915050565b5f8151905061020a8161017f565b92915050565b5f6020828403121561022557610224610172565b5b5f610232848285016101fc565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61027282610176565b915061027d83610176565b92508282019050808211156102955761029461023b565b5b9291505056fea2646970667358221220e49c024cf6cef8343d5af652ab39f89e7edf1930ba53e986741ac84a03a709ff64736f6c634300081a0033"},"contract.sol:L4b":{"abi":[{"inputs":[{"internalType":"uint256","name":"val","type":"uint256"}],"name":"Do","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"bin":"61025161004d600b8282823980515f1a6073146041577f4e487b71000000000000000000000000000000000000000000000000000000005f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632ad1127214610038575b5f80fd5b610052600480360381019061004d9190610129565b610068565b60405161005f9190610163565b60405180910390f35b5f600173__$fd1474cf57f7ed48491e8bfdfd0d172adf$__632ad11272846040518263ffffffff1660e01b81526004016100a29190610163565b602060405180830381865af41580156100bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100e19190610190565b6100eb91906101e8565b9050919050565b5f80fd5b5f819050919050565b610108816100f6565b8114610112575f80fd5b50565b5f81359050610123816100ff565b92915050565b5f6020828403121561013e5761013d6100f2565b5b5f61014b84828501610115565b91505092915050565b61015d816100f6565b82525050565b5f6020820190506101765f830184610154565b92915050565b5f8151905061018a816100ff565b92915050565b5f602082840312156101a5576101a46100f2565b5b5f6101b28482850161017c565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101f2826100f6565b91506101fd836100f6565b9250828201905080821115610215576102146101bb565b5b9291505056fea2646970667358221220819bc379f2acc661e3dba3915bee83164e666ab39a92d0bcbf56b2438c35f2e164736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/contract.sol b/accounts/abi/bind/testdata/v2/nested_libraries/contract.sol index b05d06f9f642..1794e72ac9da 100644 --- a/accounts/abi/bind/testdata/v2/nested_libraries/contract.sol +++ b/accounts/abi/bind/testdata/v2/nested_libraries/contract.sol @@ -18,31 +18,25 @@ library L1 { library L2 { function Do(uint256 val) public pure returns (uint256) { - return uint256(1); + return L1.Do(val) + uint256(1); } } library L3 { - function Do(uint256 val) public pure returns (uint256) { - return L1.Do(uint256(val)) + uint256(1); - } -} - -library L4 { function Do(uint256 val) public pure returns (uint256) { return uint256(1); } } -library L5 { +library L4 { function Do(uint256 val) public pure returns (uint256) { - return L3.Do(uint256(val)) + uint256(1); + return L2.Do(uint256(val)) + L3.Do(uint256(val)) + uint256(1); } } contract C1 { function Do(uint256 val) public pure returns (uint256 res) { - return L5.Do(uint256(val)) + L1.Do(uint256(0)) + uint256(1); + return L4.Do(uint256(val)) + L1.Do(uint256(0)) + uint256(1); } constructor(uint256 v1, uint256 v2) { diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 9db4595cbec4..cbc5278cafb1 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -18,6 +18,8 @@ type ContractInstance struct { Backend bind.ContractBackend } +// deployContract deploys a hex-encoded contract with the given constructor +// input. It returns the deployment transaction, address on success. func deployContract(backend bind.ContractBackend, auth *bind.TransactOpts, constructor []byte, contract string) (deploymentTx *types.Transaction, deploymentAddr common.Address, err error) { contractBinBytes, err := hex.DecodeString(contract[2:]) if err != nil { @@ -30,6 +32,9 @@ func deployContract(backend bind.ContractBackend, auth *bind.TransactOpts, const return tx, addr, nil } +// deployLibs iterates the set contracts (map of pattern to hex-encoded +// contract deploy code). each value in contracts is deployed, and the +// resulting addresses/deployment-txs are returned on success. func deployLibs(backend bind.ContractBackend, auth *bind.TransactOpts, contracts map[string]string) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[string]common.Address, err error) { deploymentTxs = make(map[common.Address]*types.Transaction) deployAddrs = make(map[string]common.Address) @@ -51,6 +56,10 @@ func deployLibs(backend bind.ContractBackend, auth *bind.TransactOpts, contracts return deploymentTxs, deployAddrs, nil } +// linkContract takes an unlinked contract deploy code (contract) a map of +// linked-and-deployed library dependencies, replaces references to library +// deps in the contract code, and returns the contract deployment bytecode on +// success. func linkContract(contract string, linkedLibs map[string]common.Address) (deployableContract string, err error) { reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") if err != nil { @@ -65,7 +74,13 @@ func linkContract(contract string, linkedLibs map[string]common.Address) (deploy return contract, nil } -func linkLibs(deps *map[string]string, linked *map[string]common.Address) (deployableDeps map[string]string) { +// linkLibs iterates the set of dependencies that have yet to be +// linked/deployed (pending), replacing references to library dependencies +// if those dependencies are fully linked/deployed (in 'linked'). +// +// contracts that have become fully linked in the current invocation are +// returned in the resulting map. +func linkLibs(pending *map[string]string, linked map[string]common.Address) (deployableDeps map[string]string) { reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") if err != nil { panic(err) @@ -76,49 +91,61 @@ func linkLibs(deps *map[string]string, linked *map[string]common.Address) (deplo } deployableDeps = make(map[string]string) - for pattern, dep := range *deps { + for pattern, dep := range *pending { // link references to dependent libraries that have been deployed for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(dep, -1) { matchingPattern := match[1] - addr, ok := (*linked)[matchingPattern] + addr, ok := linked[matchingPattern] if !ok { continue } - (*deps)[pattern] = strings.ReplaceAll(dep, "__$"+matchingPattern+"$__", addr.String()[2:]) + (*pending)[pattern] = strings.ReplaceAll(dep, "__$"+matchingPattern+"$__", addr.String()[2:]) } - // if the library code became fully linked, deploy it - if !reMatchAnyPattern.MatchString((*deps)[pattern]) { - deployableDeps[pattern] = (*deps)[pattern] - delete(*deps, pattern) + // if the library code became fully linked, move it from pending->linked. + if !reMatchAnyPattern.MatchString((*pending)[pattern]) { + deployableDeps[pattern] = (*pending)[pattern] + delete(*pending, pattern) } } return deployableDeps } +// ContractDeployParams represents state needed to deploy a contract: +// the metdata and constructor input (which can be nil if no input is specified). type ContractDeployParams struct { - Meta *bind.MetaData - Constructor []byte + Meta *bind.MetaData + // Input is the ABI-encoded constructor input for the contract deployment. + Input []byte } +// DeploymentParams represents parameters needed to deploy a +// set of contracts, their dependency libraries. It takes an optional override +// list to specify libraries that have already been deployed on-chain. type DeploymentParams struct { + // Contracts is the set of contract deployment parameters for contracts + // that are about to be deployed. Contracts []ContractDeployParams - // map of library pattern -> metadata + // Libraries is a map of pattern to metadata for library contracts that + // are to be deployed. Libraries map[string]*bind.MetaData - // map of library pattern -> address + // Overrides is an optional map of pattern to deployment address. + // Contracts/libraries that refer to dependencies in the override + // set are linked to the provided address (an already-deployed contract). Overrides map[string]common.Address } +// DeploymentResult contains the relevant information from the deployment of +// multiple contracts: their deployment txs and addresses. type DeploymentResult struct { - // map of contract type name -> deploy transaction + // map of contract library pattern -> deploy transaction Txs map[string]*types.Transaction - // map of contract type name -> deployed address + // map of contract library pattern -> deployed address Addrs map[string]common.Address } -// TODO: * pass single set of contracts (dont differentiate between contract/lib in parameters) -// - return map of pattern->address -// - in template, export a pattern for each contract (whether library/contract). -func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.ContractBackend, deployParams DeploymentParams) (res *DeploymentResult, err error) { +// LinkAndDeploy deploys a specified set of contracts and their dependent +// libraries. +func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deployParams DeploymentParams) (res *DeploymentResult, err error) { libMetas := deployParams.Libraries overrides := deployParams.Overrides @@ -128,30 +155,29 @@ func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.Co } // re-express libraries as a map of pattern -> pre-link binary - libs := make(map[string]string) + pending := make(map[string]string) for pattern, meta := range libMetas { - libs[pattern] = meta.Bin + pending[pattern] = meta.Bin } // initialize the set of already-deployed contracts with given override addresses - linked := make(map[string]common.Address) + deployed := make(map[string]common.Address) for pattern, deployAddr := range overrides { - linked[pattern] = deployAddr - if _, ok := libs[pattern]; ok { - delete(libs, pattern) + deployed[pattern] = deployAddr + if _, ok := pending[pattern]; ok { + delete(pending, pattern) } } // link and deploy dynamic libraries for { - deployableDeps := linkLibs(&libs, &linked) + deployableDeps := linkLibs(&pending, deployed) if len(deployableDeps) == 0 { break } deployTxs, deployAddrs, err := deployLibs(backend, auth, deployableDeps) for pattern, addr := range deployAddrs { - linked[pattern] = addr - + deployed[pattern] = addr res.Addrs[pattern] = addr res.Txs[pattern] = deployTxs[addr] } @@ -161,12 +187,12 @@ func LinkAndDeployContractWithOverrides(auth *bind.TransactOpts, backend bind.Co } for _, contractParams := range deployParams.Contracts { - linkedContract, err := linkContract(contractParams.Meta.Bin, linked) + linkedContract, err := linkContract(contractParams.Meta.Bin, deployed) if err != nil { return res, err } // link and deploy the contracts - contractTx, contractAddr, err := deployContract(backend, auth, contractParams.Constructor, linkedContract) + contractTx, contractAddr, err := deployContract(backend, auth, contractParams.Input, linkedContract) if err != nil { return res, err } diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index 13223ced43d2..0164219443da 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -3,23 +3,19 @@ package v2 import ( "context" "encoding/json" - "fmt" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/nested_libraries" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/v2_generated_testcase" - "github.com/ethereum/go-ethereum/eth/ethconfig" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/node" - "io" - "os" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/eth/ethconfig" "github.com/ethereum/go-ethereum/ethclient/simulated" + "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/params" + "io" "math/big" "strings" "testing" @@ -161,14 +157,7 @@ func TestDeployment(t *testing.T) { Client: backend.Client(), } - log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stdout, log.LevelDebug, true))) - - // TODO: allow for the flexibility of deploying only libraries. - // also, i kind of hate this conversion. But the API of LinkAndDeployContractWithOverrides feels cleaner this way... idk. - libMetas := make(map[string]*bind.MetaData) - for pattern, metadata := range nested_libraries.C1LibraryDeps { - libMetas[pattern] = metadata - } + //log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stdout, log.LevelDebug, true))) ctrct, err := nested_libraries.NewC1() if err != nil { @@ -183,8 +172,8 @@ func TestDeployment(t *testing.T) { deploymentParams := DeploymentParams{ Contracts: []ContractDeployParams{ { - Meta: nested_libraries.C1MetaData, - Constructor: constructorInput, + Meta: nested_libraries.C1MetaData, + Input: constructorInput, }, }, Libraries: nested_libraries.C1LibraryDeps, @@ -196,12 +185,9 @@ func TestDeployment(t *testing.T) { } bindBackend.Commit() - // assert that only 4 txs were produced. - /* - if len(deployedLibs)+1 != 4 { - panic(fmt.Sprintf("whoops %d\n", len(deployedLibs))) - } - */ + if len(res.Addrs) != 5 { + t.Fatalf("deployment should have generated 5 addresses. got %d", len(res.Addrs)) + } for _, tx := range res.Txs { _, err = bind.WaitDeployed(context.Background(), &bindBackend, tx) if err != nil { @@ -227,30 +213,66 @@ func TestDeployment(t *testing.T) { From: common.Address{}, Context: context.Background(), } - c1Code, err := bindBackend.PendingCodeAt(context.Background(), contractAddr) - if err != nil { - t.Fatalf("error getting pending code at %x: %v", contractAddr, err) - } - fmt.Printf("contract code:\n%x\n", c1Code) - fmt.Printf("contract input:\n%x\n", doInput) callRes, err := boundC.CallRaw(callOpts, doInput) if err != nil { t.Fatalf("err calling contract: %v", err) } - unpacked, err := c.UnpackDo(callRes) + internalCallCount, err := c.UnpackDo(callRes) if err != nil { t.Fatalf("err unpacking result: %v", err) } - - // TODO: test transact - fmt.Println(unpacked.String()) + if internalCallCount.Uint64() != 6 { + t.Fatalf("expected internal call count of 6. got %d.", internalCallCount.Uint64()) + } } -func TestDeploymentWithOverrides(t *testing.T) { - // test that libs sharing deps, if overrides not specified we will deploy multiple versions of the dependent deps - // test that libs sharing deps, if overrides specified... overrides work. -} +/* + func TestDeploymentWithOverrides(t *testing.T) { + testAddr := crypto.PubkeyToAddress(testKey.PublicKey) + backend := simulated.NewBackend( + types.GenesisAlloc{ + testAddr: {Balance: big.NewInt(10000000000000000)}, + }, + func(nodeConf *node.Config, ethConf *ethconfig.Config) { + ethConf.Genesis.Difficulty = big.NewInt(0) + }, + ) + defer backend.Close() + _, err := JSON(strings.NewReader(v2_generated_testcase.V2GeneratedTestcaseMetaData.ABI)) + if err != nil { + panic(err) + } + + signer := types.LatestSigner(params.AllDevChainProtocolChanges) + opts := bind.TransactOpts{ + From: testAddr, + Nonce: nil, + Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { + signature, err := crypto.Sign(signer.Hash(tx).Bytes(), testKey) + if err != nil { + t.Fatal(err) + } + signedTx, err := tx.WithSignature(signer, signature) + if err != nil { + t.Fatal(err) + } + return signedTx, nil + }, + Context: context.Background(), + } + // we should just be able to use the backend directly, instead of using + // this deprecated interface. However, the simulated backend no longer + // implements backends.SimulatedBackend... + bindBackend := backends.SimulatedBackend{ + Backend: backend, + Client: backend.Client(), + } + // more deployment test case ideas: + // 1) deploy libraries, then deploy contract first with libraries as overrides + // 2) deploy contract without library dependencies. + } +*/ func TestEvents(t *testing.T) { // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) } From 5c57149c985d1a22908d58cc23b2604c177de688 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 26 Nov 2024 17:22:28 +0700 Subject: [PATCH 027/104] fix v2 test --- accounts/abi/bind/v2/v2_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/accounts/abi/bind/v2/v2_test.go b/accounts/abi/bind/v2/v2_test.go index 0164219443da..4f0fb90fb693 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/v2_test.go @@ -179,7 +179,7 @@ func TestDeployment(t *testing.T) { Libraries: nested_libraries.C1LibraryDeps, Overrides: nil, } - res, err := LinkAndDeployContractWithOverrides(&opts, bindBackend, deploymentParams) + res, err := LinkAndDeploy(&opts, bindBackend, deploymentParams) if err != nil { t.Fatalf("err: %+v\n", err) } From bc96b7e052f445e29ed6cdf372f50c873b9b8e68 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 26 Nov 2024 17:32:46 +0700 Subject: [PATCH 028/104] some more docs --- accounts/abi/bind/v2/lib.go | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index cbc5278cafb1..b06bc17e1511 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -203,6 +203,7 @@ func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deploy return res, nil } +// TODO: adding docs soon (jwasinger) func FilterLogs[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { backend := instance.Backend c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) @@ -213,6 +214,7 @@ func FilterLogs[T any](instance *ContractInstance, opts *bind.FilterOpts, eventI return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil } +// TODO: adding docs soon (jwasinger) func WatchLogs[T any](instance *ContractInstance, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { backend := instance.Backend c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) @@ -313,6 +315,8 @@ func (it *EventIterator[T]) Close() error { return nil } +// Transact creates and submits a transaction to the bound contract instance +// using the provided abi-encoded input (or nil). func Transact(instance bind.ContractInstance, opts *bind.TransactOpts, input []byte) (*types.Transaction, error) { var ( addr = instance.Address() @@ -322,14 +326,9 @@ func Transact(instance bind.ContractInstance, opts *bind.TransactOpts, input []b return c.RawTransact(opts, input) } -// TODO: why do we need sepaarate transact/transfer methods? -func Transfer(instance bind.ContractInstance, opts *bind.TransactOpts) (*types.Transaction, error) { - backend := instance.Backend() - c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) - return c.Transfer(opts) -} - -func CallRaw(instance bind.ContractInstance, opts *bind.CallOpts, input []byte) ([]byte, error) { +// Call performs an eth_call on the given bound contract instance, using the +// provided abi-encoded input (or nil). +func Call(instance bind.ContractInstance, opts *bind.CallOpts, input []byte) ([]byte, error) { backend := instance.Backend() c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) return c.CallRaw(opts, input) From 8a8d7dfabf8940901eee12b299cfcf1dc0d3f943 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 26 Nov 2024 17:41:18 +0700 Subject: [PATCH 029/104] simplify generated code for list of library dependencies --- accounts/abi/bind/template2.go | 5 +-- .../testdata/v2/nested_libraries/bindings.go | 38 ++++++++----------- accounts/abi/bind/v2/lib.go | 6 +-- 3 files changed, 20 insertions(+), 29 deletions(-) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/template2.go index 42ea61e88a2d..0e97dd39c3a1 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/template2.go @@ -38,10 +38,9 @@ var ( {{end}} {{range $contract := .Contracts}} - // TODO: turn this into a list, now that the pattern is embedded in each MetaData object - var {{$contract.Type}}LibraryDeps = map[string]*bind.MetaData{ + var {{$contract.Type}}LibraryDeps = []*bind.MetaData{ {{range $name, $pattern := .AllLibraries -}} - "{{$pattern}}": {{$name}}MetaData, + {{$name}}MetaData, {{ end}} } diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go index 6e91cfc690b5..6ab458a76455 100644 --- a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go +++ b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go @@ -23,12 +23,11 @@ var ( _ = abi.ConvertType ) -// TODO: turn this into a list, now that the pattern is embedded in each MetaData object -var C1LibraryDeps = map[string]*bind.MetaData{ - "ffc1393672b8ed81d0c8093ffcb0e7fbe8": L1MetaData, - "2ce896a6dd38932d354f317286f90bc675": L2MetaData, - "d03b97f5e1a564374023a72ac7d1806773": L3MetaData, - "5f33a1fab8ea7d932b4bc8c5e7dcd90bc2": L4MetaData, +var C1LibraryDeps = []*bind.MetaData{ + L1MetaData, + L2MetaData, + L3MetaData, + L4MetaData, } // TODO: convert this type to value type after everything works. @@ -80,11 +79,10 @@ func (_C1 *C1) UnpackDo(data []byte) (*big.Int, error) { } -// TODO: turn this into a list, now that the pattern is embedded in each MetaData object -var C2LibraryDeps = map[string]*bind.MetaData{ - "ffc1393672b8ed81d0c8093ffcb0e7fbe8": L1MetaData, - "fd1474cf57f7ed48491e8bfdfd0d172adf": L2bMetaData, - "6070639404c39b5667691bb1f9177e1eac": L4bMetaData, +var C2LibraryDeps = []*bind.MetaData{ + L1MetaData, + L2bMetaData, + L4bMetaData, } // TODO: convert this type to value type after everything works. @@ -136,8 +134,7 @@ func (_C2 *C2) UnpackDo(data []byte) (*big.Int, error) { } -// TODO: turn this into a list, now that the pattern is embedded in each MetaData object -var L1LibraryDeps = map[string]*bind.MetaData{} +var L1LibraryDeps = []*bind.MetaData{} // TODO: convert this type to value type after everything works. // L1MetaData contains all meta data concerning the L1 contract. @@ -188,8 +185,7 @@ func (_L1 *L1) UnpackDo(data []byte) (*big.Int, error) { } -// TODO: turn this into a list, now that the pattern is embedded in each MetaData object -var L2LibraryDeps = map[string]*bind.MetaData{} +var L2LibraryDeps = []*bind.MetaData{} // TODO: convert this type to value type after everything works. // L2MetaData contains all meta data concerning the L2 contract. @@ -240,8 +236,7 @@ func (_L2 *L2) UnpackDo(data []byte) (*big.Int, error) { } -// TODO: turn this into a list, now that the pattern is embedded in each MetaData object -var L2bLibraryDeps = map[string]*bind.MetaData{} +var L2bLibraryDeps = []*bind.MetaData{} // TODO: convert this type to value type after everything works. // L2bMetaData contains all meta data concerning the L2b contract. @@ -292,8 +287,7 @@ func (_L2b *L2b) UnpackDo(data []byte) (*big.Int, error) { } -// TODO: turn this into a list, now that the pattern is embedded in each MetaData object -var L3LibraryDeps = map[string]*bind.MetaData{} +var L3LibraryDeps = []*bind.MetaData{} // TODO: convert this type to value type after everything works. // L3MetaData contains all meta data concerning the L3 contract. @@ -344,8 +338,7 @@ func (_L3 *L3) UnpackDo(data []byte) (*big.Int, error) { } -// TODO: turn this into a list, now that the pattern is embedded in each MetaData object -var L4LibraryDeps = map[string]*bind.MetaData{} +var L4LibraryDeps = []*bind.MetaData{} // TODO: convert this type to value type after everything works. // L4MetaData contains all meta data concerning the L4 contract. @@ -396,8 +389,7 @@ func (_L4 *L4) UnpackDo(data []byte) (*big.Int, error) { } -// TODO: turn this into a list, now that the pattern is embedded in each MetaData object -var L4bLibraryDeps = map[string]*bind.MetaData{} +var L4bLibraryDeps = []*bind.MetaData{} // TODO: convert this type to value type after everything works. // L4bMetaData contains all meta data concerning the L4b contract. diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index b06bc17e1511..3fb97ac95682 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -127,7 +127,7 @@ type DeploymentParams struct { Contracts []ContractDeployParams // Libraries is a map of pattern to metadata for library contracts that // are to be deployed. - Libraries map[string]*bind.MetaData + Libraries []*bind.MetaData // Overrides is an optional map of pattern to deployment address. // Contracts/libraries that refer to dependencies in the override // set are linked to the provided address (an already-deployed contract). @@ -156,8 +156,8 @@ func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deploy // re-express libraries as a map of pattern -> pre-link binary pending := make(map[string]string) - for pattern, meta := range libMetas { - pending[pattern] = meta.Bin + for _, meta := range libMetas { + pending[meta.Pattern] = meta.Bin } // initialize the set of already-deployed contracts with given override addresses From 70cb700e772c646fae752ed245a720543dda400f Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 26 Nov 2024 17:51:29 +0700 Subject: [PATCH 030/104] remove old half-written test case with events (I will add it back in when I complete it). --- .../v2/v2_generated_testcase/abi.json | 2 - .../v2/v2_generated_testcase/contract.bin | 1 - .../v2/v2_generated_testcase/contract.sol | 51 ----- .../v2_generated_testcase/example_contract.go | 199 ------------------ .../abi/bind/v2/{v2_test.go => lib_test.go} | 130 +----------- 5 files changed, 3 insertions(+), 380 deletions(-) delete mode 100644 accounts/abi/bind/testdata/v2/v2_generated_testcase/abi.json delete mode 100644 accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.bin delete mode 100644 accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.sol delete mode 100644 accounts/abi/bind/testdata/v2/v2_generated_testcase/example_contract.go rename accounts/abi/bind/v2/{v2_test.go => lib_test.go} (53%) diff --git a/accounts/abi/bind/testdata/v2/v2_generated_testcase/abi.json b/accounts/abi/bind/testdata/v2/v2_generated_testcase/abi.json deleted file mode 100644 index d9d45d33a4e1..000000000000 --- a/accounts/abi/bind/testdata/v2/v2_generated_testcase/abi.json +++ /dev/null @@ -1,2 +0,0 @@ - -[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"firstArg","type":"uint256"},{"indexed":false,"internalType":"string","name":"secondArg","type":"string"}],"name":"Basic","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"firstArg","type":"uint256"},{"components":[{"internalType":"int256","name":"val1","type":"int256"},{"internalType":"int256","name":"val2","type":"int256"},{"internalType":"string","name":"val3","type":"string"}],"indexed":false,"internalType":"struct Example.exampleStruct","name":"secondArg","type":"tuple"}],"name":"Struct","type":"event"},{"inputs":[],"name":"emitEvent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emitEventsDiffTypes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emitTwoEvents","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"num","type":"uint256"}],"name":"mutateStorageVal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"retrieveStorageVal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}] diff --git a/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.bin b/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.bin deleted file mode 100644 index 80fb73db5994..000000000000 --- a/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.bin +++ /dev/null @@ -1 +0,0 @@ -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 diff --git a/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.sol b/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.sol deleted file mode 100644 index e48a07f8547f..000000000000 --- a/accounts/abi/bind/testdata/v2/v2_generated_testcase/contract.sol +++ /dev/null @@ -1,51 +0,0 @@ -// SPDX-License-Identifier: GPL-3.0 - -pragma solidity >=0.8.2 <0.9.0; - -/** - * @title Storage - * @dev Store & retrieve value in a variable - * @custom:dev-run-script ./scripts/deploy_with_ethers.ts - */ -contract Example { - - uint256 number; - struct exampleStruct { - int val1; - int val2; - string val3; - } - - event Basic(uint indexed firstArg, string secondArg); - event Struct(uint indexed firstArg, exampleStruct secondArg); - - /** - * @dev Store value in variable - * @param num value to store - */ - function mutateStorageVal(uint256 num) public { - number = num; - } - - /** - * @dev Return value - * @return value of 'number' - */ - function retrieveStorageVal() public view returns (uint256){ - return number; - } - - function emitEvent() public { - emit Basic(123, "event"); - } - - function emitTwoEvents() public { - emit Basic(123, "event1"); - emit Basic(123, "event2"); - } - - function emitEventsDiffTypes() public { - emit Basic(123, "event1"); - emit Struct(123, exampleStruct({val1: 1, val2: 2, val3: "string"})); - } -} diff --git a/accounts/abi/bind/testdata/v2/v2_generated_testcase/example_contract.go b/accounts/abi/bind/testdata/v2/v2_generated_testcase/example_contract.go deleted file mode 100644 index 0aed0ddba891..000000000000 --- a/accounts/abi/bind/testdata/v2/v2_generated_testcase/example_contract.go +++ /dev/null @@ -1,199 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package v2_generated_testcase - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// ExampleexampleStruct is an auto generated low-level Go binding around an user-defined struct. -type ExampleexampleStruct struct { - Val1 *big.Int - Val2 *big.Int - Val3 string -} - -// V2GeneratedTestcaseMetaData contains all meta data concerning the V2GeneratedTestcase contract. -var V2GeneratedTestcaseMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"firstArg\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"secondArg\",\"type\":\"string\"}],\"name\":\"Basic\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"firstArg\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"int256\",\"name\":\"val1\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"val2\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"val3\",\"type\":\"string\"}],\"indexed\":false,\"internalType\":\"structExample.exampleStruct\",\"name\":\"secondArg\",\"type\":\"tuple\"}],\"name\":\"Struct\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"emitEvent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"emitEventsDiffTypes\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"emitTwoEvents\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"}],\"name\":\"mutateStorageVal\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"retrieveStorageVal\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", -} - -// V2GeneratedTestcaseInstance represents a deployed instance of the V2GeneratedTestcase contract. -type V2GeneratedTestcaseInstance struct { - V2GeneratedTestcase - address common.Address // consider removing this, not clear what it's used for now (and why did we need custom deploy method on previous abi?) - backend bind.ContractBackend -} - -func NewV2GeneratedTestcaseInstance(c *V2GeneratedTestcase, address common.Address, backend bind.ContractBackend) *V2GeneratedTestcaseInstance { - return &V2GeneratedTestcaseInstance{V2GeneratedTestcase: *c, address: address} -} - -func (i *V2GeneratedTestcaseInstance) Address() common.Address { - return i.address -} - -func (i *V2GeneratedTestcaseInstance) Backend() bind.ContractBackend { - return i.backend -} - -// V2GeneratedTestcase is an auto generated Go binding around an Ethereum contract. -type V2GeneratedTestcase struct { - abi abi.ABI - deployCode []byte -} - -// NewV2GeneratedTestcase creates a new instance of V2GeneratedTestcase. -func NewV2GeneratedTestcase() (*V2GeneratedTestcase, error) { - parsed, err := V2GeneratedTestcaseMetaData.GetAbi() - if err != nil { - return nil, err - } - code := common.Hex2Bytes(V2GeneratedTestcaseMetaData.Bin) - return &V2GeneratedTestcase{abi: *parsed, deployCode: code}, nil -} - -func (_V2GeneratedTestcase *V2GeneratedTestcase) DeployCode() []byte { - return _V2GeneratedTestcase.deployCode -} - -func (_V2GeneratedTestcase *V2GeneratedTestcase) PackConstructor() ([]byte, error) { - return _V2GeneratedTestcase.abi.Pack("") -} - -// EmitEvent is a free data retrieval call binding the contract method 0x7b0cb839. -// -// Solidity: function emitEvent() returns() -func (_V2GeneratedTestcase *V2GeneratedTestcase) PackEmitEvent() ([]byte, error) { - return _V2GeneratedTestcase.abi.Pack("emitEvent") -} - -// EmitEventsDiffTypes is a free data retrieval call binding the contract method 0x79da6d70. -// -// Solidity: function emitEventsDiffTypes() returns() -func (_V2GeneratedTestcase *V2GeneratedTestcase) PackEmitEventsDiffTypes() ([]byte, error) { - return _V2GeneratedTestcase.abi.Pack("emitEventsDiffTypes") -} - -// EmitTwoEvents is a free data retrieval call binding the contract method 0x7216c333. -// -// Solidity: function emitTwoEvents() returns() -func (_V2GeneratedTestcase *V2GeneratedTestcase) PackEmitTwoEvents() ([]byte, error) { - return _V2GeneratedTestcase.abi.Pack("emitTwoEvents") -} - -// MutateStorageVal is a free data retrieval call binding the contract method 0xbf54fad4. -// -// Solidity: function mutateStorageVal(uint256 num) returns() -func (_V2GeneratedTestcase *V2GeneratedTestcase) PackMutateStorageVal(num *big.Int) ([]byte, error) { - return _V2GeneratedTestcase.abi.Pack("mutateStorageVal", num) -} - -// RetrieveStorageVal is a free data retrieval call binding the contract method 0x6da1cd55. -// -// Solidity: function retrieveStorageVal() view returns(uint256) -func (_V2GeneratedTestcase *V2GeneratedTestcase) PackRetrieveStorageVal() ([]byte, error) { - return _V2GeneratedTestcase.abi.Pack("retrieveStorageVal") -} - -func (_V2GeneratedTestcase *V2GeneratedTestcase) UnpackRetrieveStorageVal(data []byte) (*big.Int, error) { - out, err := _V2GeneratedTestcase.abi.Unpack("retrieveStorageVal", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// V2GeneratedTestcaseBasic represents a Basic event raised by the V2GeneratedTestcase contract. -type V2GeneratedTestcaseBasic struct { - FirstArg *big.Int - SecondArg string - Raw *types.Log // Blockchain specific contextual infos -} - -func V2GeneratedTestcaseBasicEventID() common.Hash { - return common.HexToHash("0x114f97f563bc13d79fae32f4746248fd563650659371fef0bc8a7011fdd7bc6a") -} - -func (_V2GeneratedTestcase *V2GeneratedTestcase) UnpackBasicEvent(log *types.Log) (*V2GeneratedTestcaseBasic, error) { - event := "Basic" - if log.Topics[0] != _V2GeneratedTestcase.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(V2GeneratedTestcaseBasic) - if len(log.Data) > 0 { - if err := _V2GeneratedTestcase.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _V2GeneratedTestcase.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 -} - -// V2GeneratedTestcaseStruct represents a Struct event raised by the V2GeneratedTestcase contract. -type V2GeneratedTestcaseStruct struct { - FirstArg *big.Int - SecondArg ExampleexampleStruct - Raw *types.Log // Blockchain specific contextual infos -} - -func V2GeneratedTestcaseStructEventID() common.Hash { - return common.HexToHash("0xaa0aa64a4dab26dbe87da2dcff945b2197f80de1903db7334b8f496a94428d39") -} - -func (_V2GeneratedTestcase *V2GeneratedTestcase) UnpackStructEvent(log *types.Log) (*V2GeneratedTestcaseStruct, error) { - event := "Struct" - if log.Topics[0] != _V2GeneratedTestcase.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(V2GeneratedTestcaseStruct) - if len(log.Data) > 0 { - if err := _V2GeneratedTestcase.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _V2GeneratedTestcase.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/v2_test.go b/accounts/abi/bind/v2/lib_test.go similarity index 53% rename from accounts/abi/bind/v2/v2_test.go rename to accounts/abi/bind/v2/lib_test.go index 4f0fb90fb693..ccac33e974ed 100644 --- a/accounts/abi/bind/v2/v2_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -34,87 +34,8 @@ func JSON(reader io.Reader) (abi.ABI, error) { return instance, nil } -func TestV2(t *testing.T) { - testAddr := crypto.PubkeyToAddress(testKey.PublicKey) - backend := simulated.NewBackend( - types.GenesisAlloc{ - testAddr: {Balance: big.NewInt(10000000000000000)}, - }, - func(nodeConf *node.Config, ethConf *ethconfig.Config) { - ethConf.Genesis.Difficulty = big.NewInt(0) - }, - ) - defer backend.Close() - - contractABI, err := JSON(strings.NewReader(v2_generated_testcase.V2GeneratedTestcaseMetaData.ABI)) - if err != nil { - panic(err) - } - - signer := types.LatestSigner(params.AllDevChainProtocolChanges) - opts := bind.TransactOpts{ - From: testAddr, - Nonce: nil, - Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { - signature, err := crypto.Sign(signer.Hash(tx).Bytes(), testKey) - if err != nil { - t.Fatal(err) - } - signedTx, err := tx.WithSignature(signer, signature) - if err != nil { - t.Fatal(err) - } - return signedTx, nil - }, - Context: context.Background(), - } - // we should just be able to use the backend directly, instead of using - // this deprecated interface. However, the simulated backend no longer - // implements backends.SimulatedBackend... - bindBackend := backends.SimulatedBackend{ - Backend: backend, - Client: backend.Client(), - } - address, tx, _, err := bind.DeployContract(&opts, contractABI, common.Hex2Bytes(v2_generated_testcase.V2GeneratedTestcaseMetaData.Bin), &bindBackend) - if err != nil { - t.Fatal(err) - } - - _, err = bind.WaitDeployed(context.Background(), &bindBackend, tx) - if err != nil { - t.Fatalf("error deploying bound contract: %+v", err) - } - - contract, err := v2_generated_testcase.NewV2GeneratedTestcase() - if err != nil { - t.Fatal(err) // can't happen here with the example used. consider removing this block - } - //contractInstance := v2_generated_testcase.NewV2GeneratedTestcaseInstance(contract, address, bindBackend) - contractInstance := ContractInstance{ - Address: address, - Backend: bindBackend, - } - sinkCh := make(chan *v2_generated_testcase.V2GeneratedTestcaseStruct) - // q: what extra functionality is given by specifying this as a custom method, instead of catching emited methods - // from the sync channel? - unpackStruct := func(log *types.Log) (*v2_generated_testcase.V2GeneratedTestcaseStruct, error) { - res, err := contract.UnpackStructEvent(log) - return res, err - } - watchOpts := bind.WatchOpts{ - Start: nil, - Context: context.Background(), - } - // TODO: test using various topics - // q: does nil topics mean to accept any? - sub, err := WatchLogs[v2_generated_testcase.V2GeneratedTestcaseStruct](&contractInstance, &watchOpts, v2_generated_testcase.V2GeneratedTestcaseStructEventID(), unpackStruct, sinkCh, nil) - if err != nil { - t.Fatal(err) - } - defer sub.Unsubscribe() - // send a balance to our contract (contract must accept ether by default) -} - +// test that deploying a contract with library dependencies works, +// verifying by calling the deployed contract. func TestDeployment(t *testing.T) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey) backend := simulated.NewBackend( @@ -228,57 +149,12 @@ func TestDeployment(t *testing.T) { /* func TestDeploymentWithOverrides(t *testing.T) { - testAddr := crypto.PubkeyToAddress(testKey.PublicKey) - backend := simulated.NewBackend( - types.GenesisAlloc{ - testAddr: {Balance: big.NewInt(10000000000000000)}, - }, - func(nodeConf *node.Config, ethConf *ethconfig.Config) { - ethConf.Genesis.Difficulty = big.NewInt(0) - }, - ) - defer backend.Close() - - _, err := JSON(strings.NewReader(v2_generated_testcase.V2GeneratedTestcaseMetaData.ABI)) - if err != nil { - panic(err) - } - - signer := types.LatestSigner(params.AllDevChainProtocolChanges) - opts := bind.TransactOpts{ - From: testAddr, - Nonce: nil, - Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { - signature, err := crypto.Sign(signer.Hash(tx).Bytes(), testKey) - if err != nil { - t.Fatal(err) - } - signedTx, err := tx.WithSignature(signer, signature) - if err != nil { - t.Fatal(err) - } - return signedTx, nil - }, - Context: context.Background(), - } - // we should just be able to use the backend directly, instead of using - // this deprecated interface. However, the simulated backend no longer - // implements backends.SimulatedBackend... - bindBackend := backends.SimulatedBackend{ - Backend: backend, - Client: backend.Client(), - } // more deployment test case ideas: // 1) deploy libraries, then deploy contract first with libraries as overrides // 2) deploy contract without library dependencies. } */ + func TestEvents(t *testing.T) { // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) } - -/* test-cases that should be extracted from v1 tests - -* EventChecker - - */ From 613690a282ab7270a4a3d3a6a94721117d5d94d1 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 26 Nov 2024 18:17:01 +0700 Subject: [PATCH 031/104] make tests run again --- accounts/abi/bind/v2/lib_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index ccac33e974ed..4e04d9136fd4 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -7,7 +7,6 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/nested_libraries" - "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/v2_generated_testcase" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" From d41e112d9ba73bdefcd89621fb26590ac4cb9d03 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 26 Nov 2024 19:14:19 +0700 Subject: [PATCH 032/104] add copyright notices. move v2 template to its own file. Rename V2Backend->BackendV2 --- .../abi/bind/{template2.go => source2.go.tpl} | 8 +------- accounts/abi/bind/template.go | 6 ++++++ accounts/abi/bind/v2/backend.go | 18 +++++++++++++++++- accounts/abi/bind/v2/lib.go | 16 ++++++++++++++++ accounts/abi/bind/v2/lib_test.go | 18 +++++++++++++++++- 5 files changed, 57 insertions(+), 9 deletions(-) rename accounts/abi/bind/{template2.go => source2.go.tpl} (97%) diff --git a/accounts/abi/bind/template2.go b/accounts/abi/bind/source2.go.tpl similarity index 97% rename from accounts/abi/bind/template2.go rename to accounts/abi/bind/source2.go.tpl index 0e97dd39c3a1..35b3e47b8535 100644 --- a/accounts/abi/bind/template2.go +++ b/accounts/abi/bind/source2.go.tpl @@ -1,8 +1,3 @@ -package bind - -// tmplSourceV2 is the Go source template that the generated -// Go contract binding V2 is based on. -const tmplSourceV2 = ` // Code generated via abigen V2 - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. @@ -150,5 +145,4 @@ var ( return out, nil } {{end}} -{{end}} -` +{{end}} \ No newline at end of file diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index f304286ffbe6..7dce6f955872 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -83,3 +83,9 @@ type tmplStruct struct { // //go:embed source.go.tpl var tmplSource string + +// tmplSourceV2 is the Go source template that the generated Go contract binding +// for abigen v2 is based on. +// +//go:embed source2.go.tpl +var tmplSourceV2 string diff --git a/accounts/abi/bind/v2/backend.go b/accounts/abi/bind/v2/backend.go index 73b420a27e5f..ca4162efab19 100644 --- a/accounts/abi/bind/v2/backend.go +++ b/accounts/abi/bind/v2/backend.go @@ -1,3 +1,19 @@ +// Copyright 2024 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + package v2 import ( @@ -8,7 +24,7 @@ import ( "math/big" ) -type V2Backend interface { +type BackendV2 interface { SuggestGasPrice(ctx context.Context) (*big.Int, error) PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 3fb97ac95682..e160bc2e0873 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -1,3 +1,19 @@ +// Copyright 2024 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + package v2 import ( diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 4e04d9136fd4..ff96e92b2157 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -1,3 +1,19 @@ +// Copyright 2024 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + package v2 import ( @@ -47,7 +63,7 @@ func TestDeployment(t *testing.T) { ) defer backend.Close() - _, err := JSON(strings.NewReader(v2_generated_testcase.V2GeneratedTestcaseMetaData.ABI)) + _, err := JSON(strings.NewReader(nested_libraries.C1MetaData.ABI)) if err != nil { panic(err) } From 1d7fef8a1287733075ec5faa671b6a02b0fd788b Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 26 Nov 2024 19:31:58 +0700 Subject: [PATCH 033/104] various small fixes: better error message, remove unecessary comments. address review about missing word in function documentation. --- accounts/abi/bind/bind.go | 3 ++- accounts/abi/bind/v2/lib_test.go | 6 +----- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index a4655bb64a54..e4bdf41f1e7c 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -365,7 +365,8 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] // methods (which in v1 recursively deploy their // library dependencies). So, the entire set of // library dependencies is required, and we will - // the order to deploy and link them at runtime. + // determine the order to deploy and link them at + // runtime. var findDeps func(contract *tmplContract) map[string]struct{} findDeps = func(contract *tmplContract) map[string]struct{} { // 1) match all libraries that this contract depends on diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index ff96e92b2157..612a38f97a63 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -92,9 +92,6 @@ func TestDeployment(t *testing.T) { Backend: backend, Client: backend.Client(), } - - //log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stdout, log.LevelDebug, true))) - ctrct, err := nested_libraries.NewC1() if err != nil { panic(err) @@ -102,9 +99,8 @@ func TestDeployment(t *testing.T) { constructorInput, err := ctrct.PackConstructor(big.NewInt(42), big.NewInt(1)) if err != nil { - t.Fatalf("fack %v", err) + t.Fatalf("failed to pack constructor: %v", err) } - // TODO: test case with arguments-containing constructor deploymentParams := DeploymentParams{ Contracts: []ContractDeployParams{ { From 58cddb2c5a389ef198ecee2dd860398ff0eafdb7 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 27 Nov 2024 14:20:17 +0700 Subject: [PATCH 034/104] add test for overrides --- accounts/abi/bind/v2/lib.go | 18 +++-- accounts/abi/bind/v2/lib_test.go | 132 ++++++++++++++++++++++++++++--- 2 files changed, 132 insertions(+), 18 deletions(-) diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index e160bc2e0873..0895d446c89c 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -49,7 +49,7 @@ func deployContract(backend bind.ContractBackend, auth *bind.TransactOpts, const } // deployLibs iterates the set contracts (map of pattern to hex-encoded -// contract deploy code). each value in contracts is deployed, and the +// contract deployer code). Each contract is deployed, and the // resulting addresses/deployment-txs are returned on success. func deployLibs(backend bind.ContractBackend, auth *bind.TransactOpts, contracts map[string]string) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[string]common.Address, err error) { deploymentTxs = make(map[common.Address]*types.Transaction) @@ -72,9 +72,9 @@ func deployLibs(backend bind.ContractBackend, auth *bind.TransactOpts, contracts return deploymentTxs, deployAddrs, nil } -// linkContract takes an unlinked contract deploy code (contract) a map of -// linked-and-deployed library dependencies, replaces references to library -// deps in the contract code, and returns the contract deployment bytecode on +// linkContract takes an unlinked contract deployer hex-encoded code, a map of +// already-deployed library dependencies, replaces references to deployed library +// dependencies in the contract code, and returns the contract deployment bytecode on // success. func linkContract(contract string, linkedLibs map[string]common.Address) (deployableContract string, err error) { reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") @@ -92,10 +92,11 @@ func linkContract(contract string, linkedLibs map[string]common.Address) (deploy // linkLibs iterates the set of dependencies that have yet to be // linked/deployed (pending), replacing references to library dependencies -// if those dependencies are fully linked/deployed (in 'linked'). +// (i.e. mutating pending) if those dependencies are fully linked/deployed +// (in 'linked'). // // contracts that have become fully linked in the current invocation are -// returned in the resulting map. +// returned. func linkLibs(pending *map[string]string, linked map[string]common.Address) (deployableDeps map[string]string) { reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") if err != nil { @@ -160,7 +161,8 @@ type DeploymentResult struct { } // LinkAndDeploy deploys a specified set of contracts and their dependent -// libraries. +// libraries. If an error occurs, only contracts which were successfully +// deployed are returned in the result. func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deployParams DeploymentParams) (res *DeploymentResult, err error) { libMetas := deployParams.Libraries overrides := deployParams.Overrides @@ -202,12 +204,12 @@ func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deploy } } + // link and deploy contracts for _, contractParams := range deployParams.Contracts { linkedContract, err := linkContract(contractParams.Meta.Bin, deployed) if err != nil { return res, err } - // link and deploy the contracts contractTx, contractAddr, err := deployContract(backend, auth, contractParams.Input, linkedContract) if err != nil { return res, err diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 612a38f97a63..84fb4b28b7cd 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -19,6 +19,7 @@ package v2 import ( "context" "encoding/json" + "fmt" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" @@ -49,9 +50,7 @@ func JSON(reader io.Reader) (abi.ABI, error) { return instance, nil } -// test that deploying a contract with library dependencies works, -// verifying by calling the deployed contract. -func TestDeployment(t *testing.T) { +func testSetup() (*bind.TransactOpts, *backends.SimulatedBackend, error) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey) backend := simulated.NewBackend( types.GenesisAlloc{ @@ -61,11 +60,10 @@ func TestDeployment(t *testing.T) { ethConf.Genesis.Difficulty = big.NewInt(0) }, ) - defer backend.Close() _, err := JSON(strings.NewReader(nested_libraries.C1MetaData.ABI)) if err != nil { - panic(err) + return nil, nil, err } signer := types.LatestSigner(params.AllDevChainProtocolChanges) @@ -75,11 +73,13 @@ func TestDeployment(t *testing.T) { Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { signature, err := crypto.Sign(signer.Hash(tx).Bytes(), testKey) if err != nil { - t.Fatal(err) + panic(fmt.Sprintf("error signing tx: %v", err)) + return nil, err } signedTx, err := tx.WithSignature(signer, signature) if err != nil { - t.Fatal(err) + panic(fmt.Sprintf("error creating tx with sig: %v", err)) + return nil, err } return signedTx, nil }, @@ -92,6 +92,18 @@ func TestDeployment(t *testing.T) { Backend: backend, Client: backend.Client(), } + return &opts, &bindBackend, nil +} + +// test that deploying a contract with library dependencies works, +// verifying by calling the deployed contract. +func TestDeployment(t *testing.T) { + opts, bindBackend, err := testSetup() + if err != nil { + t.Fatalf("err setting up test: %v", err) + } + defer bindBackend.Backend.Close() + ctrct, err := nested_libraries.NewC1() if err != nil { panic(err) @@ -111,7 +123,7 @@ func TestDeployment(t *testing.T) { Libraries: nested_libraries.C1LibraryDeps, Overrides: nil, } - res, err := LinkAndDeploy(&opts, bindBackend, deploymentParams) + res, err := LinkAndDeploy(opts, bindBackend, deploymentParams) if err != nil { t.Fatalf("err: %+v\n", err) } @@ -121,11 +133,108 @@ func TestDeployment(t *testing.T) { t.Fatalf("deployment should have generated 5 addresses. got %d", len(res.Addrs)) } for _, tx := range res.Txs { - _, err = bind.WaitDeployed(context.Background(), &bindBackend, tx) + _, err = bind.WaitDeployed(context.Background(), bindBackend, tx) + if err != nil { + t.Fatalf("error deploying library: %+v", err) + } + } + c, err := nested_libraries.NewC1() + if err != nil { + t.Fatalf("err is %v", err) + } + doInput, err := c.PackDo(big.NewInt(1)) + if err != nil { + t.Fatalf("pack function input err: %v\n", doInput) + } + + cABI, err := nested_libraries.C1MetaData.GetAbi() + if err != nil { + t.Fatalf("error getting abi object: %v", err) + } + contractAddr := res.Addrs[nested_libraries.C1MetaData.Pattern] + boundC := bind.NewBoundContract(contractAddr, *cABI, bindBackend, bindBackend, bindBackend) + callOpts := &bind.CallOpts{ + From: common.Address{}, + Context: context.Background(), + } + callRes, err := boundC.CallRaw(callOpts, doInput) + if err != nil { + t.Fatalf("err calling contract: %v", err) + } + internalCallCount, err := c.UnpackDo(callRes) + if err != nil { + t.Fatalf("err unpacking result: %v", err) + } + if internalCallCount.Uint64() != 6 { + t.Fatalf("expected internal call count of 6. got %d.", internalCallCount.Uint64()) + } +} + +func TestDeploymentWithOverrides(t *testing.T) { + opts, bindBackend, err := testSetup() + if err != nil { + t.Fatalf("err setting up test: %v", err) + } + defer bindBackend.Backend.Close() + + // deploy some library deps + deploymentParams := DeploymentParams{ + Libraries: nested_libraries.C1LibraryDeps, + } + + res, err := LinkAndDeploy(opts, bindBackend, deploymentParams) + if err != nil { + t.Fatalf("err: %+v\n", err) + } + bindBackend.Commit() + + if len(res.Addrs) != 4 { + t.Fatalf("deployment should have generated 4 addresses. got %d", len(res.Addrs)) + } + for _, tx := range res.Txs { + _, err = bind.WaitDeployed(context.Background(), bindBackend, tx) if err != nil { t.Fatalf("error deploying library: %+v", err) } } + + ctrct, err := nested_libraries.NewC1() + if err != nil { + panic(err) + } + constructorInput, err := ctrct.PackConstructor(big.NewInt(42), big.NewInt(1)) + if err != nil { + t.Fatalf("failed to pack constructor: %v", err) + } + overrides := res.Addrs + // deploy the contract + deploymentParams = DeploymentParams{ + Contracts: []ContractDeployParams{ + { + Meta: nested_libraries.C1MetaData, + Input: constructorInput, + }, + }, + Libraries: nil, + Overrides: overrides, + } + res, err = LinkAndDeploy(opts, bindBackend, deploymentParams) + if err != nil { + t.Fatalf("err: %+v\n", err) + } + bindBackend.Commit() + + if len(res.Addrs) != 1 { + t.Fatalf("deployment should have generated 1 address. got %d", len(res.Addrs)) + } + for _, tx := range res.Txs { + _, err = bind.WaitDeployed(context.Background(), bindBackend, tx) + if err != nil { + t.Fatalf("error deploying library: %+v", err) + } + } + + // call the deployed contract and make sure it returns the correct result c, err := nested_libraries.NewC1() if err != nil { t.Fatalf("err is %v", err) @@ -140,7 +249,7 @@ func TestDeployment(t *testing.T) { t.Fatalf("error getting abi object: %v", err) } contractAddr := res.Addrs[nested_libraries.C1MetaData.Pattern] - boundC := bind.NewBoundContract(contractAddr, *cABI, &bindBackend, &bindBackend, &bindBackend) + boundC := bind.NewBoundContract(contractAddr, *cABI, bindBackend, bindBackend, bindBackend) callOpts := &bind.CallOpts{ From: common.Address{}, Context: context.Background(), @@ -158,6 +267,9 @@ func TestDeployment(t *testing.T) { } } +/* + * + */ /* func TestDeploymentWithOverrides(t *testing.T) { // more deployment test case ideas: From fa7fea2391c41dd9cf29ca37b40026575ed7865b Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 27 Nov 2024 21:17:13 +0700 Subject: [PATCH 035/104] add test coverage for events watching --- accounts/abi/bind/base.go | 7 +- .../abi/bind/testdata/v2/events/bindings.go | 140 +++++++++++ .../bind/testdata/v2/events/combined-abi.json | 1 + .../abi/bind/testdata/v2/events/contract.sol | 31 +++ .../abi/bind/testdata/v2/simple/contract.sol | 6 + accounts/abi/bind/v2/lib.go | 19 +- accounts/abi/bind/v2/lib_test.go | 234 +++++++++++++++++- 7 files changed, 425 insertions(+), 13 deletions(-) create mode 100644 accounts/abi/bind/testdata/v2/events/bindings.go create mode 100644 accounts/abi/bind/testdata/v2/events/combined-abi.json create mode 100644 accounts/abi/bind/testdata/v2/simple/contract.sol diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index eb24b4b977c2..a928a46c95f3 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -404,7 +404,6 @@ func (c *BoundContract) estimateGasLimit(opts *TransactOpts, contract *common.Ad } res, err := c.transactor.EstimateGas(ensureContext(opts.Context), msg) if err != nil { - fmt.Printf("msg data is %x\n", msg.Data) panic(err) } return res, nil @@ -519,6 +518,12 @@ func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]inter return c.watchLogs(opts, c.abi.Events[name].ID, query...) } +// WatchLogsForId filters subscribes to contract logs for future blocks, returning a +// subscription object that can be used to tear down the watcher. +func (c *BoundContract) WatchLogsForId(opts *WatchOpts, id common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + return c.watchLogs(opts, id, query...) +} + func (c *BoundContract) watchLogs(opts *WatchOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { // Don't crash on a lazy user if opts == nil { diff --git a/accounts/abi/bind/testdata/v2/events/bindings.go b/accounts/abi/bind/testdata/v2/events/bindings.go new file mode 100644 index 000000000000..720f2716b531 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/events/bindings.go @@ -0,0 +1,140 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package events + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +var CLibraryDeps = []*bind.MetaData{} + +// 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\":\"EmitMulti\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"EmitOne\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Pattern: "55ef3c19a0ab1c1845f9e347540c1e51f5", + Bin: "0x6080604052348015600e575f80fd5b506101a08061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063cb49374914610038578063e8e49a7114610042575b5f80fd5b61004061004c565b005b61004a6100fd565b005b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161007e9190610151565b60405180910390a260037f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd20760046040516100b89190610151565b60405180910390a25f15157f3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e60016040516100f39190610151565b60405180910390a2565b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161012f9190610151565b60405180910390a2565b5f819050919050565b61014b81610139565b82525050565b5f6020820190506101645f830184610142565b9291505056fea26469706673582212203624d263fed93ccf2a175b7c701e773f413c64394a51928aa2b1968299798fe664736f6c634300081a0033", +} + +// 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 +} + +// TODO: create custom exported types where unpack would generate a struct return. + +// TODO: test constructor with inputs +func (_C *C) PackConstructor() ([]byte, error) { + return _C.abi.Pack("") +} + +// 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 +} + +func CBasic1EventID() common.Hash { + return common.HexToHash("0x8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207") +} + +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 +} + +func CBasic2EventID() common.Hash { + return common.HexToHash("0x3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e") +} + +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/testdata/v2/events/combined-abi.json b/accounts/abi/bind/testdata/v2/events/combined-abi.json new file mode 100644 index 000000000000..85ab4178c24c --- /dev/null +++ b/accounts/abi/bind/testdata/v2/events/combined-abi.json @@ -0,0 +1 @@ +{"contracts":{"contract.sol:C":{"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":"EmitMulti","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"EmitOne","outputs":[],"stateMutability":"nonpayable","type":"function"}],"bin":"6080604052348015600e575f80fd5b506101a08061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063cb49374914610038578063e8e49a7114610042575b5f80fd5b61004061004c565b005b61004a6100fd565b005b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161007e9190610151565b60405180910390a260037f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd20760046040516100b89190610151565b60405180910390a25f15157f3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e60016040516100f39190610151565b60405180910390a2565b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161012f9190610151565b60405180910390a2565b5f819050919050565b61014b81610139565b82525050565b5f6020820190506101645f830184610142565b9291505056fea26469706673582212203624d263fed93ccf2a175b7c701e773f413c64394a51928aa2b1968299798fe664736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/testdata/v2/events/contract.sol b/accounts/abi/bind/testdata/v2/events/contract.sol index 1e26c0e04dc5..bb55e3a249b5 100644 --- a/accounts/abi/bind/testdata/v2/events/contract.sol +++ b/accounts/abi/bind/testdata/v2/events/contract.sol @@ -2,5 +2,36 @@ pragma solidity ^0.8.26; contract C { + event basic1( + uint256 indexed id, + uint256 data + ); + event basic2( + bool indexed flag, + uint256 data + ); + // TODO: consider log test where data is hashed? maybe not necessary for v2 coverage + function EmitOne() public { + emit basic1( + uint256(1), + uint256(2)); + } + + // emit multiple events, different types + function EmitMulti() public { + emit basic1( + uint256(1), + uint256(2)); + emit basic1( + uint256(3), + uint256(4)); + emit basic2( + false, + uint256(1)); + } + + constructor() { + // do something with these + } } \ No newline at end of file diff --git a/accounts/abi/bind/testdata/v2/simple/contract.sol b/accounts/abi/bind/testdata/v2/simple/contract.sol new file mode 100644 index 000000000000..1e26c0e04dc5 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/simple/contract.sol @@ -0,0 +1,6 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.26; + +contract C { + +} \ No newline at end of file diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 0895d446c89c..ed741e239727 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -29,6 +29,7 @@ import ( "strings" ) +// TODO: it's weird to have a mirror interface of this in the bind package... type ContractInstance struct { Address common.Address Backend bind.ContractBackend @@ -233,10 +234,10 @@ func FilterLogs[T any](instance *ContractInstance, opts *bind.FilterOpts, eventI } // TODO: adding docs soon (jwasinger) -func WatchLogs[T any](instance *ContractInstance, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { +func WatchLogs[T any](instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { backend := instance.Backend - c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) - logs, sub, err := c.WatchLogs(opts, eventID.String(), topics...) + c := bind.NewBoundContract(instance.Address, abi, backend, backend, backend) + logs, sub, err := c.WatchLogsForId(opts, eventID, topics...) if err != nil { return nil, err } @@ -335,10 +336,10 @@ func (it *EventIterator[T]) Close() error { // Transact creates and submits a transaction to the bound contract instance // using the provided abi-encoded input (or nil). -func Transact(instance bind.ContractInstance, opts *bind.TransactOpts, input []byte) (*types.Transaction, error) { +func Transact(instance *ContractInstance, opts *bind.TransactOpts, input []byte) (*types.Transaction, error) { var ( - addr = instance.Address() - backend = instance.Backend() + addr = instance.Address + backend = instance.Backend ) c := bind.NewBoundContract(addr, abi.ABI{}, backend, backend, backend) return c.RawTransact(opts, input) @@ -346,8 +347,8 @@ func Transact(instance bind.ContractInstance, opts *bind.TransactOpts, input []b // Call performs an eth_call on the given bound contract instance, using the // provided abi-encoded input (or nil). -func Call(instance bind.ContractInstance, opts *bind.CallOpts, input []byte) ([]byte, error) { - backend := instance.Backend() - c := bind.NewBoundContract(instance.Address(), abi.ABI{}, backend, backend, backend) +func Call(instance *ContractInstance, opts *bind.CallOpts, input []byte) ([]byte, error) { + backend := instance.Backend + c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) return c.CallRaw(opts, input) } diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 84fb4b28b7cd..a891b5eb36a3 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -23,6 +23,7 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" + "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/events" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/nested_libraries" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" @@ -35,6 +36,7 @@ import ( "math/big" "strings" "testing" + "time" ) var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") @@ -67,7 +69,7 @@ func testSetup() (*bind.TransactOpts, *backends.SimulatedBackend, error) { } signer := types.LatestSigner(params.AllDevChainProtocolChanges) - opts := bind.TransactOpts{ + opts := &bind.TransactOpts{ From: testAddr, Nonce: nil, Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { @@ -92,12 +94,17 @@ func testSetup() (*bind.TransactOpts, *backends.SimulatedBackend, error) { Backend: backend, Client: backend.Client(), } - return &opts, &bindBackend, nil + return opts, &bindBackend, nil +} + +// test deployment and interaction for a basic contract with no library deps +func TestDeployment(t *testing.T) { + } // test that deploying a contract with library dependencies works, // verifying by calling the deployed contract. -func TestDeployment(t *testing.T) { +func TestDeploymentLibraries(t *testing.T) { opts, bindBackend, err := testSetup() if err != nil { t.Fatalf("err setting up test: %v", err) @@ -278,6 +285,227 @@ func TestDeploymentWithOverrides(t *testing.T) { } */ +// note to self: see how to filter logs in eth_call. + func TestEvents(t *testing.T) { // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) + txAuth, backend, err := testSetup() + if err != nil { + t.Fatalf("error setting up testing env: %v", err) + } + + deploymentParams := DeploymentParams{ + Contracts: []ContractDeployParams{ + { + Meta: events.CMetaData, + }, + }, + } + + res, err := LinkAndDeploy(txAuth, backend, deploymentParams) + if err != nil { + t.Fatalf("error deploying contract for testing: %v", err) + } + + backend.Commit() + if _, err := bind.WaitDeployed(context.Background(), backend, res.Txs[events.CMetaData.Pattern]); err != nil { + t.Fatalf("WaitDeployed failed %v", err) + } + + ctrct, err := events.NewC() + if err != nil { + t.Fatalf("error instantiating contract instance: %v", err) + } + + abi, err := events.CMetaData.GetAbi() + if err != nil { + t.Fatalf("error getting contract abi: %v", err) + } + + // TODO: why did I introduce separate type, and not just use bound contract? + boundContract := ContractInstance{ + res.Addrs[events.CMetaData.Pattern], + backend, + } + + unpackBasic := func(raw *types.Log) (*events.CBasic1, error) { + return &events.CBasic1{ + Id: (new(big.Int)).SetBytes(raw.Topics[0].Bytes()), + Data: (new(big.Int)).SetBytes(raw.Data), + }, nil + } + unpackBasic2 := func(raw *types.Log) (*events.CBasic2, error) { + return &events.CBasic2{ + Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. + Data: (new(big.Int)).SetBytes(raw.Data), + }, nil + } + newCBasic1Ch := make(chan *events.CBasic1) + newCBasic2Ch := make(chan *events.CBasic2) + watchOpts := &bind.WatchOpts{ + Start: nil, + Context: context.Background(), + } + sub1, err := WatchLogs[events.CBasic1](&boundContract, *abi, watchOpts, events.CBasic1EventID(), unpackBasic, newCBasic1Ch) + sub2, err := WatchLogs[events.CBasic2](&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2, newCBasic2Ch) + defer sub1.Unsubscribe() + defer sub2.Unsubscribe() + fmt.Printf("watching for event with id %x\n", events.CBasic1EventID()) + fmt.Printf("watching for event with id %x\n", events.CBasic2EventID()) + //wtf do I do with this subscriptions?? + _ = sub1 + _ = sub2 + + crtctInstance := &ContractInstance{ + Address: res.Addrs[events.CMetaData.Pattern], + Backend: backend, + } + _ = ctrct + packedCall, err := ctrct.PackEmitMulti() + if err != nil { + t.Fatalf("failed to pack EmitMulti arguments") + } + tx, err := Transact(crtctInstance, txAuth, packedCall) + if err != nil { + t.Fatalf("failed to send transaction...") + } + backend.Commit() + if _, err := bind.WaitMined(context.Background(), backend, tx); err != nil { + t.Fatalf("error waiting for tx to be mined: %v", err) + } + + timeout := time.NewTimer(2 * time.Second) + e1Count := 0 + e2Count := 0 + for { + select { + case _ = <-newCBasic1Ch: + e1Count++ + case _ = <-newCBasic2Ch: + e2Count++ + case _ = <-timeout.C: + goto done + } + if e1Count == 2 && e2Count == 1 { + break + } + } +done: + if e1Count != 2 { + t.Fatalf("expected event type 1 count to be 2. got %d", e1Count) + } + if e2Count != 1 { + t.Fatalf("expected event type 2 count to be 1. got %d", e2Count) + } + // commit a few blocks... + // now filter for the previously-emitted events. + + // TODO: test that returning error from unpack prevents event from being received by sink. +} + +func TestEventsUnpackFailure(t *testing.T) { + // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) + txAuth, backend, err := testSetup() + if err != nil { + t.Fatalf("error setting up testing env: %v", err) + } + + deploymentParams := DeploymentParams{ + Contracts: []ContractDeployParams{ + { + Meta: events.CMetaData, + }, + }, + } + + res, err := LinkAndDeploy(txAuth, backend, deploymentParams) + if err != nil { + t.Fatalf("error deploying contract for testing: %v", err) + } + + backend.Commit() + if _, err := bind.WaitDeployed(context.Background(), backend, res.Txs[events.CMetaData.Pattern]); err != nil { + t.Fatalf("WaitDeployed failed %v", err) + } + + ctrct, err := events.NewC() + if err != nil { + t.Fatalf("error instantiating contract instance: %v", err) + } + + abi, err := events.CMetaData.GetAbi() + if err != nil { + t.Fatalf("error getting contract abi: %v", err) + } + + // TODO: why did I introduce separate type, and not just use bound contract? + boundContract := ContractInstance{ + res.Addrs[events.CMetaData.Pattern], + backend, + } + + unpackBasic := func(raw *types.Log) (*events.CBasic1, error) { + return nil, fmt.Errorf("could not unpack event") + } + unpackBasic2 := func(raw *types.Log) (*events.CBasic2, error) { + return &events.CBasic2{ + Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. + Data: (new(big.Int)).SetBytes(raw.Data), + }, nil + } + newCBasic1Ch := make(chan *events.CBasic1) + newCBasic2Ch := make(chan *events.CBasic2) + watchOpts := &bind.WatchOpts{ + Start: nil, + Context: context.Background(), + } + sub1, err := WatchLogs[events.CBasic1](&boundContract, *abi, watchOpts, events.CBasic1EventID(), unpackBasic, newCBasic1Ch) + sub2, err := WatchLogs[events.CBasic2](&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2, newCBasic2Ch) + defer sub1.Unsubscribe() + defer sub2.Unsubscribe() + //wtf do I do with this subscriptions?? + _ = sub1 + _ = sub2 + + crtctInstance := &ContractInstance{ + Address: res.Addrs[events.CMetaData.Pattern], + Backend: backend, + } + _ = ctrct + packedCall, err := ctrct.PackEmitMulti() + if err != nil { + t.Fatalf("failed to pack EmitMulti arguments") + } + tx, err := Transact(crtctInstance, txAuth, packedCall) + if err != nil { + t.Fatalf("failed to send transaction...") + } + backend.Commit() + if _, err := bind.WaitMined(context.Background(), backend, tx); err != nil { + t.Fatalf("error waiting for tx to be mined: %v", err) + } + + timeout := time.NewTimer(2 * time.Second) + e1Count := 0 + e2Count := 0 + for { + select { + case _ = <-newCBasic1Ch: + e1Count++ + case _ = <-newCBasic2Ch: + e2Count++ + case _ = <-timeout.C: + goto done + } + if e1Count == 2 && e2Count == 1 { + break + } + } +done: + if e1Count != 0 { + t.Fatalf("expected event type 1 count to be 0. got %d", e1Count) + } + if e2Count != 1 { + t.Fatalf("expected event type 2 count to be 1. got %d", e2Count) + } } From 2277beb46f15bfce4c0a54a7dd406cf74e47c95b Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 27 Nov 2024 23:10:15 +0700 Subject: [PATCH 036/104] add coverage for event filtering --- accounts/abi/bind/v2/lib.go | 16 +++++++++---- accounts/abi/bind/v2/lib_test.go | 40 +++++++++++++++++++++++--------- 2 files changed, 41 insertions(+), 15 deletions(-) diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index ed741e239727..3e677d6ce066 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -233,7 +233,10 @@ func FilterLogs[T any](instance *ContractInstance, opts *bind.FilterOpts, eventI return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil } -// TODO: adding docs soon (jwasinger) +// WatchLogs causes logs emitted with a given event id from a specified +// contract to be intercepted, unpacked, and forwarded to sink. If +// unpack returns an error, the returned subscription is closed with the +// error. func WatchLogs[T any](instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { backend := instance.Backend c := bind.NewBoundContract(instance.Address, abi, backend, backend, backend) @@ -270,7 +273,7 @@ func WatchLogs[T any](instance *ContractInstance, abi abi.ABI, opts *bind.WatchO // EventIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for events. type EventIterator[T any] struct { - Event *T // Event containing the contract specifics and raw log + event *T // event containing the contract specifics and raw log unpack func(*types.Log) (*T, error) // Unpack function for the event @@ -280,6 +283,11 @@ type EventIterator[T any] struct { fail error // Occurred error to stop iteration } +// Value returns the current value of the iterator, or nil if there isn't one. +func (it *EventIterator[T]) Value() *T { + return it.event +} + // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. @@ -297,7 +305,7 @@ func (it *EventIterator[T]) Next() bool { it.fail = err return false } - it.Event = res + it.event = res return true default: @@ -312,7 +320,7 @@ func (it *EventIterator[T]) Next() bool { it.fail = err return false } - it.Event = res + it.event = res return true case err := <-it.sub.Err(): diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index a891b5eb36a3..d8b0c5ee42a8 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -350,11 +350,6 @@ func TestEvents(t *testing.T) { sub2, err := WatchLogs[events.CBasic2](&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2, newCBasic2Ch) defer sub1.Unsubscribe() defer sub2.Unsubscribe() - fmt.Printf("watching for event with id %x\n", events.CBasic1EventID()) - fmt.Printf("watching for event with id %x\n", events.CBasic2EventID()) - //wtf do I do with this subscriptions?? - _ = sub1 - _ = sub2 crtctInstance := &ContractInstance{ Address: res.Addrs[events.CMetaData.Pattern], @@ -397,10 +392,36 @@ done: if e2Count != 1 { t.Fatalf("expected event type 2 count to be 1. got %d", e2Count) } - // commit a few blocks... - // now filter for the previously-emitted events. + // now, test that we can filter those events that were just caught through the subscription + + filterOpts := &bind.FilterOpts{ + Start: 0, + Context: context.Background(), + } // TODO: test that returning error from unpack prevents event from being received by sink. + it, err := FilterLogs[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), unpackBasic) + if err != nil { + t.Fatalf("error filtering logs %v\n", err) + } + it2, err := FilterLogs[events.CBasic2](crtctInstance, filterOpts, events.CBasic1EventID(), unpackBasic2) + if err != nil { + t.Fatalf("error filtering logs %v\n", err) + } + e1Count = 0 + e2Count = 0 + for it.Next() { + e1Count++ + } + for it2.Next() { + e2Count++ + } + if e2Count != 1 { + t.Fatalf("bad") + } + if e1Count != 1 { + t.Fatalf("bad") + } } func TestEventsUnpackFailure(t *testing.T) { @@ -445,7 +466,7 @@ func TestEventsUnpackFailure(t *testing.T) { } unpackBasic := func(raw *types.Log) (*events.CBasic1, error) { - return nil, fmt.Errorf("could not unpack event") + return nil, fmt.Errorf("this error should stop the filter that uses this unpack.") } unpackBasic2 := func(raw *types.Log) (*events.CBasic2, error) { return &events.CBasic2{ @@ -463,9 +484,6 @@ func TestEventsUnpackFailure(t *testing.T) { sub2, err := WatchLogs[events.CBasic2](&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2, newCBasic2Ch) defer sub1.Unsubscribe() defer sub2.Unsubscribe() - //wtf do I do with this subscriptions?? - _ = sub1 - _ = sub2 crtctInstance := &ContractInstance{ Address: res.Addrs[events.CMetaData.Pattern], From adbe12b19d0735bfa0a37abfc03b1c033543bfec Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 28 Nov 2024 15:40:30 +0700 Subject: [PATCH 037/104] return multiple results in exported struct (instead of anonymous one). add return_structs contract example to have an example of it. --- accounts/abi/bind/source2.go.tpl | 13 +-- .../abi/bind/testdata/v2/events/bindings.go | 64 ++++++++++++-- .../bind/testdata/v2/events/combined-abi.json | 2 +- .../testdata/v2/nested_libraries/bindings.go | 24 ------ .../testdata/v2/return_structs/bindings.go | 84 +++++++++++++++++++ .../v2/return_structs/combined-abi.json | 1 + .../testdata/v2/return_structs/contract.sol | 8 ++ 7 files changed, 161 insertions(+), 35 deletions(-) create mode 100644 accounts/abi/bind/testdata/v2/return_structs/bindings.go create mode 100644 accounts/abi/bind/testdata/v2/return_structs/combined-abi.json create mode 100644 accounts/abi/bind/testdata/v2/return_structs/contract.sol diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index 35b3e47b8535..223b41da47a7 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -69,9 +69,6 @@ var ( return &{{.Type}}{abi: *parsed}, nil } - // TODO: create custom exported types where unpack would generate a struct return. - - // TODO: test constructor with inputs func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}} {{.Name}} {{bindtype .Type $structs}}, {{end}}) ([]byte, error) { return _{{$contract.Type}}.abi.Pack("" {{range .Constructor.Inputs}}, {{.Name}}{{end}}) } @@ -86,10 +83,16 @@ var ( {{/* Unpack method is needed only when there are return args */}} {{if .Normalized.Outputs }} - func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}(data []byte) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) { + {{ if .Structured }} + type {{.Normalized.Name}}Output struct { + {{range .Normalized.Outputs}} + {{.Name}} {{bindtype .Type $structs}}{{end}} + } + {{ end }} + func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}(data []byte) ({{if .Structured}} {{.Normalized.Name}}Output,{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) { out, err := _{{$contract.Type}}.abi.Unpack("{{.Original.Name}}", data) {{if .Structured}} - outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} }) + outstruct := new({{.Normalized.Name}}Output) if err != nil { return *outstruct, err } diff --git a/accounts/abi/bind/testdata/v2/events/bindings.go b/accounts/abi/bind/testdata/v2/events/bindings.go index 720f2716b531..a2e93d699652 100644 --- a/accounts/abi/bind/testdata/v2/events/bindings.go +++ b/accounts/abi/bind/testdata/v2/events/bindings.go @@ -23,14 +23,20 @@ var ( _ = 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 +} + var CLibraryDeps = []*bind.MetaData{} // 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\":\"EmitMulti\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"EmitOne\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + 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: "0x6080604052348015600e575f80fd5b506101a08061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063cb49374914610038578063e8e49a7114610042575b5f80fd5b61004061004c565b005b61004a6100fd565b005b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161007e9190610151565b60405180910390a260037f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd20760046040516100b89190610151565b60405180910390a25f15157f3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e60016040516100f39190610151565b60405180910390a2565b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161012f9190610151565b60405180910390a2565b5f819050919050565b61014b81610139565b82525050565b5f6020820190506101645f830184610142565b9291505056fea26469706673582212203624d263fed93ccf2a175b7c701e773f413c64394a51928aa2b1968299798fe664736f6c634300081a0033", + Bin: "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", } // C is an auto generated Go binding around an Ethereum contract. @@ -47,13 +53,61 @@ func NewC() (*C, error) { return &C{abi: *parsed}, nil } -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs func (_C *C) PackConstructor() ([]byte, error) { return _C.abi.Pack("") } +// 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() diff --git a/accounts/abi/bind/testdata/v2/events/combined-abi.json b/accounts/abi/bind/testdata/v2/events/combined-abi.json index 85ab4178c24c..4921b7261b93 100644 --- a/accounts/abi/bind/testdata/v2/events/combined-abi.json +++ b/accounts/abi/bind/testdata/v2/events/combined-abi.json @@ -1 +1 @@ -{"contracts":{"contract.sol:C":{"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":"EmitMulti","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"EmitOne","outputs":[],"stateMutability":"nonpayable","type":"function"}],"bin":"6080604052348015600e575f80fd5b506101a08061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063cb49374914610038578063e8e49a7114610042575b5f80fd5b61004061004c565b005b61004a6100fd565b005b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161007e9190610151565b60405180910390a260037f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd20760046040516100b89190610151565b60405180910390a25f15157f3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e60016040516100f39190610151565b60405180910390a2565b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207600260405161012f9190610151565b60405180910390a2565b5f819050919050565b61014b81610139565b82525050565b5f6020820190506101645f830184610142565b9291505056fea26469706673582212203624d263fed93ccf2a175b7c701e773f413c64394a51928aa2b1968299798fe664736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} +{"contracts":{"contract.sol:C":{"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":"struct C.Point","name":"p","type":"tuple"}],"name":"DoSomethingWithPoint","outputs":[{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct C.Point","name":"","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"EmitMulti","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"EmitOne","outputs":[],"stateMutability":"nonpayable","type":"function"}],"bin":"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"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go index 6ab458a76455..267862d19459 100644 --- a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go +++ b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go @@ -52,9 +52,6 @@ func NewC1() (*C1, error) { return &C1{abi: *parsed}, nil } -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs func (_C1 *C1) PackConstructor(v1 *big.Int, v2 *big.Int) ([]byte, error) { return _C1.abi.Pack("", v1, v2) } @@ -107,9 +104,6 @@ func NewC2() (*C2, error) { return &C2{abi: *parsed}, nil } -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs func (_C2 *C2) PackConstructor(v1 *big.Int, v2 *big.Int) ([]byte, error) { return _C2.abi.Pack("", v1, v2) } @@ -158,9 +152,6 @@ func NewL1() (*L1, error) { return &L1{abi: *parsed}, nil } -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs func (_L1 *L1) PackConstructor() ([]byte, error) { return _L1.abi.Pack("") } @@ -209,9 +200,6 @@ func NewL2() (*L2, error) { return &L2{abi: *parsed}, nil } -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs func (_L2 *L2) PackConstructor() ([]byte, error) { return _L2.abi.Pack("") } @@ -260,9 +248,6 @@ func NewL2b() (*L2b, error) { return &L2b{abi: *parsed}, nil } -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs func (_L2b *L2b) PackConstructor() ([]byte, error) { return _L2b.abi.Pack("") } @@ -311,9 +296,6 @@ func NewL3() (*L3, error) { return &L3{abi: *parsed}, nil } -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs func (_L3 *L3) PackConstructor() ([]byte, error) { return _L3.abi.Pack("") } @@ -362,9 +344,6 @@ func NewL4() (*L4, error) { return &L4{abi: *parsed}, nil } -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs func (_L4 *L4) PackConstructor() ([]byte, error) { return _L4.abi.Pack("") } @@ -413,9 +392,6 @@ func NewL4b() (*L4b, error) { return &L4b{abi: *parsed}, nil } -// TODO: create custom exported types where unpack would generate a struct return. - -// TODO: test constructor with inputs func (_L4b *L4b) PackConstructor() ([]byte, error) { return _L4b.abi.Pack("") } diff --git a/accounts/abi/bind/testdata/v2/return_structs/bindings.go b/accounts/abi/bind/testdata/v2/return_structs/bindings.go new file mode 100644 index 000000000000..49cec76960fd --- /dev/null +++ b/accounts/abi/bind/testdata/v2/return_structs/bindings.go @@ -0,0 +1,84 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package return_structs + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +var CLibraryDeps = []*bind.MetaData{} + +// 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\":[],\"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\"}]", + Pattern: "55ef3c19a0ab1c1845f9e347540c1e51f5", + Bin: "0x6080604052348015600e575f80fd5b5060fc8061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c80636fd8b96814602a575b5f80fd5b60306047565b604051603e9493929190608b565b60405180910390f35b5f805f805f805f80935093509350935090919293565b5f819050919050565b606d81605d565b82525050565b5f8115159050919050565b6085816073565b82525050565b5f608082019050609c5f8301876066565b60a760208301866066565b60b260408301856066565b60bd6060830184607e565b9594505050505056fea2646970667358221220ca49ad4f133bcee385e1656fc277c9fd6546763a73df384f7d5d0fdd3c4808a564736f6c634300081a0033", +} + +// 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, error) { + return _C.abi.Pack("") +} + +// 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 + +} + diff --git a/accounts/abi/bind/testdata/v2/return_structs/combined-abi.json b/accounts/abi/bind/testdata/v2/return_structs/combined-abi.json new file mode 100644 index 000000000000..8c27f43d42a0 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/return_structs/combined-abi.json @@ -0,0 +1 @@ +{"contracts":{"contract.sol:C":{"abi":[{"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"}],"bin":"6080604052348015600e575f80fd5b5060fc8061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c80636fd8b96814602a575b5f80fd5b60306047565b604051603e9493929190608b565b60405180910390f35b5f805f805f805f80935093509350935090919293565b5f819050919050565b606d81605d565b82525050565b5f8115159050919050565b6085816073565b82525050565b5f608082019050609c5f8301876066565b60a760208301866066565b60b260408301856066565b60bd6060830184607e565b9594505050505056fea2646970667358221220ca49ad4f133bcee385e1656fc277c9fd6546763a73df384f7d5d0fdd3c4808a564736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/testdata/v2/return_structs/contract.sol b/accounts/abi/bind/testdata/v2/return_structs/contract.sol new file mode 100644 index 000000000000..85c517bce06b --- /dev/null +++ b/accounts/abi/bind/testdata/v2/return_structs/contract.sol @@ -0,0 +1,8 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.26; + +contract C { + function DoSomethingWithManyArgs() public pure returns (uint256, uint256, uint256, bool) { + return(uint256(0), uint256(0), uint256(0), false); + } +} \ No newline at end of file From a7e9fbea124a3554f286afd11257cc1612e04fd3 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 28 Nov 2024 18:59:12 +0700 Subject: [PATCH 038/104] add errors to emitted code. --- accounts/abi/bind/bind.go | 47 +++++++++++ accounts/abi/bind/template.go | 6 ++ accounts/abi/bind/testdata/v2/bindings.go | 0 .../abi/bind/testdata/v2/events/bindings.go | 2 +- .../testdata/v2/nested_libraries/bindings.go | 2 +- .../testdata/v2/return_structs/bindings.go | 2 +- .../bind/testdata/v2/solc_errors/bindings.go | 81 +++++++++++++++++++ .../testdata/v2/solc_errors/combined-abi.json | 1 + .../bind/testdata/v2/solc_errors/contract.sol | 15 ++++ accounts/abi/bind/v2/lib.go | 2 +- accounts/abi/bind/v2/lib_test.go | 55 ++++++++++++- 11 files changed, 208 insertions(+), 5 deletions(-) create mode 100644 accounts/abi/bind/testdata/v2/bindings.go create mode 100644 accounts/abi/bind/testdata/v2/solc_errors/bindings.go create mode 100644 accounts/abi/bind/testdata/v2/solc_errors/combined-abi.json create mode 100644 accounts/abi/bind/testdata/v2/solc_errors/contract.sol diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index e4bdf41f1e7c..59b04926e83b 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -189,6 +189,7 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] calls = make(map[string]*tmplMethod) transacts = make(map[string]*tmplMethod) events = make(map[string]*tmplEvent) + errors = make(map[string]*tmplError) fallback *tmplMethod receive *tmplMethod @@ -304,6 +305,51 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] // Append the event to the accumulator list events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} } + for _, original := range evmABI.Errors { + // TODO: I copied this from events. I think it should be correct but not totally sure + // even if it is correct, should consider deduplicating this into its own function. + + // Normalize the event for capital cases and non-anonymous outputs + normalized := original + + // Ensure there is no duplicated identifier + normalizedName := methodNormalizer(alias(aliases, original.Name)) + // Name shouldn't start with a digit. It will make the generated code invalid. + if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { + normalizedName = fmt.Sprintf("E%s", normalizedName) + normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { + _, ok := eventIdentifiers[name] + return ok + }) + } + if eventIdentifiers[normalizedName] { + return nil, fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + } + eventIdentifiers[normalizedName] = true + normalized.Name = normalizedName + + used := make(map[string]bool) + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" || isKeyWord(input.Name) { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + // Event is a bit special, we need to define event struct in binding, + // ensure there is no camel-case-style name conflict. + for index := 0; ; index++ { + if !used[capitalise(normalized.Inputs[j].Name)] { + used[capitalise(normalized.Inputs[j].Name)] = true + break + } + normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index) + } + if hasStruct(input.Type) { + bindStructType(input.Type, structs) + } + } + errors[original.Name] = &tmplError{Original: original, Normalized: normalized} + } // Add two special fallback functions if they exist if evmABI.HasFallback() { fallback = &tmplMethod{Original: evmABI.Fallback} @@ -324,6 +370,7 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] Events: events, Libraries: make(map[string]string), AllLibraries: make(map[string]string), + Errors: errors, } // Function 4-byte signatures are stored in the same sequence diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index 7dce6f955872..7481bf06f656 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -46,6 +46,7 @@ type tmplContract struct { Libraries map[string]string // Same as tmplData, but filtered to only keep direct deps that the contract needs AllLibraries map[string]string // same as Libraries, but all direct/indirect library dependencies Library bool // Indicator whether the contract is a library + Errors map[string]*tmplError } // tmplMethod is a wrapper around an abi.Method that contains a few preprocessed @@ -63,6 +64,11 @@ type tmplEvent struct { Normalized abi.Event // Normalized version of the parsed fields } +type tmplError struct { + Original abi.Error + Normalized abi.Error +} + // tmplField is a wrapper around a struct field with binding language // struct type definition and relative filed name. type tmplField struct { diff --git a/accounts/abi/bind/testdata/v2/bindings.go b/accounts/abi/bind/testdata/v2/bindings.go new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/accounts/abi/bind/testdata/v2/events/bindings.go b/accounts/abi/bind/testdata/v2/events/bindings.go index a2e93d699652..6c8b6cd16b02 100644 --- a/accounts/abi/bind/testdata/v2/events/bindings.go +++ b/accounts/abi/bind/testdata/v2/events/bindings.go @@ -13,7 +13,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" ) -// Reference imports to suppress errors if they are not otherwise used. +// Reference imports to suppress solc_errors if they are not otherwise used. var ( _ = errors.New _ = big.NewInt diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go index 267862d19459..cf5206c2a25c 100644 --- a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go +++ b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go @@ -13,7 +13,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" ) -// Reference imports to suppress errors if they are not otherwise used. +// Reference imports to suppress solc_errors if they are not otherwise used. var ( _ = errors.New _ = big.NewInt diff --git a/accounts/abi/bind/testdata/v2/return_structs/bindings.go b/accounts/abi/bind/testdata/v2/return_structs/bindings.go index 49cec76960fd..959da73e966e 100644 --- a/accounts/abi/bind/testdata/v2/return_structs/bindings.go +++ b/accounts/abi/bind/testdata/v2/return_structs/bindings.go @@ -13,7 +13,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" ) -// Reference imports to suppress errors if they are not otherwise used. +// Reference imports to suppress solc_errors if they are not otherwise used. var ( _ = errors.New _ = big.NewInt diff --git a/accounts/abi/bind/testdata/v2/solc_errors/bindings.go b/accounts/abi/bind/testdata/v2/solc_errors/bindings.go new file mode 100644 index 000000000000..50e01a49a94b --- /dev/null +++ b/accounts/abi/bind/testdata/v2/solc_errors/bindings.go @@ -0,0 +1,81 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package solc_errors + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +var CLibraryDeps = []*bind.MetaData{} + +// 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\":[],\"name\":\"Foo\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "55ef3c19a0ab1c1845f9e347540c1e51f5", + Bin: "0x6080604052348015600e575f80fd5b506101148061001c5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c8063bfb4ebcf14602a575b5f80fd5b60306032565b005b5f600160025f6040517fbb6a82f1000000000000000000000000000000000000000000000000000000008152600401606c949392919060a3565b60405180910390fd5b5f819050919050565b6085816075565b82525050565b5f8115159050919050565b609d81608b565b82525050565b5f60808201905060b45f830187607e565b60bf6020830186607e565b60ca6040830185607e565b60d560608301846096565b9594505050505056fea26469706673582212205ce065ab1cfe16beba2b766e14009fc67ac66c214872149c889f0589720b870a64736f6c634300081a0033", +} + +// 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, error) { + return _C.abi.Pack("") +} + +// 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") +} + +// 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 { + return nil, err + } + return out, nil +} + diff --git a/accounts/abi/bind/testdata/v2/solc_errors/combined-abi.json b/accounts/abi/bind/testdata/v2/solc_errors/combined-abi.json new file mode 100644 index 000000000000..e9f5d2e00f42 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/solc_errors/combined-abi.json @@ -0,0 +1 @@ +{"contracts":{"contract.sol:C":{"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"}],"bin":"6080604052348015600e575f80fd5b506101148061001c5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c8063bfb4ebcf14602a575b5f80fd5b60306032565b005b5f600160025f6040517fbb6a82f1000000000000000000000000000000000000000000000000000000008152600401606c949392919060a3565b60405180910390fd5b5f819050919050565b6085816075565b82525050565b5f8115159050919050565b609d81608b565b82525050565b5f60808201905060b45f830187607e565b60bf6020830186607e565b60ca6040830185607e565b60d560608301846096565b9594505050505056fea26469706673582212205ce065ab1cfe16beba2b766e14009fc67ac66c214872149c889f0589720b870a64736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/testdata/v2/solc_errors/contract.sol b/accounts/abi/bind/testdata/v2/solc_errors/contract.sol new file mode 100644 index 000000000000..aa2218cdc331 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/solc_errors/contract.sol @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.26; + +error BadThing(uint256 arg1, uint256 arg2, uint256 arg3, bool arg4); + +contract C { + function Foo() public pure { + revert BadThing({ + arg1: uint256(0), + arg2: uint256(1), + arg3: uint256(2), + arg4: false + }); + } +} \ No newline at end of file diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 3e677d6ce066..eaef2832ea5c 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -278,7 +278,7 @@ type EventIterator[T any] struct { unpack func(*types.Log) (*T, error) // Unpack function for the event logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination + sub ethereum.Subscription // Subscription for solc_errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index d8b0c5ee42a8..eb6bf6ae09f6 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -25,6 +25,7 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/events" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/nested_libraries" + "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/solc_errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" @@ -98,8 +99,60 @@ func testSetup() (*bind.TransactOpts, *backends.SimulatedBackend, error) { } // test deployment and interaction for a basic contract with no library deps -func TestDeployment(t *testing.T) { +func TestErrors(t *testing.T) { + opts, bindBackend, err := testSetup() + if err != nil { + t.Fatalf("err setting up test: %v", err) + } + defer bindBackend.Backend.Close() + deploymentParams := DeploymentParams{ + Contracts: []ContractDeployParams{ + { + Meta: solc_errors.CMetaData, + }, + }, + } + res, err := LinkAndDeploy(opts, bindBackend, deploymentParams) + if err != nil { + t.Fatalf("err: %+v\n", err) + } + bindBackend.Commit() + + if len(res.Addrs) != 1 { + t.Fatalf("deployment should have generated 1 addresses. got %d", len(res.Addrs)) + } + for _, tx := range res.Txs { + _, err = bind.WaitDeployed(context.Background(), bindBackend, tx) + if err != nil { + t.Fatalf("error deploying library: %+v", err) + } + } + c, err := solc_errors.NewC() + if err != nil { + t.Fatalf("err is %v", err) + } + doInput, err := c.PackFoo() + if err != nil { + t.Fatalf("pack function input err: %v\n", doInput) + } + + cABI, err := nested_libraries.C1MetaData.GetAbi() + if err != nil { + t.Fatalf("error getting abi object: %v", err) + } + contractAddr := res.Addrs[solc_errors.CMetaData.Pattern] + boundC := bind.NewBoundContract(contractAddr, *cABI, bindBackend, bindBackend, bindBackend) + callOpts := &bind.CallOpts{ + From: common.Address{}, + Context: context.Background(), + } + callRes, err := boundC.CallRaw(callOpts, doInput) + if err != nil { + fmt.Println(callRes) + t.Fatalf("err calling contract: %v", err) + } + _ = callRes } // test that deploying a contract with library dependencies works, From 0f398595fed9c13c61e4a5a52fd7371acc459c26 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 2 Dec 2024 11:51:45 +0700 Subject: [PATCH 039/104] add error unpacking. simplify WatchLogs api. --- accounts/abi/bind/source2.go.tpl | 20 +++++++++++ accounts/abi/bind/v2/lib.go | 13 ++----- accounts/abi/bind/v2/lib_test.go | 62 ++++++++++++++++++++------------ 3 files changed, 61 insertions(+), 34 deletions(-) diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index 223b41da47a7..34bf50b8eafa 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -148,4 +148,24 @@ var ( return out, nil } {{end}} + + {{range .Errors}} + // {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} error raised by the {{$contract.Type}} contract. + type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}} + {{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}} + } + + func {{$contract.Type}}{{.Normalized.Name}}ErrorID() common.Hash { + return common.HexToHash("{{.Original.ID}}") + } + + func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Error(raw []byte) (*{{$contract.Type}}{{.Normalized.Name}}, error) { + errName := "{{.Normalized.Name}}" + out := new({{$contract.Type}}{{.Normalized.Name}}) + if err := _{{$contract.Type}}.abi.UnpackIntoInterface(out, errName, raw); err != nil { + return nil, err + } + return out, nil + } + {{end}} {{end}} \ No newline at end of file diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index eaef2832ea5c..9345662a1afe 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -237,7 +237,7 @@ func FilterLogs[T any](instance *ContractInstance, opts *bind.FilterOpts, eventI // contract to be intercepted, unpacked, and forwarded to sink. If // unpack returns an error, the returned subscription is closed with the // error. -func WatchLogs[T any](instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { +func WatchLogs(instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, eventID common.Hash, onLog func(*types.Log) error, topics ...[]any) (event.Subscription, error) { backend := instance.Backend c := bind.NewBoundContract(instance.Address, abi, backend, backend, backend) logs, sub, err := c.WatchLogsForId(opts, eventID, topics...) @@ -249,19 +249,10 @@ func WatchLogs[T any](instance *ContractInstance, abi abi.ABI, opts *bind.WatchO for { select { case log := <-logs: - // New log arrived, parse the event and forward to the user - ev, err := unpack(&log) + err := onLog(&log) if err != nil { return err } - - select { - case sink <- ev: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } case err := <-sub.Err(): return err case <-quit: diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index eb6bf6ae09f6..3d09ac2a21c7 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -381,26 +381,28 @@ func TestEvents(t *testing.T) { backend, } - unpackBasic := func(raw *types.Log) (*events.CBasic1, error) { - return &events.CBasic1{ - Id: (new(big.Int)).SetBytes(raw.Topics[0].Bytes()), - Data: (new(big.Int)).SetBytes(raw.Data), - }, nil - } - unpackBasic2 := func(raw *types.Log) (*events.CBasic2, error) { - return &events.CBasic2{ - Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. - Data: (new(big.Int)).SetBytes(raw.Data), - }, nil - } newCBasic1Ch := make(chan *events.CBasic1) newCBasic2Ch := make(chan *events.CBasic2) watchOpts := &bind.WatchOpts{ Start: nil, Context: context.Background(), } - sub1, err := WatchLogs[events.CBasic1](&boundContract, *abi, watchOpts, events.CBasic1EventID(), unpackBasic, newCBasic1Ch) - sub2, err := WatchLogs[events.CBasic2](&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2, newCBasic2Ch) + sub1, err := WatchLogs(&boundContract, *abi, watchOpts, events.CBasic1EventID(), func(raw *types.Log) error { + event := &events.CBasic1{ + Id: (new(big.Int)).SetBytes(raw.Topics[0].Bytes()), + Data: (new(big.Int)).SetBytes(raw.Data), + } + newCBasic1Ch <- event + return nil + }) + sub2, err := WatchLogs(&boundContract, *abi, watchOpts, events.CBasic2EventID(), func(raw *types.Log) error { + event := &events.CBasic2{ + Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. + Data: (new(big.Int)).SetBytes(raw.Data), + } + newCBasic2Ch <- event + return nil + }) defer sub1.Unsubscribe() defer sub2.Unsubscribe() @@ -452,6 +454,18 @@ done: Start: 0, Context: context.Background(), } + unpackBasic := func(raw *types.Log) (*events.CBasic1, error) { + return &events.CBasic1{ + Id: (new(big.Int)).SetBytes(raw.Topics[0].Bytes()), + Data: (new(big.Int)).SetBytes(raw.Data), + }, nil + } + unpackBasic2 := func(raw *types.Log) (*events.CBasic2, error) { + return &events.CBasic2{ + Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. + Data: (new(big.Int)).SetBytes(raw.Data), + }, nil + } // TODO: test that returning error from unpack prevents event from being received by sink. it, err := FilterLogs[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), unpackBasic) if err != nil { @@ -518,23 +532,25 @@ func TestEventsUnpackFailure(t *testing.T) { backend, } - unpackBasic := func(raw *types.Log) (*events.CBasic1, error) { - return nil, fmt.Errorf("this error should stop the filter that uses this unpack.") + newCBasic1Ch := make(chan *events.CBasic1) + newCBasic2Ch := make(chan *events.CBasic2) + unpackBasic := func(raw *types.Log) error { + return fmt.Errorf("this error should stop the filter that uses this unpack.") } - unpackBasic2 := func(raw *types.Log) (*events.CBasic2, error) { - return &events.CBasic2{ + unpackBasic2 := func(raw *types.Log) error { + newCBasic2Ch <- &events.CBasic2{ Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. Data: (new(big.Int)).SetBytes(raw.Data), - }, nil + } + return nil } - newCBasic1Ch := make(chan *events.CBasic1) - newCBasic2Ch := make(chan *events.CBasic2) + watchOpts := &bind.WatchOpts{ Start: nil, Context: context.Background(), } - sub1, err := WatchLogs[events.CBasic1](&boundContract, *abi, watchOpts, events.CBasic1EventID(), unpackBasic, newCBasic1Ch) - sub2, err := WatchLogs[events.CBasic2](&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2, newCBasic2Ch) + sub1, err := WatchLogs(&boundContract, *abi, watchOpts, events.CBasic1EventID(), unpackBasic) + sub2, err := WatchLogs(&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2) defer sub1.Unsubscribe() defer sub2.Unsubscribe() From 3653585d31bce08ebed424e3999b7952d69d0ba6 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 2 Dec 2024 12:57:09 +0700 Subject: [PATCH 040/104] fix contract filter test. rename *Logs methods to *Events, to reflect the fact that these are specific to solidity events. --- accounts/abi/bind/base.go | 8 ++++++-- accounts/abi/bind/v2/lib.go | 20 +++++++++++--------- accounts/abi/bind/v2/lib_test.go | 24 +++++++++++------------- 3 files changed, 28 insertions(+), 24 deletions(-) diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index a928a46c95f3..a0c4dc3d086d 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -153,8 +153,6 @@ func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend Co } func DeployContractRaw(opts *TransactOpts, bytecode []byte, backend ContractBackend, packedParams []byte) (common.Address, *types.Transaction, *BoundContract, error) { - // TODO: it's weird to instantiate a bound contract (implies existence of contract) in order to deploy a contract - // that doesn't yet exist c := NewBoundContract(common.Address{}, abi.ABI{}, backend, backend, backend) tx, err := c.transact(opts, nil, append(bytecode, packedParams...)) @@ -463,6 +461,12 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i return signedTx, nil } +// FilterLogsByID filters contract logs for past blocks, returning the necessary +// channels to construct a strongly typed bound iterator on top of them. +func (c *BoundContract) FilterLogsByID(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + return c.filterLogs(opts, eventID, query...) +} + // FilterLogs filters contract logs for past blocks, returning the necessary // channels to construct a strongly typed bound iterator on top of them. func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 9345662a1afe..caa6469637be 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -222,22 +222,24 @@ func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deploy return res, nil } -// TODO: adding docs soon (jwasinger) -func FilterLogs[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { +// FilterEvents returns an iterator for filtering events that match the query +// parameters (filter range, eventID, topics). If unpack returns an error, +// the iterator value is not updated, and the iterator is stopped with the +// returned error. +func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { backend := instance.Backend c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) - logs, sub, err := c.FilterLogs(opts, eventID.String(), topics...) + logs, sub, err := c.FilterLogsByID(opts, eventID, topics...) if err != nil { return nil, err } return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil } -// WatchLogs causes logs emitted with a given event id from a specified -// contract to be intercepted, unpacked, and forwarded to sink. If -// unpack returns an error, the returned subscription is closed with the -// error. -func WatchLogs(instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, eventID common.Hash, onLog func(*types.Log) error, topics ...[]any) (event.Subscription, error) { +// WatchEvents causes events emitted from a specified contract to be forwarded to +// onLog if they match the query parameters (matching eventID and topics). If +// onLog returns an error, the returned subscription is cancelled with that error. +func WatchEvents(instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, eventID common.Hash, onLog func(*types.Log) error, topics ...[]any) (event.Subscription, error) { backend := instance.Backend c := bind.NewBoundContract(instance.Address, abi, backend, backend, backend) logs, sub, err := c.WatchLogsForId(opts, eventID, topics...) @@ -262,7 +264,7 @@ func WatchLogs(instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, ev }), nil } -// EventIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for events. +// EventIterator is returned from FilterEvents and is used to iterate over the raw logs and unpacked data for events. type EventIterator[T any] struct { event *T // event containing the contract specifics and raw log diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 3d09ac2a21c7..1424727c6164 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -375,7 +375,6 @@ func TestEvents(t *testing.T) { t.Fatalf("error getting contract abi: %v", err) } - // TODO: why did I introduce separate type, and not just use bound contract? boundContract := ContractInstance{ res.Addrs[events.CMetaData.Pattern], backend, @@ -387,7 +386,7 @@ func TestEvents(t *testing.T) { Start: nil, Context: context.Background(), } - sub1, err := WatchLogs(&boundContract, *abi, watchOpts, events.CBasic1EventID(), func(raw *types.Log) error { + sub1, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic1EventID(), func(raw *types.Log) error { event := &events.CBasic1{ Id: (new(big.Int)).SetBytes(raw.Topics[0].Bytes()), Data: (new(big.Int)).SetBytes(raw.Data), @@ -395,7 +394,7 @@ func TestEvents(t *testing.T) { newCBasic1Ch <- event return nil }) - sub2, err := WatchLogs(&boundContract, *abi, watchOpts, events.CBasic2EventID(), func(raw *types.Log) error { + sub2, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic2EventID(), func(raw *types.Log) error { event := &events.CBasic2{ Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. Data: (new(big.Int)).SetBytes(raw.Data), @@ -448,7 +447,7 @@ done: t.Fatalf("expected event type 2 count to be 1. got %d", e2Count) } - // now, test that we can filter those events that were just caught through the subscription + // now, test that we can filter those same logs after they were included in the chain filterOpts := &bind.FilterOpts{ Start: 0, @@ -466,12 +465,11 @@ done: Data: (new(big.Int)).SetBytes(raw.Data), }, nil } - // TODO: test that returning error from unpack prevents event from being received by sink. - it, err := FilterLogs[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), unpackBasic) + it, err := FilterEvents[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), unpackBasic) if err != nil { t.Fatalf("error filtering logs %v\n", err) } - it2, err := FilterLogs[events.CBasic2](crtctInstance, filterOpts, events.CBasic1EventID(), unpackBasic2) + it2, err := FilterEvents[events.CBasic2](crtctInstance, filterOpts, events.CBasic2EventID(), unpackBasic2) if err != nil { t.Fatalf("error filtering logs %v\n", err) } @@ -483,11 +481,11 @@ done: for it2.Next() { e2Count++ } - if e2Count != 1 { - t.Fatalf("bad") + if e1Count != 2 { + t.Fatalf("expected e1Count of 2 from filter call. got %d", e1Count) } - if e1Count != 1 { - t.Fatalf("bad") + if e2Count != 1 { + t.Fatalf("expected e2Count of 1 from filter call. got %d", e1Count) } } @@ -549,8 +547,8 @@ func TestEventsUnpackFailure(t *testing.T) { Start: nil, Context: context.Background(), } - sub1, err := WatchLogs(&boundContract, *abi, watchOpts, events.CBasic1EventID(), unpackBasic) - sub2, err := WatchLogs(&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2) + sub1, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic1EventID(), unpackBasic) + sub2, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2) defer sub1.Unsubscribe() defer sub2.Unsubscribe() From 1ac716b78f3b0aadf274f5c1f40587f6fe2a88fb Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 2 Dec 2024 14:43:32 +0700 Subject: [PATCH 041/104] delete unused test data. remove useless v2 helper methods. update tests --- accounts/abi/bind/base.go | 17 +- accounts/abi/bind/lib.go | 5 - accounts/abi/bind/testdata/v2/bindings.go | 0 .../testdata/v2/return_structs/bindings.go | 84 ------- .../v2/return_structs/combined-abi.json | 1 - .../testdata/v2/return_structs/contract.sol | 8 - .../abi/bind/testdata/v2/simple/contract.sol | 6 - accounts/abi/bind/v2/lib.go | 141 ----------- accounts/abi/bind/v2/lib_test.go | 237 ++++-------------- 9 files changed, 56 insertions(+), 443 deletions(-) delete mode 100644 accounts/abi/bind/testdata/v2/bindings.go delete mode 100644 accounts/abi/bind/testdata/v2/return_structs/bindings.go delete mode 100644 accounts/abi/bind/testdata/v2/return_structs/combined-abi.json delete mode 100644 accounts/abi/bind/testdata/v2/return_structs/contract.sol delete mode 100644 accounts/abi/bind/testdata/v2/simple/contract.sol diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index a0c4dc3d086d..690766f7b5d9 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -152,6 +152,9 @@ func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend Co return c.address, tx, c, nil } +// DeployContractRaw deploys a contract onto the Ethereum blockchain and binds the +// deployment address with a Go wrapper. It expects its parameters to be abi-encoded +// bytes. func DeployContractRaw(opts *TransactOpts, bytecode []byte, backend ContractBackend, packedParams []byte) (common.Address, *types.Transaction, *BoundContract, error) { c := NewBoundContract(common.Address{}, abi.ABI{}, backend, backend, backend) @@ -402,7 +405,7 @@ func (c *BoundContract) estimateGasLimit(opts *TransactOpts, contract *common.Ad } res, err := c.transactor.EstimateGas(ensureContext(opts.Context), msg) if err != nil { - panic(err) + return 0, err } return res, nil } @@ -463,17 +466,17 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i // FilterLogsByID filters contract logs for past blocks, returning the necessary // channels to construct a strongly typed bound iterator on top of them. -func (c *BoundContract) FilterLogsByID(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { +func (c *BoundContract) FilterLogsByID(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { return c.filterLogs(opts, eventID, query...) } // FilterLogs filters contract logs for past blocks, returning the necessary // channels to construct a strongly typed bound iterator on top of them. -func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { +func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { return c.filterLogs(opts, c.abi.Events[name].ID, query...) } -func (c *BoundContract) filterLogs(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { +func (c *BoundContract) filterLogs(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { // Don't crash on a lazy user if opts == nil { opts = new(FilterOpts) @@ -518,17 +521,17 @@ func (c *BoundContract) filterLogs(opts *FilterOpts, eventID common.Hash, query // WatchLogs filters subscribes to contract logs for future blocks, returning a // subscription object that can be used to tear down the watcher. -func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { +func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { return c.watchLogs(opts, c.abi.Events[name].ID, query...) } // WatchLogsForId filters subscribes to contract logs for future blocks, returning a // subscription object that can be used to tear down the watcher. -func (c *BoundContract) WatchLogsForId(opts *WatchOpts, id common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { +func (c *BoundContract) WatchLogsForId(opts *WatchOpts, id common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { return c.watchLogs(opts, id, query...) } -func (c *BoundContract) watchLogs(opts *WatchOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { +func (c *BoundContract) watchLogs(opts *WatchOpts, eventID common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { // Don't crash on a lazy user if opts == nil { opts = new(WatchOpts) diff --git a/accounts/abi/bind/lib.go b/accounts/abi/bind/lib.go index 3ab6a8aee634..2ffb0dec517d 100644 --- a/accounts/abi/bind/lib.go +++ b/accounts/abi/bind/lib.go @@ -26,8 +26,3 @@ type ContractInstance interface { Address() common.Address Backend() ContractBackend } - -type ContractInstanceV2 interface { - Address() common.Address - Backend() ContractBackend -} diff --git a/accounts/abi/bind/testdata/v2/bindings.go b/accounts/abi/bind/testdata/v2/bindings.go deleted file mode 100644 index e69de29bb2d1..000000000000 diff --git a/accounts/abi/bind/testdata/v2/return_structs/bindings.go b/accounts/abi/bind/testdata/v2/return_structs/bindings.go deleted file mode 100644 index 959da73e966e..000000000000 --- a/accounts/abi/bind/testdata/v2/return_structs/bindings.go +++ /dev/null @@ -1,84 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package return_structs - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress solc_errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -var CLibraryDeps = []*bind.MetaData{} - -// 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\":[],\"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\"}]", - Pattern: "55ef3c19a0ab1c1845f9e347540c1e51f5", - Bin: "0x6080604052348015600e575f80fd5b5060fc8061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c80636fd8b96814602a575b5f80fd5b60306047565b604051603e9493929190608b565b60405180910390f35b5f805f805f805f80935093509350935090919293565b5f819050919050565b606d81605d565b82525050565b5f8115159050919050565b6085816073565b82525050565b5f608082019050609c5f8301876066565b60a760208301866066565b60b260408301856066565b60bd6060830184607e565b9594505050505056fea2646970667358221220ca49ad4f133bcee385e1656fc277c9fd6546763a73df384f7d5d0fdd3c4808a564736f6c634300081a0033", -} - -// 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, error) { - return _C.abi.Pack("") -} - -// 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 - -} - diff --git a/accounts/abi/bind/testdata/v2/return_structs/combined-abi.json b/accounts/abi/bind/testdata/v2/return_structs/combined-abi.json deleted file mode 100644 index 8c27f43d42a0..000000000000 --- a/accounts/abi/bind/testdata/v2/return_structs/combined-abi.json +++ /dev/null @@ -1 +0,0 @@ -{"contracts":{"contract.sol:C":{"abi":[{"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"}],"bin":"6080604052348015600e575f80fd5b5060fc8061001b5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c80636fd8b96814602a575b5f80fd5b60306047565b604051603e9493929190608b565b60405180910390f35b5f805f805f805f80935093509350935090919293565b5f819050919050565b606d81605d565b82525050565b5f8115159050919050565b6085816073565b82525050565b5f608082019050609c5f8301876066565b60a760208301866066565b60b260408301856066565b60bd6060830184607e565b9594505050505056fea2646970667358221220ca49ad4f133bcee385e1656fc277c9fd6546763a73df384f7d5d0fdd3c4808a564736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/testdata/v2/return_structs/contract.sol b/accounts/abi/bind/testdata/v2/return_structs/contract.sol deleted file mode 100644 index 85c517bce06b..000000000000 --- a/accounts/abi/bind/testdata/v2/return_structs/contract.sol +++ /dev/null @@ -1,8 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.26; - -contract C { - function DoSomethingWithManyArgs() public pure returns (uint256, uint256, uint256, bool) { - return(uint256(0), uint256(0), uint256(0), false); - } -} \ No newline at end of file diff --git a/accounts/abi/bind/testdata/v2/simple/contract.sol b/accounts/abi/bind/testdata/v2/simple/contract.sol deleted file mode 100644 index 1e26c0e04dc5..000000000000 --- a/accounts/abi/bind/testdata/v2/simple/contract.sol +++ /dev/null @@ -1,6 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity ^0.8.26; - -contract C { - -} \ No newline at end of file diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index caa6469637be..e2658c235717 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -19,22 +19,13 @@ package v2 import ( "encoding/hex" "fmt" - "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" "regexp" "strings" ) -// TODO: it's weird to have a mirror interface of this in the bind package... -type ContractInstance struct { - Address common.Address - Backend bind.ContractBackend -} - // deployContract deploys a hex-encoded contract with the given constructor // input. It returns the deployment transaction, address on success. func deployContract(backend bind.ContractBackend, auth *bind.TransactOpts, constructor []byte, contract string) (deploymentTx *types.Transaction, deploymentAddr common.Address, err error) { @@ -221,135 +212,3 @@ func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deploy return res, nil } - -// FilterEvents returns an iterator for filtering events that match the query -// parameters (filter range, eventID, topics). If unpack returns an error, -// the iterator value is not updated, and the iterator is stopped with the -// returned error. -func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { - backend := instance.Backend - c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) - logs, sub, err := c.FilterLogsByID(opts, eventID, topics...) - if err != nil { - return nil, err - } - return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil -} - -// WatchEvents causes events emitted from a specified contract to be forwarded to -// onLog if they match the query parameters (matching eventID and topics). If -// onLog returns an error, the returned subscription is cancelled with that error. -func WatchEvents(instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, eventID common.Hash, onLog func(*types.Log) error, topics ...[]any) (event.Subscription, error) { - backend := instance.Backend - c := bind.NewBoundContract(instance.Address, abi, backend, backend, backend) - logs, sub, err := c.WatchLogsForId(opts, eventID, topics...) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - err := onLog(&log) - if err != nil { - return err - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// EventIterator is returned from FilterEvents and is used to iterate over the raw logs and unpacked data for events. -type EventIterator[T any] struct { - event *T // event containing the contract specifics and raw log - - unpack func(*types.Log) (*T, error) // Unpack function for the event - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for solc_errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Value returns the current value of the iterator, or nil if there isn't one. -func (it *EventIterator[T]) Value() *T { - return it.event -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *EventIterator[T]) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - res, err := it.unpack(&log) - if err != nil { - it.fail = err - return false - } - it.event = res - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - res, err := it.unpack(&log) - if err != nil { - it.fail = err - return false - } - it.event = res - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *EventIterator[T]) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *EventIterator[T]) Close() error { - it.sub.Unsubscribe() - return nil -} - -// Transact creates and submits a transaction to the bound contract instance -// using the provided abi-encoded input (or nil). -func Transact(instance *ContractInstance, opts *bind.TransactOpts, input []byte) (*types.Transaction, error) { - var ( - addr = instance.Address - backend = instance.Backend - ) - c := bind.NewBoundContract(addr, abi.ABI{}, backend, backend, backend) - return c.RawTransact(opts, input) -} - -// Call performs an eth_call on the given bound contract instance, using the -// provided abi-encoded input (or nil). -func Call(instance *ContractInstance, opts *bind.CallOpts, input []byte) ([]byte, error) { - backend := instance.Backend - c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) - return c.CallRaw(opts, input) -} diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 1424727c6164..3b78062f5dca 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -25,7 +25,6 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/events" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/nested_libraries" - "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/solc_errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" @@ -98,6 +97,7 @@ func testSetup() (*bind.TransactOpts, *backends.SimulatedBackend, error) { return opts, &bindBackend, nil } +/* // test deployment and interaction for a basic contract with no library deps func TestErrors(t *testing.T) { opts, bindBackend, err := testSetup() @@ -137,26 +137,20 @@ func TestErrors(t *testing.T) { t.Fatalf("pack function input err: %v\n", doInput) } - cABI, err := nested_libraries.C1MetaData.GetAbi() - if err != nil { - t.Fatalf("error getting abi object: %v", err) - } contractAddr := res.Addrs[solc_errors.CMetaData.Pattern] - boundC := bind.NewBoundContract(contractAddr, *cABI, bindBackend, bindBackend, bindBackend) - callOpts := &bind.CallOpts{ - From: common.Address{}, - Context: context.Background(), + contractInstance := &ContractInstance{ + Address: contractAddr, + Backend: bindBackend, } - callRes, err := boundC.CallRaw(callOpts, doInput) + _, err = Transact(contractInstance, opts, doInput) if err != nil { - fmt.Println(callRes) - t.Fatalf("err calling contract: %v", err) + t.Fatalf("err submitting tx: %v", err) } - _ = callRes } +*/ // test that deploying a contract with library dependencies works, -// verifying by calling the deployed contract. +// verifying by calling method on the deployed contract. func TestDeploymentLibraries(t *testing.T) { opts, bindBackend, err := testSetup() if err != nil { @@ -230,6 +224,8 @@ func TestDeploymentLibraries(t *testing.T) { } } +// Same as TestDeployment. However, stagger the deployments with overrides: +// first deploy the library deps and then the contract. func TestDeploymentWithOverrides(t *testing.T) { opts, bindBackend, err := testSetup() if err != nil { @@ -309,12 +305,12 @@ func TestDeploymentWithOverrides(t *testing.T) { t.Fatalf("error getting abi object: %v", err) } contractAddr := res.Addrs[nested_libraries.C1MetaData.Pattern] - boundC := bind.NewBoundContract(contractAddr, *cABI, bindBackend, bindBackend, bindBackend) + boundContract := bind.NewBoundContract(contractAddr, *cABI, bindBackend, bindBackend, bindBackend) callOpts := &bind.CallOpts{ From: common.Address{}, Context: context.Background(), } - callRes, err := boundC.CallRaw(callOpts, doInput) + callRes, err := boundContract.CallRaw(callOpts, doInput) if err != nil { t.Fatalf("err calling contract: %v", err) } @@ -327,19 +323,6 @@ func TestDeploymentWithOverrides(t *testing.T) { } } -/* - * - */ -/* - func TestDeploymentWithOverrides(t *testing.T) { - // more deployment test case ideas: - // 1) deploy libraries, then deploy contract first with libraries as overrides - // 2) deploy contract without library dependencies. - } -*/ - -// note to self: see how to filter logs in eth_call. - func TestEvents(t *testing.T) { // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) txAuth, backend, err := testSetup() @@ -375,48 +358,31 @@ func TestEvents(t *testing.T) { t.Fatalf("error getting contract abi: %v", err) } - boundContract := ContractInstance{ - res.Addrs[events.CMetaData.Pattern], - backend, - } + boundContract := bind.NewBoundContract(res.Addrs[events.CMetaData.Pattern], *abi, backend, backend, backend) - newCBasic1Ch := make(chan *events.CBasic1) - newCBasic2Ch := make(chan *events.CBasic2) watchOpts := &bind.WatchOpts{ Start: nil, Context: context.Background(), } - sub1, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic1EventID(), func(raw *types.Log) error { - event := &events.CBasic1{ - Id: (new(big.Int)).SetBytes(raw.Topics[0].Bytes()), - Data: (new(big.Int)).SetBytes(raw.Data), - } - newCBasic1Ch <- event - return nil - }) - sub2, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic2EventID(), func(raw *types.Log) error { - event := &events.CBasic2{ - Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. - Data: (new(big.Int)).SetBytes(raw.Data), - } - newCBasic2Ch <- event - return nil - }) + chE1, sub1, err := boundContract.WatchLogsForId(watchOpts, events.CBasic1EventID(), nil) + if err != nil { + t.Fatalf("WatchLogsForId with event type 1 failed: %v", err) + } defer sub1.Unsubscribe() - defer sub2.Unsubscribe() - crtctInstance := &ContractInstance{ - Address: res.Addrs[events.CMetaData.Pattern], - Backend: backend, + chE2, sub2, err := boundContract.WatchLogsForId(watchOpts, events.CBasic2EventID(), nil) + if err != nil { + t.Fatalf("WatchLogsForId with event type 2 failed: %v", err) } - _ = ctrct - packedCall, err := ctrct.PackEmitMulti() + defer sub2.Unsubscribe() + + packedCallData, err := ctrct.PackEmitMulti() if err != nil { t.Fatalf("failed to pack EmitMulti arguments") } - tx, err := Transact(crtctInstance, txAuth, packedCall) + tx, err := boundContract.RawTransact(txAuth, packedCallData) if err != nil { - t.Fatalf("failed to send transaction...") + t.Fatalf("failed to submit transaction: %v", err) } backend.Commit() if _, err := bind.WaitMined(context.Background(), backend, tx); err != nil { @@ -428,15 +394,16 @@ func TestEvents(t *testing.T) { e2Count := 0 for { select { - case _ = <-newCBasic1Ch: + case <-timeout.C: + goto done + case err := <-sub1.Err(): + t.Fatalf("received err from sub1: %v", err) + case err := <-sub2.Err(): + t.Fatalf("received err from sub2: %v", err) + case <-chE1: e1Count++ - case _ = <-newCBasic2Ch: + case <-chE2: e2Count++ - case _ = <-timeout.C: - goto done - } - if e1Count == 2 && e2Count == 1 { - break } } done: @@ -453,144 +420,32 @@ done: Start: 0, Context: context.Background(), } - unpackBasic := func(raw *types.Log) (*events.CBasic1, error) { - return &events.CBasic1{ - Id: (new(big.Int)).SetBytes(raw.Topics[0].Bytes()), - Data: (new(big.Int)).SetBytes(raw.Data), - }, nil - } - unpackBasic2 := func(raw *types.Log) (*events.CBasic2, error) { - return &events.CBasic2{ - Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. - Data: (new(big.Int)).SetBytes(raw.Data), - }, nil - } - it, err := FilterEvents[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), unpackBasic) + chE1, sub1, err = boundContract.FilterLogsByID(filterOpts, events.CBasic1EventID(), nil) if err != nil { - t.Fatalf("error filtering logs %v\n", err) + t.Fatalf("failed to filter logs for event type 1: %v", err) } - it2, err := FilterEvents[events.CBasic2](crtctInstance, filterOpts, events.CBasic2EventID(), unpackBasic2) + chE2, sub2, err = boundContract.FilterLogsByID(filterOpts, events.CBasic2EventID(), nil) if err != nil { - t.Fatalf("error filtering logs %v\n", err) + t.Fatalf("failed to filter logs for event type 2: %v", err) } + timeout.Reset(2 * time.Second) e1Count = 0 e2Count = 0 - for it.Next() { - e1Count++ - } - for it2.Next() { - e2Count++ - } - if e1Count != 2 { - t.Fatalf("expected e1Count of 2 from filter call. got %d", e1Count) - } - if e2Count != 1 { - t.Fatalf("expected e2Count of 1 from filter call. got %d", e1Count) - } -} - -func TestEventsUnpackFailure(t *testing.T) { - // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) - txAuth, backend, err := testSetup() - if err != nil { - t.Fatalf("error setting up testing env: %v", err) - } - - deploymentParams := DeploymentParams{ - Contracts: []ContractDeployParams{ - { - Meta: events.CMetaData, - }, - }, - } - - res, err := LinkAndDeploy(txAuth, backend, deploymentParams) - if err != nil { - t.Fatalf("error deploying contract for testing: %v", err) - } - - backend.Commit() - if _, err := bind.WaitDeployed(context.Background(), backend, res.Txs[events.CMetaData.Pattern]); err != nil { - t.Fatalf("WaitDeployed failed %v", err) - } - - ctrct, err := events.NewC() - if err != nil { - t.Fatalf("error instantiating contract instance: %v", err) - } - - abi, err := events.CMetaData.GetAbi() - if err != nil { - t.Fatalf("error getting contract abi: %v", err) - } - - // TODO: why did I introduce separate type, and not just use bound contract? - boundContract := ContractInstance{ - res.Addrs[events.CMetaData.Pattern], - backend, - } - - newCBasic1Ch := make(chan *events.CBasic1) - newCBasic2Ch := make(chan *events.CBasic2) - unpackBasic := func(raw *types.Log) error { - return fmt.Errorf("this error should stop the filter that uses this unpack.") - } - unpackBasic2 := func(raw *types.Log) error { - newCBasic2Ch <- &events.CBasic2{ - Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. - Data: (new(big.Int)).SetBytes(raw.Data), - } - return nil - } - - watchOpts := &bind.WatchOpts{ - Start: nil, - Context: context.Background(), - } - sub1, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic1EventID(), unpackBasic) - sub2, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic2EventID(), unpackBasic2) - defer sub1.Unsubscribe() - defer sub2.Unsubscribe() - - crtctInstance := &ContractInstance{ - Address: res.Addrs[events.CMetaData.Pattern], - Backend: backend, - } - _ = ctrct - packedCall, err := ctrct.PackEmitMulti() - if err != nil { - t.Fatalf("failed to pack EmitMulti arguments") - } - tx, err := Transact(crtctInstance, txAuth, packedCall) - if err != nil { - t.Fatalf("failed to send transaction...") - } - backend.Commit() - if _, err := bind.WaitMined(context.Background(), backend, tx); err != nil { - t.Fatalf("error waiting for tx to be mined: %v", err) - } - - timeout := time.NewTimer(2 * time.Second) - e1Count := 0 - e2Count := 0 for { select { - case _ = <-newCBasic1Ch: + case <-timeout.C: + goto done2 + case <-chE1: e1Count++ - case _ = <-newCBasic2Ch: + case <-chE2: e2Count++ - case _ = <-timeout.C: - goto done - } - if e1Count == 2 && e2Count == 1 { - break } } -done: - if e1Count != 0 { - t.Fatalf("expected event type 1 count to be 0. got %d", e1Count) +done2: + if e1Count != 2 { + t.Fatalf("incorrect results from filter logs: expected event type 1 count to be 2. got %d", e1Count) } if e2Count != 1 { - t.Fatalf("expected event type 2 count to be 1. got %d", e2Count) + t.Fatalf("incorrect results from filter logs: expected event type 2 count to be 1. got %d", e2Count) } } From 8a9fe9941750abf27a456e1fd64b770c781b3fbf Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 2 Dec 2024 14:47:02 +0700 Subject: [PATCH 042/104] remove unused error test, other unused code in tests --- accounts/abi/bind/v2/lib_test.go | 58 -------------------------------- 1 file changed, 58 deletions(-) diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 3b78062f5dca..c2a8fdc3d129 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -34,7 +34,6 @@ import ( "github.com/ethereum/go-ethereum/params" "io" "math/big" - "strings" "testing" "time" ) @@ -63,11 +62,6 @@ func testSetup() (*bind.TransactOpts, *backends.SimulatedBackend, error) { }, ) - _, err := JSON(strings.NewReader(nested_libraries.C1MetaData.ABI)) - if err != nil { - return nil, nil, err - } - signer := types.LatestSigner(params.AllDevChainProtocolChanges) opts := &bind.TransactOpts{ From: testAddr, @@ -97,58 +91,6 @@ func testSetup() (*bind.TransactOpts, *backends.SimulatedBackend, error) { return opts, &bindBackend, nil } -/* -// test deployment and interaction for a basic contract with no library deps -func TestErrors(t *testing.T) { - opts, bindBackend, err := testSetup() - if err != nil { - t.Fatalf("err setting up test: %v", err) - } - defer bindBackend.Backend.Close() - - deploymentParams := DeploymentParams{ - Contracts: []ContractDeployParams{ - { - Meta: solc_errors.CMetaData, - }, - }, - } - res, err := LinkAndDeploy(opts, bindBackend, deploymentParams) - if err != nil { - t.Fatalf("err: %+v\n", err) - } - bindBackend.Commit() - - if len(res.Addrs) != 1 { - t.Fatalf("deployment should have generated 1 addresses. got %d", len(res.Addrs)) - } - for _, tx := range res.Txs { - _, err = bind.WaitDeployed(context.Background(), bindBackend, tx) - if err != nil { - t.Fatalf("error deploying library: %+v", err) - } - } - c, err := solc_errors.NewC() - if err != nil { - t.Fatalf("err is %v", err) - } - doInput, err := c.PackFoo() - if err != nil { - t.Fatalf("pack function input err: %v\n", doInput) - } - - contractAddr := res.Addrs[solc_errors.CMetaData.Pattern] - contractInstance := &ContractInstance{ - Address: contractAddr, - Backend: bindBackend, - } - _, err = Transact(contractInstance, opts, doInput) - if err != nil { - t.Fatalf("err submitting tx: %v", err) - } -} -*/ - // test that deploying a contract with library dependencies works, // verifying by calling method on the deployed contract. func TestDeploymentLibraries(t *testing.T) { From 4507f3c34bf15dc6f8556c707c698baa1ac5e9d7 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 2 Dec 2024 14:58:05 +0700 Subject: [PATCH 043/104] small cleanups --- accounts/abi/bind/base.go | 6 +----- accounts/abi/bind/bind.go | 1 - accounts/abi/bind/lib.go | 28 ---------------------------- 3 files changed, 1 insertion(+), 34 deletions(-) delete mode 100644 accounts/abi/bind/lib.go diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index 690766f7b5d9..2ae92391a3a1 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -403,11 +403,7 @@ func (c *BoundContract) estimateGasLimit(opts *TransactOpts, contract *common.Ad Value: value, Data: input, } - res, err := c.transactor.EstimateGas(ensureContext(opts.Context), msg) - if err != nil { - return 0, err - } - return res, nil + return c.transactor.EstimateGas(ensureContext(opts.Context), msg) } func (c *BoundContract) getNonce(opts *TransactOpts) (uint64, error) { diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 59b04926e83b..ea4ed555403e 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -393,7 +393,6 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] } } } - // Check if that type has already been identified as a library for i := 0; i < len(types); i++ { _, ok := isLib[types[i]] diff --git a/accounts/abi/bind/lib.go b/accounts/abi/bind/lib.go deleted file mode 100644 index 2ffb0dec517d..000000000000 --- a/accounts/abi/bind/lib.go +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright 2023 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package bind - -import ( - "github.com/ethereum/go-ethereum/common" -) - -// ContractInstance provides means to interact with -// a deployed contract. -type ContractInstance interface { - Address() common.Address - Backend() ContractBackend -} From 5cc5898628253430dfc6be33a49d3a1a5c39da82 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 2 Dec 2024 20:27:05 +0700 Subject: [PATCH 044/104] add binding generation test --- .../abi/bind/testdata/v2/events/bindings.go | 3 +- .../testdata/v2/nested_libraries/bindings.go | 3 +- .../bind/testdata/v2/solc_errors/bindings.go | 1 - accounts/abi/bind/v2/lib_test.go | 79 ++++++++++++++++++- 4 files changed, 79 insertions(+), 7 deletions(-) diff --git a/accounts/abi/bind/testdata/v2/events/bindings.go b/accounts/abi/bind/testdata/v2/events/bindings.go index 6c8b6cd16b02..24c5c4da3629 100644 --- a/accounts/abi/bind/testdata/v2/events/bindings.go +++ b/accounts/abi/bind/testdata/v2/events/bindings.go @@ -13,7 +13,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" ) -// Reference imports to suppress solc_errors if they are not otherwise used. +// Reference imports to suppress errors if they are not otherwise used. var ( _ = errors.New _ = big.NewInt @@ -191,4 +191,3 @@ func (_C *C) UnpackBasic2Event(log *types.Log) (*CBasic2, error) { out.Raw = log return out, nil } - diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go index cf5206c2a25c..60c87095eea5 100644 --- a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go +++ b/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go @@ -13,7 +13,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" ) -// Reference imports to suppress solc_errors if they are not otherwise used. +// Reference imports to suppress errors if they are not otherwise used. var ( _ = errors.New _ = big.NewInt @@ -415,4 +415,3 @@ func (_L4b *L4b) UnpackDo(data []byte) (*big.Int, error) { return out0, err } - diff --git a/accounts/abi/bind/testdata/v2/solc_errors/bindings.go b/accounts/abi/bind/testdata/v2/solc_errors/bindings.go index 50e01a49a94b..1af79d97b375 100644 --- a/accounts/abi/bind/testdata/v2/solc_errors/bindings.go +++ b/accounts/abi/bind/testdata/v2/solc_errors/bindings.go @@ -78,4 +78,3 @@ func (_C *C) UnpackBadThingError(raw []byte) (*CBadThing, error) { } return out, nil } - diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index c2a8fdc3d129..fc96d1a811cb 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -25,7 +25,9 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/events" "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/nested_libraries" + "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/compiler" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/ethconfig" @@ -34,6 +36,9 @@ import ( "github.com/ethereum/go-ethereum/params" "io" "math/big" + "os" + "path/filepath" + "strings" "testing" "time" ) @@ -342,9 +347,15 @@ func TestEvents(t *testing.T) { t.Fatalf("received err from sub1: %v", err) case err := <-sub2.Err(): t.Fatalf("received err from sub2: %v", err) - case <-chE1: + case log := <-chE1: + if _, err := ctrct.UnpackBasic1Event(&log); err != nil { + t.Fatalf("failed to unpack basic1 type event: %v", err) + } e1Count++ - case <-chE2: + case log := <-chE2: + if _, err := ctrct.UnpackBasic2Event(&log); err != nil { + t.Fatalf("failed to unpack basic2 type event: %v", err) + } e2Count++ } } @@ -391,3 +402,67 @@ done2: t.Fatalf("incorrect results from filter logs: expected event type 2 count to be 1. got %d", e2Count) } } + +func TestBindingGeneration(t *testing.T) { + matches, _ := filepath.Glob("../testdata/v2/*") + var dirs []string + for _, match := range matches { + f, _ := os.Stat(match) + if f.IsDir() { + fmt.Printf("match %s\n", f.Name()) + dirs = append(dirs, f.Name()) + } + } + + for _, dir := range dirs { + var ( + abis []string + bins []string + types []string + sigs []map[string]string + libs = make(map[string]string) + ) + basePath := filepath.Join("../testdata/v2", dir) + combinedJsonPath := filepath.Join(basePath, "combined-abi.json") + abiBytes, err := os.ReadFile(combinedJsonPath) + if err != nil { + t.Fatalf("error trying to read file %s: %v", combinedJsonPath, err) + } + contracts, err := compiler.ParseCombinedJSON(abiBytes, "", "", "", "") + if err != nil { + t.Fatalf("Failed to read contract information from json output: %v", err) + } + + fmt.Println(dir) + fmt.Printf("number of contracts: %d\n", len(contracts)) + for name, contract := range contracts { + // fully qualified name is of the form : + nameParts := strings.Split(name, ":") + typeName := nameParts[len(nameParts)-1] + abi, err := json.Marshal(contract.Info.AbiDefinition) // Flatten the compiler parse + if err != nil { + utils.Fatalf("Failed to parse ABIs from compiler output: %v", err) + } + abis = append(abis, string(abi)) + bins = append(bins, contract.Code) + sigs = append(sigs, contract.Hashes) + types = append(types, typeName) + + // Derive the library placeholder which is a 34 character prefix of the + // hex encoding of the keccak256 hash of the fully qualified library name. + // Note that the fully qualified library name is the path of its source + // file and the library name separated by ":". + libPattern := crypto.Keccak256Hash([]byte(name)).String()[2:36] // the first 2 chars are 0x + libs[libPattern] = typeName + } + code, err := bind.BindV2(types, abis, bins, sigs, dir, libs, make(map[string]string)) + if err != nil { + t.Fatalf("error creating bindings for package %s: %v", dir, err) + } + + existingBindings, err := os.ReadFile(filepath.Join(basePath, "bindings.go")) + if code != string(existingBindings) { + t.Fatalf("code mismatch for %s", dir) + } + } +} From 4b69e053230e86505c01090961d139210cffecb0 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 3 Dec 2024 13:25:46 +0700 Subject: [PATCH 045/104] add generic log watching/filtering. skip adding generic call/transact (issue with interface regarding contract methods that don't take arguments) --- accounts/abi/bind/base.go | 4 +- accounts/abi/bind/source2.go.tpl | 4 +- .../abi/bind/testdata/v2/events/bindings.go | 8 +- accounts/abi/bind/v2/lib.go | 149 ++++++++++++++++++ accounts/abi/bind/v2/lib_test.go | 94 ++++++----- 5 files changed, 204 insertions(+), 55 deletions(-) diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index 2ae92391a3a1..2380d137c7f9 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -460,9 +460,9 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i return signedTx, nil } -// FilterLogsByID filters contract logs for past blocks, returning the necessary +// FilterLogsById filters contract logs for past blocks, returning the necessary // channels to construct a strongly typed bound iterator on top of them. -func (c *BoundContract) FilterLogsByID(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { +func (c *BoundContract) FilterLogsById(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { return c.filterLogs(opts, eventID, query...) } diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index 34bf50b8eafa..990988bbf18b 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -125,7 +125,9 @@ var ( } func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log *types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { - event := "{{.Normalized.Name}}" + // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. + // and we only need normalized name when dealing with generated go symbols. + event := "{{.Original.Name}}" if log.Topics[0] != _{{$contract.Type}}.abi.Events[event].ID { return nil, errors.New("event signature mismatch") } diff --git a/accounts/abi/bind/testdata/v2/events/bindings.go b/accounts/abi/bind/testdata/v2/events/bindings.go index 24c5c4da3629..c8c3944d95df 100644 --- a/accounts/abi/bind/testdata/v2/events/bindings.go +++ b/accounts/abi/bind/testdata/v2/events/bindings.go @@ -134,7 +134,9 @@ func CBasic1EventID() common.Hash { } func (_C *C) UnpackBasic1Event(log *types.Log) (*CBasic1, error) { - event := "Basic1" + // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. + // and we only need normalized name when dealing with generated go symbols. + event := "basic1" if log.Topics[0] != _C.abi.Events[event].ID { return nil, errors.New("event signature mismatch") } @@ -169,7 +171,9 @@ func CBasic2EventID() common.Hash { } func (_C *C) UnpackBasic2Event(log *types.Log) (*CBasic2, error) { - event := "Basic2" + // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. + // and we only need normalized name when dealing with generated go symbols. + event := "basic2" if log.Topics[0] != _C.abi.Events[event].ID { return nil, errors.New("event signature mismatch") } diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index e2658c235717..1be51fae4e34 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -19,9 +19,12 @@ package v2 import ( "encoding/hex" "fmt" + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" "regexp" "strings" ) @@ -212,3 +215,149 @@ func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deploy return res, nil } + +// TODO: this will be generated as part of the bindings, contain the ABI (or metadata object?) and errors +type ContractInstance struct { + Address common.Address + Backend bind.ContractBackend +} + +// TODO: adding docs soon (jwasinger) +func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { + backend := instance.Backend + c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) + logs, sub, err := c.FilterLogsById(opts, eventID, topics...) + if err != nil { + return nil, err + } + return &EventIterator[T]{unpack: unpack, logs: logs, sub: sub}, nil +} + +// WatchEvents causes logs emitted with a given event id from a specified +// contract to be intercepted, unpacked, and forwarded to sink. If +// unpack returns an error, the returned subscription is closed with the +// error. +func WatchEvents[T any](instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { + backend := instance.Backend + c := bind.NewBoundContract(instance.Address, abi, backend, backend, backend) + logs, sub, err := c.WatchLogsForId(opts, eventID, topics...) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + ev, err := unpack(&log) + if err != nil { + fmt.Printf("unpack err: %v", err) + return err + } + + select { + case sink <- ev: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// EventIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for events. +type EventIterator[T any] struct { + event *T // event containing the contract specifics and raw log + + unpack func(*types.Log) (*T, error) // Unpack function for the event + + logs <-chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for solc_errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Value returns the current value of the iterator, or nil if there isn't one. +func (it *EventIterator[T]) Value() *T { + return it.event +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *EventIterator[T]) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + res, err := it.unpack(&log) + if err != nil { + it.fail = err + return false + } + it.event = res + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + res, err := it.unpack(&log) + if err != nil { + it.fail = err + return false + } + it.event = res + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *EventIterator[T]) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EventIterator[T]) Close() error { + it.sub.Unsubscribe() + return nil +} + +// Transact creates and submits a transaction to the bound contract instance +// using the provided abi-encoded input (or nil). +func Transact(instance *ContractInstance, opts *bind.TransactOpts, packedInput []byte) (*types.Transaction, error) { + var ( + addr = instance.Address + backend = instance.Backend + ) + c := bind.NewBoundContract(addr, abi.ABI{}, backend, backend, backend) + return c.RawTransact(opts, packedInput) +} + +// Call performs an eth_call on the given bound contract instance, using the +// provided abi-encoded input (or nil). +func Call(instance *ContractInstance, opts *bind.CallOpts, packedInput []byte) ([]byte, error) { + backend := instance.Backend + c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) + return c.CallRaw(opts, packedInput) +} diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index fc96d1a811cb..bedd368216fe 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -269,7 +269,6 @@ func TestDeploymentWithOverrides(t *testing.T) { t.Fatalf("expected internal call count of 6. got %d.", internalCallCount.Uint64()) } } - func TestEvents(t *testing.T) { // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) txAuth, backend, err := testSetup() @@ -305,31 +304,30 @@ func TestEvents(t *testing.T) { t.Fatalf("error getting contract abi: %v", err) } - boundContract := bind.NewBoundContract(res.Addrs[events.CMetaData.Pattern], *abi, backend, backend, backend) + boundContract := ContractInstance{ + res.Addrs[events.CMetaData.Pattern], + backend, + } + newCBasic1Ch := make(chan *events.CBasic1) + newCBasic2Ch := make(chan *events.CBasic2) watchOpts := &bind.WatchOpts{ Start: nil, Context: context.Background(), } - chE1, sub1, err := boundContract.WatchLogsForId(watchOpts, events.CBasic1EventID(), nil) - if err != nil { - t.Fatalf("WatchLogsForId with event type 1 failed: %v", err) - } + sub1, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic1EventID(), ctrct.UnpackBasic1Event, newCBasic1Ch) + sub2, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic2EventID(), ctrct.UnpackBasic2Event, newCBasic2Ch) defer sub1.Unsubscribe() - - chE2, sub2, err := boundContract.WatchLogsForId(watchOpts, events.CBasic2EventID(), nil) - if err != nil { - t.Fatalf("WatchLogsForId with event type 2 failed: %v", err) - } defer sub2.Unsubscribe() - packedCallData, err := ctrct.PackEmitMulti() - if err != nil { - t.Fatalf("failed to pack EmitMulti arguments") + crtctInstance := &ContractInstance{ + Address: res.Addrs[events.CMetaData.Pattern], + Backend: backend, } - tx, err := boundContract.RawTransact(txAuth, packedCallData) + packedInput, _ := ctrct.PackEmitMulti() + tx, err := Transact(crtctInstance, txAuth, packedInput) if err != nil { - t.Fatalf("failed to submit transaction: %v", err) + t.Fatalf("failed to send transaction: %v", err) } backend.Commit() if _, err := bind.WaitMined(context.Background(), backend, tx); err != nil { @@ -341,22 +339,15 @@ func TestEvents(t *testing.T) { e2Count := 0 for { select { - case <-timeout.C: - goto done - case err := <-sub1.Err(): - t.Fatalf("received err from sub1: %v", err) - case err := <-sub2.Err(): - t.Fatalf("received err from sub2: %v", err) - case log := <-chE1: - if _, err := ctrct.UnpackBasic1Event(&log); err != nil { - t.Fatalf("failed to unpack basic1 type event: %v", err) - } + case _ = <-newCBasic1Ch: e1Count++ - case log := <-chE2: - if _, err := ctrct.UnpackBasic2Event(&log); err != nil { - t.Fatalf("failed to unpack basic2 type event: %v", err) - } + case _ = <-newCBasic2Ch: e2Count++ + case _ = <-timeout.C: + goto done + } + if e1Count == 2 && e2Count == 1 { + break } } done: @@ -373,33 +364,39 @@ done: Start: 0, Context: context.Background(), } - chE1, sub1, err = boundContract.FilterLogsByID(filterOpts, events.CBasic1EventID(), nil) + unpackBasic := func(raw *types.Log) (*events.CBasic1, error) { + return &events.CBasic1{ + Id: (new(big.Int)).SetBytes(raw.Topics[0].Bytes()), + Data: (new(big.Int)).SetBytes(raw.Data), + }, nil + } + unpackBasic2 := func(raw *types.Log) (*events.CBasic2, error) { + return &events.CBasic2{ + Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. + Data: (new(big.Int)).SetBytes(raw.Data), + }, nil + } + it, err := FilterEvents[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), unpackBasic) if err != nil { - t.Fatalf("failed to filter logs for event type 1: %v", err) + t.Fatalf("error filtering logs %v\n", err) } - chE2, sub2, err = boundContract.FilterLogsByID(filterOpts, events.CBasic2EventID(), nil) + it2, err := FilterEvents[events.CBasic2](crtctInstance, filterOpts, events.CBasic2EventID(), unpackBasic2) if err != nil { - t.Fatalf("failed to filter logs for event type 2: %v", err) + t.Fatalf("error filtering logs %v\n", err) } - timeout.Reset(2 * time.Second) e1Count = 0 e2Count = 0 - for { - select { - case <-timeout.C: - goto done2 - case <-chE1: - e1Count++ - case <-chE2: - e2Count++ - } + for it.Next() { + e1Count++ + } + for it2.Next() { + e2Count++ } -done2: if e1Count != 2 { - t.Fatalf("incorrect results from filter logs: expected event type 1 count to be 2. got %d", e1Count) + t.Fatalf("expected e1Count of 2 from filter call. got %d", e1Count) } if e2Count != 1 { - t.Fatalf("incorrect results from filter logs: expected event type 2 count to be 1. got %d", e2Count) + t.Fatalf("expected e2Count of 1 from filter call. got %d", e1Count) } } @@ -409,7 +406,6 @@ func TestBindingGeneration(t *testing.T) { for _, match := range matches { f, _ := os.Stat(match) if f.IsDir() { - fmt.Printf("match %s\n", f.Name()) dirs = append(dirs, f.Name()) } } @@ -433,8 +429,6 @@ func TestBindingGeneration(t *testing.T) { t.Fatalf("Failed to read contract information from json output: %v", err) } - fmt.Println(dir) - fmt.Printf("number of contracts: %d\n", len(contracts)) for name, contract := range contracts { // fully qualified name is of the form : nameParts := strings.Split(name, ":") From 0c66c0254f20a8e23a58ba426cb1a75970f800bc Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 3 Dec 2024 13:49:24 +0700 Subject: [PATCH 046/104] add generic call/transact --- accounts/abi/bind/v2/lib.go | 12 ++++++++---- accounts/abi/bind/v2/lib_test.go | 14 +++++--------- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 1be51fae4e34..3ae5b4283ee1 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -345,19 +345,23 @@ func (it *EventIterator[T]) Close() error { // Transact creates and submits a transaction to the bound contract instance // using the provided abi-encoded input (or nil). -func Transact(instance *ContractInstance, opts *bind.TransactOpts, packedInput []byte) (*types.Transaction, error) { +func Transact(instance *ContractInstance, opts *bind.TransactOpts, input []byte) (*types.Transaction, error) { var ( addr = instance.Address backend = instance.Backend ) c := bind.NewBoundContract(addr, abi.ABI{}, backend, backend, backend) - return c.RawTransact(opts, packedInput) + return c.RawTransact(opts, input) } // Call performs an eth_call on the given bound contract instance, using the // provided abi-encoded input (or nil). -func Call(instance *ContractInstance, opts *bind.CallOpts, packedInput []byte) ([]byte, error) { +func Call[T any](instance *ContractInstance, opts *bind.CallOpts, packedInput []byte, unpack func([]byte) (*T, error)) (*T, error) { backend := instance.Backend c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) - return c.CallRaw(opts, packedInput) + packedOutput, err := c.CallRaw(opts, packedInput) + if err != nil { + return nil, err + } + return unpack(packedOutput) } diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index bedd368216fe..a7e548e5b994 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -148,21 +148,17 @@ func TestDeploymentLibraries(t *testing.T) { t.Fatalf("pack function input err: %v\n", doInput) } - cABI, err := nested_libraries.C1MetaData.GetAbi() - if err != nil { - t.Fatalf("error getting abi object: %v", err) - } contractAddr := res.Addrs[nested_libraries.C1MetaData.Pattern] - boundC := bind.NewBoundContract(contractAddr, *cABI, bindBackend, bindBackend, bindBackend) callOpts := &bind.CallOpts{ From: common.Address{}, Context: context.Background(), } - callRes, err := boundC.CallRaw(callOpts, doInput) - if err != nil { - t.Fatalf("err calling contract: %v", err) + + ctrctInstance := &ContractInstance{ + Address: contractAddr, + Backend: bindBackend, } - internalCallCount, err := c.UnpackDo(callRes) + internalCallCount, err := Call[big.Int](ctrctInstance, callOpts, doInput, ctrct.UnpackDo) if err != nil { t.Fatalf("err unpacking result: %v", err) } From 97b457606e65c5e54e1448537ff041c32e90d35a Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 3 Dec 2024 15:04:25 +0700 Subject: [PATCH 047/104] add db example from sina --- accounts/abi/bind/testdata/v2/db/bindings.go | 252 ++++++++++++++++++ .../abi/bind/testdata/v2/db/combined-abi.json | 1 + accounts/abi/bind/testdata/v2/db/contract.sol | 66 +++++ 3 files changed, 319 insertions(+) create mode 100644 accounts/abi/bind/testdata/v2/db/bindings.go create mode 100644 accounts/abi/bind/testdata/v2/db/combined-abi.json create mode 100644 accounts/abi/bind/testdata/v2/db/contract.sol diff --git a/accounts/abi/bind/testdata/v2/db/bindings.go b/accounts/abi/bind/testdata/v2/db/bindings.go new file mode 100644 index 000000000000..c288910584bd --- /dev/null +++ b/accounts/abi/bind/testdata/v2/db/bindings.go @@ -0,0 +1,252 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package db + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = 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 +} + +var DBLibraryDeps = []*bind.MetaData{} + +// 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, error) { + return _DB.abi.Pack("") +} + +// 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 +} + +func DBInsertEventID() common.Hash { + return common.HexToHash("0x8b39ff47dca36ab5b8b80845238af53aa579625ac7fb173dc09376adada41769") +} + +func (_DB *DB) UnpackInsertEvent(log *types.Log) (*DBInsert, error) { + // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. + // and we only need normalized name when dealing with generated go symbols. + 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 +} + +func DBKeyedInsertEventID() common.Hash { + return common.HexToHash("0x40bed843c6c5f72002f9b469cf4c1ee9f7fb1eb48f091c1267970f98522ac02d") +} + +func (_DB *DB) UnpackKeyedInsertEvent(log *types.Log) (*DBKeyedInsert, error) { + // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. + // and we only need normalized name when dealing with generated go symbols. + 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/testdata/v2/db/combined-abi.json b/accounts/abi/bind/testdata/v2/db/combined-abi.json new file mode 100644 index 000000000000..62ad2562a53f --- /dev/null +++ b/accounts/abi/bind/testdata/v2/db/combined-abi.json @@ -0,0 +1 @@ +{"contracts":{"contract.sol:DB":{"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":"struct DB.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"}],"bin":"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"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/testdata/v2/db/contract.sol b/accounts/abi/bind/testdata/v2/db/contract.sol new file mode 100644 index 000000000000..f24aa8d38183 --- /dev/null +++ b/accounts/abi/bind/testdata/v2/db/contract.sol @@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-3.0 +pragma solidity >=0.7.0 <0.9.0; + +contract DB { + uint balance = 0; + mapping(uint => uint) private _store; + uint[] private _keys; + struct Stats { + uint gets; + uint inserts; + uint mods; // modifications + } + Stats _stats; + + event KeyedInsert(uint indexed key, uint value); + event Insert(uint key, uint value, uint length); + + constructor() { + _stats = Stats(0, 0, 0); + } + + // insert adds a key value to the store, returning the new length of the store. + function insert(uint k, uint v) external returns (uint) { + // No need to store 0 values + if (v == 0) { + return _keys.length; + } + // Check if a key is being overriden + if (_store[k] == 0) { + _keys.push(k); + _stats.inserts++; + } else { + _stats.mods++; + } + _store[k] = v; + emit Insert(k, v, _keys.length); + emit KeyedInsert(k, v); + + return _keys.length; + } + + function get(uint k) public returns (uint) { + _stats.gets++; + return _store[k]; + } + + function getStatParams() public view returns (uint, uint, uint) { + return (_stats.gets, _stats.inserts, _stats.mods); + } + + function getNamedStatParams() public view returns (uint gets, uint inserts, uint mods) { + return (_stats.gets, _stats.inserts, _stats.mods); + } + + function getStatsStruct() public view returns (Stats memory) { + return _stats; + } + + receive() external payable { + balance += msg.value; + } + + fallback(bytes calldata _input) external returns (bytes memory _output) { + _output = _input; + } +} \ No newline at end of file From fec62d26eef5d33f0a4f7ab3dd86d8c557becf62 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 3 Dec 2024 15:18:24 +0700 Subject: [PATCH 048/104] remove unecessary abi parameter from WatchEvents. simplify event tests --- accounts/abi/bind/v2/lib.go | 4 ++-- accounts/abi/bind/v2/lib_test.go | 25 ++++--------------------- 2 files changed, 6 insertions(+), 23 deletions(-) diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 3ae5b4283ee1..3557818dec46 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -237,9 +237,9 @@ func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, even // contract to be intercepted, unpacked, and forwarded to sink. If // unpack returns an error, the returned subscription is closed with the // error. -func WatchEvents[T any](instance *ContractInstance, abi abi.ABI, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { +func WatchEvents[T any](instance *ContractInstance, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { backend := instance.Backend - c := bind.NewBoundContract(instance.Address, abi, backend, backend, backend) + c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) logs, sub, err := c.WatchLogsForId(opts, eventID, topics...) if err != nil { return nil, err diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index a7e548e5b994..86101e3a64c8 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -295,11 +295,6 @@ func TestEvents(t *testing.T) { t.Fatalf("error instantiating contract instance: %v", err) } - abi, err := events.CMetaData.GetAbi() - if err != nil { - t.Fatalf("error getting contract abi: %v", err) - } - boundContract := ContractInstance{ res.Addrs[events.CMetaData.Pattern], backend, @@ -311,8 +306,8 @@ func TestEvents(t *testing.T) { Start: nil, Context: context.Background(), } - sub1, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic1EventID(), ctrct.UnpackBasic1Event, newCBasic1Ch) - sub2, err := WatchEvents(&boundContract, *abi, watchOpts, events.CBasic2EventID(), ctrct.UnpackBasic2Event, newCBasic2Ch) + sub1, err := WatchEvents(&boundContract, watchOpts, events.CBasic1EventID(), ctrct.UnpackBasic1Event, newCBasic1Ch) + sub2, err := WatchEvents(&boundContract, watchOpts, events.CBasic2EventID(), ctrct.UnpackBasic2Event, newCBasic2Ch) defer sub1.Unsubscribe() defer sub2.Unsubscribe() @@ -360,23 +355,11 @@ done: Start: 0, Context: context.Background(), } - unpackBasic := func(raw *types.Log) (*events.CBasic1, error) { - return &events.CBasic1{ - Id: (new(big.Int)).SetBytes(raw.Topics[0].Bytes()), - Data: (new(big.Int)).SetBytes(raw.Data), - }, nil - } - unpackBasic2 := func(raw *types.Log) (*events.CBasic2, error) { - return &events.CBasic2{ - Flag: false, // TODO: how to unpack different types to go types? this should be exposed via abi package. - Data: (new(big.Int)).SetBytes(raw.Data), - }, nil - } - it, err := FilterEvents[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), unpackBasic) + it, err := FilterEvents[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), ctrct.UnpackBasic1Event) if err != nil { t.Fatalf("error filtering logs %v\n", err) } - it2, err := FilterEvents[events.CBasic2](crtctInstance, filterOpts, events.CBasic2EventID(), unpackBasic2) + it2, err := FilterEvents[events.CBasic2](crtctInstance, filterOpts, events.CBasic2EventID(), ctrct.UnpackBasic2Event) if err != nil { t.Fatalf("error filtering logs %v\n", err) } From b90cf25e43ce13ea2d456ba0dd6ae39325d883dc Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 3 Dec 2024 16:04:05 +0700 Subject: [PATCH 049/104] mv test contracts to internal directory under v2 --- .../abi/bind/{testdata/v2 => v2/internal}/db/bindings.go | 0 .../{testdata/v2 => v2/internal}/db/combined-abi.json | 0 .../abi/bind/{testdata/v2 => v2/internal}/db/contract.sol | 0 .../bind/{testdata/v2 => v2/internal}/events/bindings.go | 0 .../{testdata/v2 => v2/internal}/events/combined-abi.json | 0 .../bind/{testdata/v2 => v2/internal}/events/contract.sol | 0 .../v2 => v2/internal}/nested_libraries/abi.json | 0 .../v2 => v2/internal}/nested_libraries/bindings.go | 0 .../v2 => v2/internal}/nested_libraries/combined-abi.json | 0 .../v2 => v2/internal}/nested_libraries/contract.sol | 0 .../{testdata/v2 => v2/internal}/solc_errors/bindings.go | 0 .../v2 => v2/internal}/solc_errors/combined-abi.json | 0 .../{testdata/v2 => v2/internal}/solc_errors/contract.sol | 0 accounts/abi/bind/v2/lib_test.go | 8 ++++---- 14 files changed, 4 insertions(+), 4 deletions(-) rename accounts/abi/bind/{testdata/v2 => v2/internal}/db/bindings.go (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/db/combined-abi.json (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/db/contract.sol (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/events/bindings.go (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/events/combined-abi.json (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/events/contract.sol (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/nested_libraries/abi.json (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/nested_libraries/bindings.go (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/nested_libraries/combined-abi.json (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/nested_libraries/contract.sol (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/solc_errors/bindings.go (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/solc_errors/combined-abi.json (100%) rename accounts/abi/bind/{testdata/v2 => v2/internal}/solc_errors/contract.sol (100%) diff --git a/accounts/abi/bind/testdata/v2/db/bindings.go b/accounts/abi/bind/v2/internal/db/bindings.go similarity index 100% rename from accounts/abi/bind/testdata/v2/db/bindings.go rename to accounts/abi/bind/v2/internal/db/bindings.go diff --git a/accounts/abi/bind/testdata/v2/db/combined-abi.json b/accounts/abi/bind/v2/internal/db/combined-abi.json similarity index 100% rename from accounts/abi/bind/testdata/v2/db/combined-abi.json rename to accounts/abi/bind/v2/internal/db/combined-abi.json diff --git a/accounts/abi/bind/testdata/v2/db/contract.sol b/accounts/abi/bind/v2/internal/db/contract.sol similarity index 100% rename from accounts/abi/bind/testdata/v2/db/contract.sol rename to accounts/abi/bind/v2/internal/db/contract.sol diff --git a/accounts/abi/bind/testdata/v2/events/bindings.go b/accounts/abi/bind/v2/internal/events/bindings.go similarity index 100% rename from accounts/abi/bind/testdata/v2/events/bindings.go rename to accounts/abi/bind/v2/internal/events/bindings.go diff --git a/accounts/abi/bind/testdata/v2/events/combined-abi.json b/accounts/abi/bind/v2/internal/events/combined-abi.json similarity index 100% rename from accounts/abi/bind/testdata/v2/events/combined-abi.json rename to accounts/abi/bind/v2/internal/events/combined-abi.json diff --git a/accounts/abi/bind/testdata/v2/events/contract.sol b/accounts/abi/bind/v2/internal/events/contract.sol similarity index 100% rename from accounts/abi/bind/testdata/v2/events/contract.sol rename to accounts/abi/bind/v2/internal/events/contract.sol diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/abi.json b/accounts/abi/bind/v2/internal/nested_libraries/abi.json similarity index 100% rename from accounts/abi/bind/testdata/v2/nested_libraries/abi.json rename to accounts/abi/bind/v2/internal/nested_libraries/abi.json diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/bindings.go b/accounts/abi/bind/v2/internal/nested_libraries/bindings.go similarity index 100% rename from accounts/abi/bind/testdata/v2/nested_libraries/bindings.go rename to accounts/abi/bind/v2/internal/nested_libraries/bindings.go diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/combined-abi.json b/accounts/abi/bind/v2/internal/nested_libraries/combined-abi.json similarity index 100% rename from accounts/abi/bind/testdata/v2/nested_libraries/combined-abi.json rename to accounts/abi/bind/v2/internal/nested_libraries/combined-abi.json diff --git a/accounts/abi/bind/testdata/v2/nested_libraries/contract.sol b/accounts/abi/bind/v2/internal/nested_libraries/contract.sol similarity index 100% rename from accounts/abi/bind/testdata/v2/nested_libraries/contract.sol rename to accounts/abi/bind/v2/internal/nested_libraries/contract.sol diff --git a/accounts/abi/bind/testdata/v2/solc_errors/bindings.go b/accounts/abi/bind/v2/internal/solc_errors/bindings.go similarity index 100% rename from accounts/abi/bind/testdata/v2/solc_errors/bindings.go rename to accounts/abi/bind/v2/internal/solc_errors/bindings.go diff --git a/accounts/abi/bind/testdata/v2/solc_errors/combined-abi.json b/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json similarity index 100% rename from accounts/abi/bind/testdata/v2/solc_errors/combined-abi.json rename to accounts/abi/bind/v2/internal/solc_errors/combined-abi.json diff --git a/accounts/abi/bind/testdata/v2/solc_errors/contract.sol b/accounts/abi/bind/v2/internal/solc_errors/contract.sol similarity index 100% rename from accounts/abi/bind/testdata/v2/solc_errors/contract.sol rename to accounts/abi/bind/v2/internal/solc_errors/contract.sol diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 86101e3a64c8..90869f603f0a 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -23,8 +23,8 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" - "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/events" - "github.com/ethereum/go-ethereum/accounts/abi/bind/testdata/v2/nested_libraries" + "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/events" + "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/nested_libraries" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/compiler" @@ -380,7 +380,7 @@ done: } func TestBindingGeneration(t *testing.T) { - matches, _ := filepath.Glob("../testdata/v2/*") + matches, _ := filepath.Glob("internal/*") var dirs []string for _, match := range matches { f, _ := os.Stat(match) @@ -397,7 +397,7 @@ func TestBindingGeneration(t *testing.T) { sigs []map[string]string libs = make(map[string]string) ) - basePath := filepath.Join("../testdata/v2", dir) + basePath := filepath.Join("internal", dir) combinedJsonPath := filepath.Join(basePath, "combined-abi.json") abiBytes, err := os.ReadFile(combinedJsonPath) if err != nil { From b2e27befad8e50ca89aed0c60a19e13cc6a4e17a Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 5 Dec 2024 17:32:24 +0700 Subject: [PATCH 050/104] staging changes for linking tests. rework LinkAndDeploy to decouple logic of contract deployment, by passing a callback that does it. --- accounts/abi/bind/contract_linking_test.go | 98 ++++++++++++++++++++++ accounts/abi/bind/v2/lib.go | 27 +++--- accounts/abi/bind/v2/lib_test.go | 16 +++- 3 files changed, 125 insertions(+), 16 deletions(-) create mode 100644 accounts/abi/bind/contract_linking_test.go diff --git a/accounts/abi/bind/contract_linking_test.go b/accounts/abi/bind/contract_linking_test.go new file mode 100644 index 000000000000..5f82d813cc1d --- /dev/null +++ b/accounts/abi/bind/contract_linking_test.go @@ -0,0 +1,98 @@ +package bind + +import ( + v2 "github.com/ethereum/go-ethereum/accounts/abi/bind/v2" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "strings" + "testing" +) + +type linkTestCase struct { + // map of a library to the order in which its dependencies appear in the EVM bytecode. + codes map[string]string +} + +func makeLinkTestCase(input map[rune][]rune) *linkTestCase { + codes := make(map[string]string) + inputMap := make(map[rune]map[rune]struct{}) + + for contract, deps := range input { + inputMap[contract] = make(map[rune]struct{}) + for _, dep := range deps { + codes[string(contract)] = codes[string(contract)] + string(dep) + inputMap[contract][dep] = struct{}{} + } + } + return &linkTestCase{ + generateUnlinkedContracts(codes), + } +} + +func generateUnlinkedContracts(inputCodes map[string]string) map[string]string { + // map of solidity library pattern to unlinked code + codes := make(map[string]string) + + for name, code := range inputCodes { + var prelinkCode []string + for _, char := range code { + prelinkCode = append(prelinkCode, crypto.Keccak256Hash([]byte(string(char))).String()[2:36]) + } + pattern := crypto.Keccak256Hash([]byte(string(name))).String()[2:36] + codes[pattern] = strings.Join(prelinkCode, "") + } + return codes +} + +var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + +func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]common.Address) { + testAddr := crypto.PubkeyToAddress(testKey.PublicKey) + var testAddrNonce uint64 + + tc := makeLinkTestCase(input) + alreadyDeployed := make(map[common.Address]struct{}) + // TODO: include in link test case: set of contracts that we expect to be deployed at the end. + // generate this in makeLinkTestCase + // ^ overrides are not included in this case. + mockDeploy := func(input []byte, deployer []byte) (common.Address, *types.Transaction, error) { + contractAddr := crypto.CreateAddress(testAddr, testAddrNonce) + testAddrNonce++ + + // assert that this contract only references libs that are known to be deployed or in the override set + for i := 0; i < len(deployer)/20; i += 20 { + var dep common.Address + dep.SetBytes(deployer[i : i+20]) + if _, ok := alreadyDeployed[dep]; !ok { + t.Fatalf("reference to dependent contract that has not yet been deployed.") + } + } + alreadyDeployed[contractAddr] = struct{}{} + // we don't care about the txs themselves for the sake of the linking tests. so we can return nil for them in the mock deployer + return contractAddr, nil, nil + } + doTest := func() { + // convert the raw test case into working form + + deployParams := v2.DeploymentParams{ + Contracts: nil, + Libraries: nil, + Overrides: nil, + } + res, err := v2.LinkAndDeploy(deployParams, mockDeploy) + if err != nil { + t.Fatalf("got error from LinkAndDeploy: %v\n", err) + } + + // assert that res contains everything we expected to be deployed + } +} + +func TestContractLinking(t *testing.T) { + + //test-case specific values (TODO: move these, mockDeploy, doTest into their own routines). + + // input: a cycle of dependencies. + // expected: [{set of deps deployed first}, {set of deps deployed second}, ..., {contract(s) deployed}] +} diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 3557818dec46..84a03c028379 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -31,32 +31,31 @@ import ( // deployContract deploys a hex-encoded contract with the given constructor // input. It returns the deployment transaction, address on success. -func deployContract(backend bind.ContractBackend, auth *bind.TransactOpts, constructor []byte, contract string) (deploymentTx *types.Transaction, deploymentAddr common.Address, err error) { +func deployContract(constructor []byte, contract string, deploy func(input, deployer []byte) (common.Address, *types.Transaction, error)) (deploymentAddr common.Address, deploymentTx *types.Transaction, err error) { contractBinBytes, err := hex.DecodeString(contract[2:]) if err != nil { - return nil, common.Address{}, fmt.Errorf("contract bytecode is not a hex string: %s", contractBinBytes[2:]) + return common.Address{}, nil, fmt.Errorf("contract bytecode is not a hex string: %s", contractBinBytes[2:]) } - addr, tx, _, err := bind.DeployContractRaw(auth, contractBinBytes, backend, constructor) + addr, tx, err := deploy(constructor, contractBinBytes) if err != nil { - return nil, common.Address{}, fmt.Errorf("failed to deploy contract: %v", err) + return common.Address{}, nil, fmt.Errorf("failed to deploy contract: %v", err) } - return tx, addr, nil + return addr, tx, nil } // deployLibs iterates the set contracts (map of pattern to hex-encoded // contract deployer code). Each contract is deployed, and the // resulting addresses/deployment-txs are returned on success. -func deployLibs(backend bind.ContractBackend, auth *bind.TransactOpts, contracts map[string]string) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[string]common.Address, err error) { +func deployLibs(contracts map[string]string, deploy func(input, deployer []byte) (common.Address, *types.Transaction, error)) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[string]common.Address, err error) { deploymentTxs = make(map[common.Address]*types.Transaction) deployAddrs = make(map[string]common.Address) for pattern, contractBin := range contracts { - contractBinBytes, err := hex.DecodeString(contractBin[2:]) + contractDeployer, err := hex.DecodeString(contractBin[2:]) if err != nil { return deploymentTxs, deployAddrs, fmt.Errorf("contract bytecode is not a hex string: %s", contractBin[2:]) } - // TODO: can pass nil for constructor? - addr, tx, _, err := bind.DeployContractRaw(auth, contractBinBytes, backend, []byte{}) + addr, tx, err := deploy([]byte{}, contractDeployer) if err != nil { return deploymentTxs, deployAddrs, fmt.Errorf("failed to deploy contract: %v", err) } @@ -155,10 +154,14 @@ type DeploymentResult struct { Addrs map[string]common.Address } +type ContractDeployer interface { + DeployContract(input []byte, deployer []byte) (common.Address, *types.Transaction, error) +} + // LinkAndDeploy deploys a specified set of contracts and their dependent // libraries. If an error occurs, only contracts which were successfully // deployed are returned in the result. -func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deployParams DeploymentParams) (res *DeploymentResult, err error) { +func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer []byte) (common.Address, *types.Transaction, error)) (res *DeploymentResult, err error) { libMetas := deployParams.Libraries overrides := deployParams.Overrides @@ -188,7 +191,7 @@ func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deploy if len(deployableDeps) == 0 { break } - deployTxs, deployAddrs, err := deployLibs(backend, auth, deployableDeps) + deployTxs, deployAddrs, err := deployLibs(deployableDeps, deploy) for pattern, addr := range deployAddrs { deployed[pattern] = addr res.Addrs[pattern] = addr @@ -205,7 +208,7 @@ func LinkAndDeploy(auth *bind.TransactOpts, backend bind.ContractBackend, deploy if err != nil { return res, err } - contractTx, contractAddr, err := deployContract(backend, auth, contractParams.Input, linkedContract) + contractAddr, contractTx, err := deployContract(contractParams.Input, linkedContract, deploy) if err != nil { return res, err } diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 90869f603f0a..f621762ccf8f 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -96,6 +96,13 @@ func testSetup() (*bind.TransactOpts, *backends.SimulatedBackend, error) { return opts, &bindBackend, nil } +func makeTestDeployer(auth *bind.TransactOpts, backend bind.ContractBackend) func(input, deployer []byte) (common.Address, *types.Transaction, error) { + return func(input, deployer []byte) (common.Address, *types.Transaction, error) { + addr, tx, _, err := bind.DeployContractRaw(auth, deployer, backend, input) + return addr, tx, err + } +} + // test that deploying a contract with library dependencies works, // verifying by calling method on the deployed contract. func TestDeploymentLibraries(t *testing.T) { @@ -124,7 +131,8 @@ func TestDeploymentLibraries(t *testing.T) { Libraries: nested_libraries.C1LibraryDeps, Overrides: nil, } - res, err := LinkAndDeploy(opts, bindBackend, deploymentParams) + + res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { t.Fatalf("err: %+v\n", err) } @@ -181,7 +189,7 @@ func TestDeploymentWithOverrides(t *testing.T) { Libraries: nested_libraries.C1LibraryDeps, } - res, err := LinkAndDeploy(opts, bindBackend, deploymentParams) + res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { t.Fatalf("err: %+v\n", err) } @@ -217,7 +225,7 @@ func TestDeploymentWithOverrides(t *testing.T) { Libraries: nil, Overrides: overrides, } - res, err = LinkAndDeploy(opts, bindBackend, deploymentParams) + res, err = LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { t.Fatalf("err: %+v\n", err) } @@ -280,7 +288,7 @@ func TestEvents(t *testing.T) { }, } - res, err := LinkAndDeploy(txAuth, backend, deploymentParams) + res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(txAuth, backend)) if err != nil { t.Fatalf("error deploying contract for testing: %v", err) } From 8fdb5ef992c7d4757af38c5de9af6d1e1e9be4b9 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Fri, 6 Dec 2024 13:17:58 +0700 Subject: [PATCH 051/104] wip --- accounts/abi/bind/contract_linking_test.go | 98 ---------------------- 1 file changed, 98 deletions(-) delete mode 100644 accounts/abi/bind/contract_linking_test.go diff --git a/accounts/abi/bind/contract_linking_test.go b/accounts/abi/bind/contract_linking_test.go deleted file mode 100644 index 5f82d813cc1d..000000000000 --- a/accounts/abi/bind/contract_linking_test.go +++ /dev/null @@ -1,98 +0,0 @@ -package bind - -import ( - v2 "github.com/ethereum/go-ethereum/accounts/abi/bind/v2" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "strings" - "testing" -) - -type linkTestCase struct { - // map of a library to the order in which its dependencies appear in the EVM bytecode. - codes map[string]string -} - -func makeLinkTestCase(input map[rune][]rune) *linkTestCase { - codes := make(map[string]string) - inputMap := make(map[rune]map[rune]struct{}) - - for contract, deps := range input { - inputMap[contract] = make(map[rune]struct{}) - for _, dep := range deps { - codes[string(contract)] = codes[string(contract)] + string(dep) - inputMap[contract][dep] = struct{}{} - } - } - return &linkTestCase{ - generateUnlinkedContracts(codes), - } -} - -func generateUnlinkedContracts(inputCodes map[string]string) map[string]string { - // map of solidity library pattern to unlinked code - codes := make(map[string]string) - - for name, code := range inputCodes { - var prelinkCode []string - for _, char := range code { - prelinkCode = append(prelinkCode, crypto.Keccak256Hash([]byte(string(char))).String()[2:36]) - } - pattern := crypto.Keccak256Hash([]byte(string(name))).String()[2:36] - codes[pattern] = strings.Join(prelinkCode, "") - } - return codes -} - -var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") - -func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]common.Address) { - testAddr := crypto.PubkeyToAddress(testKey.PublicKey) - var testAddrNonce uint64 - - tc := makeLinkTestCase(input) - alreadyDeployed := make(map[common.Address]struct{}) - // TODO: include in link test case: set of contracts that we expect to be deployed at the end. - // generate this in makeLinkTestCase - // ^ overrides are not included in this case. - mockDeploy := func(input []byte, deployer []byte) (common.Address, *types.Transaction, error) { - contractAddr := crypto.CreateAddress(testAddr, testAddrNonce) - testAddrNonce++ - - // assert that this contract only references libs that are known to be deployed or in the override set - for i := 0; i < len(deployer)/20; i += 20 { - var dep common.Address - dep.SetBytes(deployer[i : i+20]) - if _, ok := alreadyDeployed[dep]; !ok { - t.Fatalf("reference to dependent contract that has not yet been deployed.") - } - } - alreadyDeployed[contractAddr] = struct{}{} - // we don't care about the txs themselves for the sake of the linking tests. so we can return nil for them in the mock deployer - return contractAddr, nil, nil - } - doTest := func() { - // convert the raw test case into working form - - deployParams := v2.DeploymentParams{ - Contracts: nil, - Libraries: nil, - Overrides: nil, - } - res, err := v2.LinkAndDeploy(deployParams, mockDeploy) - if err != nil { - t.Fatalf("got error from LinkAndDeploy: %v\n", err) - } - - // assert that res contains everything we expected to be deployed - } -} - -func TestContractLinking(t *testing.T) { - - //test-case specific values (TODO: move these, mockDeploy, doTest into their own routines). - - // input: a cycle of dependencies. - // expected: [{set of deps deployed first}, {set of deps deployed second}, ..., {contract(s) deployed}] -} From 3c7ce61f7be7280dc905308dccf61800ba623414 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Fri, 6 Dec 2024 14:03:01 +0700 Subject: [PATCH 052/104] basic linking test working --- accounts/abi/bind/v2/lib.go | 1 - 1 file changed, 1 deletion(-) diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 84a03c028379..415b7f8827b5 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -255,7 +255,6 @@ func WatchEvents[T any](instance *ContractInstance, opts *bind.WatchOpts, eventI // New log arrived, parse the event and forward to the user ev, err := unpack(&log) if err != nil { - fmt.Printf("unpack err: %v", err) return err } From 53b5b21475abf020ccfc1890baa6623bd4c2497b Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Fri, 6 Dec 2024 14:56:43 +0700 Subject: [PATCH 053/104] add test cases for contract linking that I forgot to push earlier. Fix deployment logic (apparently modifying a map in-place during iteration is not safe???? --- accounts/abi/bind/v2/contract_linking_test.go | 184 ++++++++++++++++++ accounts/abi/bind/v2/lib.go | 23 ++- 2 files changed, 198 insertions(+), 9 deletions(-) create mode 100644 accounts/abi/bind/v2/contract_linking_test.go diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go new file mode 100644 index 000000000000..517afbaa10ca --- /dev/null +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -0,0 +1,184 @@ +package v2 + +import ( + "fmt" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "testing" +) + +type linkTestCase struct { + // map of pattern to unlinked bytecode (for the purposes of tests just contains the patterns of its dependencies) + libCodes map[string]string + contractCodes map[string]string + + overrides map[string]common.Address +} + +func makeLinkTestCase(input map[rune][]rune, overrides map[rune]common.Address) *linkTestCase { + codes := make(map[string]string) + libCodes := make(map[string]string) + contractCodes := make(map[string]string) + + inputMap := make(map[rune]map[rune]struct{}) + // set of solidity patterns for all contracts that are known to be libraries + libs := make(map[string]struct{}) + + // map of test contract id (rune) to the solidity library pattern (hash of that rune) + patternMap := map[rune]string{} + + for contract, deps := range input { + inputMap[contract] = make(map[rune]struct{}) + if _, ok := patternMap[contract]; !ok { + patternMap[contract] = crypto.Keccak256Hash([]byte(string(contract))).String()[2:36] + } + + for _, dep := range deps { + if _, ok := patternMap[dep]; !ok { + patternMap[dep] = crypto.Keccak256Hash([]byte(string(dep))).String()[2:36] + } + codes[patternMap[contract]] = codes[patternMap[contract]] + fmt.Sprintf("__$%s$__", patternMap[dep]) + inputMap[contract][dep] = struct{}{} + libs[patternMap[dep]] = struct{}{} + } + } + overridesPatterns := make(map[string]common.Address) + for contractId, overrideAddr := range overrides { + pattern := crypto.Keccak256Hash([]byte(string(contractId))).String()[2:36] + overridesPatterns[pattern] = overrideAddr + } + + for _, pattern := range patternMap { + if _, ok := libs[pattern]; ok { + // if the library didn't depend on others, give it some dummy code to not bork deployment logic down-the-line + if len(codes[pattern]) == 0 { + libCodes[pattern] = "ff" + } else { + libCodes[pattern] = codes[pattern] + } + } else { + contractCodes[pattern] = codes[pattern] + } + } + + return &linkTestCase{ + libCodes, + contractCodes, + overridesPatterns, + } +} + +func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]common.Address) { + testAddr := crypto.PubkeyToAddress(testKey.PublicKey) + var testAddrNonce uint64 + + tc := makeLinkTestCase(input, overrides) + alreadyDeployed := make(map[common.Address]struct{}) + allContracts := make(map[rune]struct{}) + + for contract, deps := range input { + allContracts[contract] = struct{}{} + for _, dep := range deps { + allContracts[dep] = struct{}{} + } + } + + // TODO: include in link test case: set of contracts that we expect to be deployed at the end. + // generate this in makeLinkTestCase + // ^ overrides are not included in this case. + mockDeploy := func(input []byte, deployer []byte) (common.Address, *types.Transaction, error) { + contractAddr := crypto.CreateAddress(testAddr, testAddrNonce) + testAddrNonce++ + + // assert that this contract only references libs that are known to be deployed or in the override set + for i := 0; i < len(deployer)/20; i += 20 { + var dep common.Address + dep.SetBytes(deployer[i : i+20]) + if _, ok := alreadyDeployed[dep]; !ok { + t.Fatalf("reference to dependent contract that has not yet been deployed: %x\n", dep) + } + } + alreadyDeployed[contractAddr] = struct{}{} + // we don't care about the txs themselves for the sake of the linking tests. so we can return nil for them in the mock deployer + return contractAddr, nil, nil + } + + var ( + contracts []ContractDeployParams + libs []*bind.MetaData + ) + for pattern, bin := range tc.contractCodes { + contracts = append(contracts, ContractDeployParams{ + Meta: &bind.MetaData{Pattern: pattern, Bin: "0x" + bin}, + Input: nil, + }) + } + for pattern, bin := range tc.libCodes { + libs = append(libs, &bind.MetaData{ + Bin: "0x" + bin, + Pattern: pattern, + }) + } + deployParams := DeploymentParams{ + Contracts: contracts, + Libraries: libs, + Overrides: nil, + } + + res, err := LinkAndDeploy(deployParams, mockDeploy) + if err != nil { + t.Fatalf("got error from LinkAndDeploy: %v\n", err) + } + + // TODO: assert that the result consists of the input contracts minus the overrides. + + if len(res.Addrs) != len(allContracts)-len(overrides) { + for val, _ := range allContracts { + fmt.Println(string(val)) + } + t.Fatalf("expected %d contracts to be deployed. got %d\n", len(allContracts)-len(overrides), len(res.Addrs)) + } + + // note that the link-and-deploy functionality assumes that the combined-abi is well-formed. + + // test-case ideas: + // * libraries that are disjount from the rest of dep graph (they don't get deployed) +} + +func TestContractLinking(t *testing.T) { + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i'}}, + map[rune]common.Address{}) + + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}}, + map[rune]common.Address{}) + + // test single contract only without deps + testLinkCase(t, map[rune][]rune{ + 'a': {}}, + map[rune]common.Address{}) + + // test that libraries at different levels of the tree can share deps, + // and that these shared deps will only be deployed once. + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i', 'm'}, + 'i': {'j', 'k', 'l', 'm'}}, + map[rune]common.Address{}) + + // test two contracts can be deployed which don't share deps + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'f': {'g', 'h', 'i', 'j'}}, + map[rune]common.Address{}) + + // test two contracts can be deployed which share deps + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'f': {'g', 'c', 'd', 'j'}}, + map[rune]common.Address{}) +} diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 415b7f8827b5..0db3fd3191fb 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -91,7 +91,8 @@ func linkContract(contract string, linkedLibs map[string]common.Address) (deploy // // contracts that have become fully linked in the current invocation are // returned. -func linkLibs(pending *map[string]string, linked map[string]common.Address) (deployableDeps map[string]string) { +func linkLibs(pending map[string]string, linked map[string]common.Address) (newPending map[string]string, deployableDeps map[string]string) { + newPending = make(map[string]string) reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") if err != nil { panic(err) @@ -102,23 +103,25 @@ func linkLibs(pending *map[string]string, linked map[string]common.Address) (dep } deployableDeps = make(map[string]string) - for pattern, dep := range *pending { + for pattern, dep := range pending { + newPending[pattern] = dep // link references to dependent libraries that have been deployed - for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(dep, -1) { + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(newPending[pattern], -1) { matchingPattern := match[1] addr, ok := linked[matchingPattern] if !ok { continue } - (*pending)[pattern] = strings.ReplaceAll(dep, "__$"+matchingPattern+"$__", addr.String()[2:]) + + newPending[pattern] = strings.ReplaceAll(newPending[pattern], "__$"+matchingPattern+"$__", addr.String()[2:]) } // if the library code became fully linked, move it from pending->linked. - if !reMatchAnyPattern.MatchString((*pending)[pattern]) { - deployableDeps[pattern] = (*pending)[pattern] - delete(*pending, pattern) + if !reMatchAnyPattern.MatchString(newPending[pattern]) { + deployableDeps[pattern] = newPending[pattern] + delete(newPending, pattern) } } - return deployableDeps + return newPending, deployableDeps } // ContractDeployParams represents state needed to deploy a contract: @@ -187,10 +190,12 @@ func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer [] // link and deploy dynamic libraries for { - deployableDeps := linkLibs(&pending, deployed) + var deployableDeps map[string]string + pending, deployableDeps = linkLibs(pending, deployed) if len(deployableDeps) == 0 { break } + deployTxs, deployAddrs, err := deployLibs(deployableDeps, deploy) for pattern, addr := range deployAddrs { deployed[pattern] = addr From fc681fae37a1f361d6b068da63b6451a0c04d167 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Fri, 6 Dec 2024 20:45:49 +0700 Subject: [PATCH 054/104] wip: update --- accounts/abi/bind/v2/contract_linking_test.go | 46 ++++-- accounts/abi/bind/v2/lib.go | 135 +++++++++++------- 2 files changed, 122 insertions(+), 59 deletions(-) diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index 517afbaa10ca..af22b1998f0d 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -6,6 +6,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "golang.org/x/exp/rand" "testing" ) @@ -70,12 +71,22 @@ func makeLinkTestCase(input map[rune][]rune, overrides map[rune]common.Address) } } -func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]common.Address) { +func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct{}) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey) var testAddrNonce uint64 - - tc := makeLinkTestCase(input, overrides) alreadyDeployed := make(map[common.Address]struct{}) + + // generate deterministic addresses for the override set. + rand.Seed(42) + overrideAddrs := make(map[rune]common.Address) + for contract, _ := range overrides { + var addr common.Address + rand.Read(addr[:]) + overrideAddrs[contract] = addr + alreadyDeployed[addr] = struct{}{} + } + + tc := makeLinkTestCase(input, overrideAddrs) allContracts := make(map[rune]struct{}) for contract, deps := range input { @@ -121,10 +132,15 @@ func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]common Pattern: pattern, }) } + + overridePatterns := make(map[string]common.Address) + for pattern, override := range tc.overrides { + overridePatterns[pattern] = override + } deployParams := DeploymentParams{ Contracts: contracts, Libraries: libs, - Overrides: nil, + Overrides: overridePatterns, } res, err := LinkAndDeploy(deployParams, mockDeploy) @@ -151,16 +167,16 @@ func TestContractLinking(t *testing.T) { testLinkCase(t, map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'e': {'f', 'g', 'h', 'i'}}, - map[rune]common.Address{}) + map[rune]struct{}{}) testLinkCase(t, map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}}, - map[rune]common.Address{}) + map[rune]struct{}{}) // test single contract only without deps testLinkCase(t, map[rune][]rune{ 'a': {}}, - map[rune]common.Address{}) + map[rune]struct{}{}) // test that libraries at different levels of the tree can share deps, // and that these shared deps will only be deployed once. @@ -168,17 +184,27 @@ func TestContractLinking(t *testing.T) { 'a': {'b', 'c', 'd', 'e'}, 'e': {'f', 'g', 'h', 'i', 'm'}, 'i': {'j', 'k', 'l', 'm'}}, - map[rune]common.Address{}) + map[rune]struct{}{}) // test two contracts can be deployed which don't share deps testLinkCase(t, map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'h', 'i', 'j'}}, - map[rune]common.Address{}) + map[rune]struct{}{}) // test two contracts can be deployed which share deps testLinkCase(t, map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'c', 'd', 'j'}}, - map[rune]common.Address{}) + map[rune]struct{}{}) + + // test that one contract with overrides for all lib deps + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}}, + map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}}) + + // test deployment of a contract with overrides + testLinkCase(t, map[rune][]rune{ + 'a': {}}, + map[rune]struct{}{'a': {}}) } diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 0db3fd3191fb..15664c38c82e 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -157,71 +157,108 @@ type DeploymentResult struct { Addrs map[string]common.Address } +func (d *DeploymentResult) Accumulate(other *DeploymentResult) { + for pattern, tx := range other.Txs { + d.Txs[pattern] = tx + } + for pattern, addr := range other.Addrs { + d.Addrs[pattern] = addr + } +} + type ContractDeployer interface { DeployContract(input []byte, deployer []byte) (common.Address, *types.Transaction, error) } -// LinkAndDeploy deploys a specified set of contracts and their dependent -// libraries. If an error occurs, only contracts which were successfully -// deployed are returned in the result. -func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer []byte) (common.Address, *types.Transaction, error)) (res *DeploymentResult, err error) { - libMetas := deployParams.Libraries - overrides := deployParams.Overrides +type depTreeBuilder struct { + overrides map[string]common.Address +} +type depTreeNode struct { + pattern string + unlinkedCode string + nodes []*depTreeNode +} - res = &DeploymentResult{ - Txs: make(map[string]*types.Transaction), - Addrs: make(map[string]common.Address), - } +func (d *depTreeBuilder) buildDepTree(contractBin string, libs map[string]string) *depTreeNode { + node := depTreeNode{contractBin, contractBin, nil} - // re-express libraries as a map of pattern -> pre-link binary - pending := make(map[string]string) - for _, meta := range libMetas { - pending[meta.Pattern] = meta.Bin + reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") + if err != nil { + panic(err) } - - // initialize the set of already-deployed contracts with given override addresses - deployed := make(map[string]common.Address) - for pattern, deployAddr := range overrides { - deployed[pattern] = deployAddr - if _, ok := pending[pattern]; ok { - delete(pending, pattern) + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contractBin, -1) { + pattern := match[1] + if _, ok := d.overrides[pattern]; ok { + continue } + node.nodes = append(node.nodes, d.buildDepTree(libs[pattern], libs)) } + return &node +} - // link and deploy dynamic libraries - for { - var deployableDeps map[string]string - pending, deployableDeps = linkLibs(pending, deployed) - if len(deployableDeps) == 0 { - break - } +type treeDeployer struct { + deployedAddrs map[string]common.Address + deployerTxs map[string]*types.Transaction + inputs map[string][]byte + deploy func(input, deployer []byte) (common.Address, *types.Transaction, error) + err error +} - deployTxs, deployAddrs, err := deployLibs(deployableDeps, deploy) - for pattern, addr := range deployAddrs { - deployed[pattern] = addr - res.Addrs[pattern] = addr - res.Txs[pattern] = deployTxs[addr] - } - if err != nil { - return res, err - } +func (d *treeDeployer) linkAndDeploy(node *depTreeNode) { + for _, childNode := range node.nodes { + d.linkAndDeploy(childNode) + } + // link in all node dependencies and produce the deployer bytecode + deployerCode := node.unlinkedCode + for _, child := range node.nodes { + deployerCode = strings.ReplaceAll(deployerCode, child.pattern, d.deployedAddrs[child.pattern].String()[2:]) } + // deploy the contract. + addr, tx, err := d.deploy(d.inputs[node.pattern], common.Hex2Bytes(deployerCode)) + if err != nil { + d.err = err + } else { + d.deployedAddrs[node.pattern] = addr + d.deployerTxs[node.pattern] = tx + } +} - // link and deploy contracts - for _, contractParams := range deployParams.Contracts { - linkedContract, err := linkContract(contractParams.Meta.Bin, deployed) - if err != nil { - return res, err - } - contractAddr, contractTx, err := deployContract(contractParams.Input, linkedContract, deploy) +func (d *treeDeployer) Result() (*DeploymentResult, error) { + if d.err != nil { + return nil, d.err + } + return &DeploymentResult{ + Txs: d.deployerTxs, + Addrs: d.deployedAddrs, + }, nil +} + +// LinkAndDeploy deploys a specified set of contracts and their dependent +// libraries. If an error occurs, only contracts which were successfully +// deployed are returned in the result. +func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer []byte) (common.Address, *types.Transaction, error)) (res *DeploymentResult, err error) { + // re-express libraries as a map of pattern -> pre-link binary + unlinkedLibs := make(map[string]string) + for _, meta := range deployParams.Libraries { + unlinkedLibs[meta.Pattern] = meta.Bin + } + accumRes := &DeploymentResult{ + Txs: make(map[string]*types.Transaction), + Addrs: make(map[string]common.Address), + } + for _, contract := range deployParams.Contracts { + treeBuilder := depTreeBuilder{deployParams.Overrides} + tree := treeBuilder.buildDepTree(contract.Meta.Bin, unlinkedLibs) + deployer := treeDeployer{deploy: deploy} + deployer.linkAndDeploy(tree) + res, err := deployer.Result() if err != nil { - return res, err + return accumRes, err } - res.Txs[contractParams.Meta.Pattern] = contractTx - res.Addrs[contractParams.Meta.Pattern] = contractAddr - } + accumRes.Accumulate(res) - return res, nil + } + return accumRes, nil } // TODO: this will be generated as part of the bindings, contain the ABI (or metadata object?) and errors From af405b1d82bfb8b4a7c0fbba5dd88c25e1489f71 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 9 Dec 2024 13:56:53 +0700 Subject: [PATCH 055/104] fix test cases --- accounts/abi/bind/v2/contract_linking_test.go | 95 ++++++++++---- accounts/abi/bind/v2/lib.go | 116 ++---------------- 2 files changed, 81 insertions(+), 130 deletions(-) diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index af22b1998f0d..ecdccbfb3abc 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -71,10 +71,10 @@ func makeLinkTestCase(input map[rune][]rune, overrides map[rune]common.Address) } } -func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct{}) { +func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct{}, expectDeployed map[rune]struct{}) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey) var testAddrNonce uint64 - alreadyDeployed := make(map[common.Address]struct{}) + overridesAddrs := make(map[common.Address]struct{}) // generate deterministic addresses for the override set. rand.Seed(42) @@ -83,7 +83,7 @@ func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct var addr common.Address rand.Read(addr[:]) overrideAddrs[contract] = addr - alreadyDeployed[addr] = struct{}{} + overridesAddrs[addr] = struct{}{} } tc := makeLinkTestCase(input, overrideAddrs) @@ -96,9 +96,6 @@ func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct } } - // TODO: include in link test case: set of contracts that we expect to be deployed at the end. - // generate this in makeLinkTestCase - // ^ overrides are not included in this case. mockDeploy := func(input []byte, deployer []byte) (common.Address, *types.Transaction, error) { contractAddr := crypto.CreateAddress(testAddr, testAddrNonce) testAddrNonce++ @@ -107,11 +104,11 @@ func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct for i := 0; i < len(deployer)/20; i += 20 { var dep common.Address dep.SetBytes(deployer[i : i+20]) - if _, ok := alreadyDeployed[dep]; !ok { + if _, ok := overridesAddrs[dep]; !ok { t.Fatalf("reference to dependent contract that has not yet been deployed: %x\n", dep) } } - alreadyDeployed[contractAddr] = struct{}{} + overridesAddrs[contractAddr] = struct{}{} // we don't care about the txs themselves for the sake of the linking tests. so we can return nil for them in the mock deployer return contractAddr, nil, nil } @@ -148,13 +145,14 @@ func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct t.Fatalf("got error from LinkAndDeploy: %v\n", err) } - // TODO: assert that the result consists of the input contracts minus the overrides. - - if len(res.Addrs) != len(allContracts)-len(overrides) { - for val, _ := range allContracts { - fmt.Println(string(val)) + if len(res.Addrs) != len(expectDeployed) { + t.Fatalf("got %d deployed contracts. expected %d.\n", len(res.Addrs), len(expectDeployed)) + } + for contract, _ := range expectDeployed { + pattern := crypto.Keccak256Hash([]byte(string(contract))).String()[2:36] + if _, ok := res.Addrs[pattern]; !ok { + t.Fatalf("expected contract %s was not deployed\n", string(contract)) } - t.Fatalf("expected %d contracts to be deployed. got %d\n", len(allContracts)-len(overrides), len(res.Addrs)) } // note that the link-and-deploy functionality assumes that the combined-abi is well-formed. @@ -164,19 +162,29 @@ func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct } func TestContractLinking(t *testing.T) { - testLinkCase(t, map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'e': {'f', 'g', 'h', 'i'}}, - map[rune]struct{}{}) testLinkCase(t, map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}}, - map[rune]struct{}{}) + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, + }) + + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i'}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, + }) // test single contract only without deps testLinkCase(t, map[rune][]rune{ 'a': {}}, - map[rune]struct{}{}) + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, + }) // test that libraries at different levels of the tree can share deps, // and that these shared deps will only be deployed once. @@ -184,27 +192,60 @@ func TestContractLinking(t *testing.T) { 'a': {'b', 'c', 'd', 'e'}, 'e': {'f', 'g', 'h', 'i', 'm'}, 'i': {'j', 'k', 'l', 'm'}}, - map[rune]struct{}{}) + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, 'k': {}, 'l': {}, 'm': {}, + }) // test two contracts can be deployed which don't share deps testLinkCase(t, map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'h', 'i', 'j'}}, - map[rune]struct{}{}) + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, + }) // test two contracts can be deployed which share deps testLinkCase(t, map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, - 'f': {'g', 'c', 'd', 'j'}}, - map[rune]struct{}{}) + 'f': {'g', 'c', 'd', 'h'}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, + }) - // test that one contract with overrides for all lib deps + // test one contract with overrides for all lib deps testLinkCase(t, map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}}, - map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}}) + map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}}, + map[rune]struct{}{ + 'a': {}, + }) + + // test one contract with overrides for some lib deps + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c'}}, + map[rune]struct{}{'b': {}, 'c': {}}, + map[rune]struct{}{ + 'a': {}, + }) // test deployment of a contract with overrides testLinkCase(t, map[rune][]rune{ 'a': {}}, - map[rune]struct{}{'a': {}}) + map[rune]struct{}{'a': {}}, + map[rune]struct{}{}) + + // two contracts share some dependencies. one contract is marked as an override. all dependencies for the non-override + // contract will be deployed + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'f': {'g', 'c', 'd', 'h'}}, + map[rune]struct{}{'a': {}}, + map[rune]struct{}{ + 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}, + }) + + // TODO: same as the above case but nested one level of dependencies deep (?) } diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 15664c38c82e..dd7a7b827980 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -17,8 +17,6 @@ package v2 import ( - "encoding/hex" - "fmt" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" @@ -29,101 +27,6 @@ import ( "strings" ) -// deployContract deploys a hex-encoded contract with the given constructor -// input. It returns the deployment transaction, address on success. -func deployContract(constructor []byte, contract string, deploy func(input, deployer []byte) (common.Address, *types.Transaction, error)) (deploymentAddr common.Address, deploymentTx *types.Transaction, err error) { - contractBinBytes, err := hex.DecodeString(contract[2:]) - if err != nil { - return common.Address{}, nil, fmt.Errorf("contract bytecode is not a hex string: %s", contractBinBytes[2:]) - } - addr, tx, err := deploy(constructor, contractBinBytes) - if err != nil { - return common.Address{}, nil, fmt.Errorf("failed to deploy contract: %v", err) - } - return addr, tx, nil -} - -// deployLibs iterates the set contracts (map of pattern to hex-encoded -// contract deployer code). Each contract is deployed, and the -// resulting addresses/deployment-txs are returned on success. -func deployLibs(contracts map[string]string, deploy func(input, deployer []byte) (common.Address, *types.Transaction, error)) (deploymentTxs map[common.Address]*types.Transaction, deployAddrs map[string]common.Address, err error) { - deploymentTxs = make(map[common.Address]*types.Transaction) - deployAddrs = make(map[string]common.Address) - - for pattern, contractBin := range contracts { - contractDeployer, err := hex.DecodeString(contractBin[2:]) - if err != nil { - return deploymentTxs, deployAddrs, fmt.Errorf("contract bytecode is not a hex string: %s", contractBin[2:]) - } - addr, tx, err := deploy([]byte{}, contractDeployer) - if err != nil { - return deploymentTxs, deployAddrs, fmt.Errorf("failed to deploy contract: %v", err) - } - deploymentTxs[addr] = tx - deployAddrs[pattern] = addr - } - - return deploymentTxs, deployAddrs, nil -} - -// linkContract takes an unlinked contract deployer hex-encoded code, a map of -// already-deployed library dependencies, replaces references to deployed library -// dependencies in the contract code, and returns the contract deployment bytecode on -// success. -func linkContract(contract string, linkedLibs map[string]common.Address) (deployableContract string, err error) { - reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") - if err != nil { - return "", err - } - // link in any library the contract depends on - for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { - matchingPattern := match[1] - addr := linkedLibs[matchingPattern] - contract = strings.ReplaceAll(contract, "__$"+matchingPattern+"$__", addr.String()[2:]) - } - return contract, nil -} - -// linkLibs iterates the set of dependencies that have yet to be -// linked/deployed (pending), replacing references to library dependencies -// (i.e. mutating pending) if those dependencies are fully linked/deployed -// (in 'linked'). -// -// contracts that have become fully linked in the current invocation are -// returned. -func linkLibs(pending map[string]string, linked map[string]common.Address) (newPending map[string]string, deployableDeps map[string]string) { - newPending = make(map[string]string) - reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") - if err != nil { - panic(err) - } - reMatchAnyPattern, err := regexp.Compile("__\\$.*\\$__") - if err != nil { - panic(err) - } - deployableDeps = make(map[string]string) - - for pattern, dep := range pending { - newPending[pattern] = dep - // link references to dependent libraries that have been deployed - for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(newPending[pattern], -1) { - matchingPattern := match[1] - addr, ok := linked[matchingPattern] - if !ok { - continue - } - - newPending[pattern] = strings.ReplaceAll(newPending[pattern], "__$"+matchingPattern+"$__", addr.String()[2:]) - } - // if the library code became fully linked, move it from pending->linked. - if !reMatchAnyPattern.MatchString(newPending[pattern]) { - deployableDeps[pattern] = newPending[pattern] - delete(newPending, pattern) - } - } - return newPending, deployableDeps -} - // ContractDeployParams represents state needed to deploy a contract: // the metdata and constructor input (which can be nil if no input is specified). type ContractDeployParams struct { @@ -172,6 +75,7 @@ type ContractDeployer interface { type depTreeBuilder struct { overrides map[string]common.Address + libs map[string]string } type depTreeNode struct { pattern string @@ -179,8 +83,8 @@ type depTreeNode struct { nodes []*depTreeNode } -func (d *depTreeBuilder) buildDepTree(contractBin string, libs map[string]string) *depTreeNode { - node := depTreeNode{contractBin, contractBin, nil} +func (d *depTreeBuilder) buildDepTree(pattern string, contractBin string) *depTreeNode { + node := depTreeNode{pattern, contractBin, nil} reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") if err != nil { @@ -191,7 +95,7 @@ func (d *depTreeBuilder) buildDepTree(contractBin string, libs map[string]string if _, ok := d.overrides[pattern]; ok { continue } - node.nodes = append(node.nodes, d.buildDepTree(libs[pattern], libs)) + node.nodes = append(node.nodes, d.buildDepTree(pattern, d.libs[pattern])) } return &node } @@ -247,9 +151,15 @@ func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer [] Addrs: make(map[string]common.Address), } for _, contract := range deployParams.Contracts { - treeBuilder := depTreeBuilder{deployParams.Overrides} - tree := treeBuilder.buildDepTree(contract.Meta.Bin, unlinkedLibs) - deployer := treeDeployer{deploy: deploy} + if _, ok := deployParams.Overrides[contract.Meta.Pattern]; ok { + continue + } + treeBuilder := depTreeBuilder{deployParams.Overrides, unlinkedLibs} + tree := treeBuilder.buildDepTree(contract.Meta.Pattern, contract.Meta.Bin) + deployer := treeDeployer{ + deploy: deploy, + deployedAddrs: make(map[string]common.Address), + deployerTxs: make(map[string]*types.Transaction)} deployer.linkAndDeploy(tree) res, err := deployer.Result() if err != nil { From 32ead61537c4d9233afd48f3982fbd89ee4a16b4 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 9 Dec 2024 13:59:41 +0700 Subject: [PATCH 056/104] one more test --- accounts/abi/bind/v2/contract_linking_test.go | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index ecdccbfb3abc..4c5d2c2a249d 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -247,5 +247,16 @@ func TestContractLinking(t *testing.T) { 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}, }) + // test nested libraries that share deps at different levels of the tree.. with override. + testLinkCase(t, map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i', 'm'}, + 'i': {'j', 'k', 'l', 'm'}}, + map[rune]struct{}{ + 'i': {}, + }, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}, + }) // TODO: same as the above case but nested one level of dependencies deep (?) } From 58ba9872336eab2e0a52688d3e4c40d303eab970 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 9 Dec 2024 14:52:39 +0700 Subject: [PATCH 057/104] make link test case input be its own struct --- accounts/abi/bind/v2/contract_linking_test.go | 109 ++++++++++-------- 1 file changed, 63 insertions(+), 46 deletions(-) diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index 4c5d2c2a249d..ab102e12bdc9 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -71,7 +71,13 @@ func makeLinkTestCase(input map[rune][]rune, overrides map[rune]common.Address) } } -func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct{}, expectDeployed map[rune]struct{}) { +type linkTestCaseInput struct { + input map[rune][]rune + overrides map[rune]struct{} + expectDeployed map[rune]struct{} +} + +func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey) var testAddrNonce uint64 overridesAddrs := make(map[common.Address]struct{}) @@ -79,17 +85,17 @@ func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct // generate deterministic addresses for the override set. rand.Seed(42) overrideAddrs := make(map[rune]common.Address) - for contract, _ := range overrides { + for contract, _ := range tcInput.overrides { var addr common.Address rand.Read(addr[:]) overrideAddrs[contract] = addr overridesAddrs[addr] = struct{}{} } - tc := makeLinkTestCase(input, overrideAddrs) + tc := makeLinkTestCase(tcInput.input, overrideAddrs) allContracts := make(map[rune]struct{}) - for contract, deps := range input { + for contract, deps := range tcInput.input { allContracts[contract] = struct{}{} for _, dep := range deps { allContracts[dep] = struct{}{} @@ -145,10 +151,10 @@ func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct t.Fatalf("got error from LinkAndDeploy: %v\n", err) } - if len(res.Addrs) != len(expectDeployed) { - t.Fatalf("got %d deployed contracts. expected %d.\n", len(res.Addrs), len(expectDeployed)) + if len(res.Addrs) != len(tcInput.expectDeployed) { + t.Fatalf("got %d deployed contracts. expected %d.\n", len(res.Addrs), len(tcInput.expectDeployed)) } - for contract, _ := range expectDeployed { + for contract, _ := range tcInput.expectDeployed { pattern := crypto.Keccak256Hash([]byte(string(contract))).String()[2:36] if _, ok := res.Addrs[pattern]; !ok { t.Fatalf("expected contract %s was not deployed\n", string(contract)) @@ -163,100 +169,111 @@ func testLinkCase(t *testing.T, input map[rune][]rune, overrides map[rune]struct func TestContractLinking(t *testing.T) { - testLinkCase(t, map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}}, map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, - }) + }, + }) - testLinkCase(t, map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'e': {'f', 'g', 'h', 'i'}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i'}}, map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, - }) + }}) // test single contract only without deps - testLinkCase(t, map[rune][]rune{ - 'a': {}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {}}, map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, - }) + }}) // test that libraries at different levels of the tree can share deps, // and that these shared deps will only be deployed once. - testLinkCase(t, map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'e': {'f', 'g', 'h', 'i', 'm'}, - 'i': {'j', 'k', 'l', 'm'}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i', 'm'}, + 'i': {'j', 'k', 'l', 'm'}}, map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, 'k': {}, 'l': {}, 'm': {}, - }) + }}) // test two contracts can be deployed which don't share deps - testLinkCase(t, map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'f': {'g', 'h', 'i', 'j'}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'f': {'g', 'h', 'i', 'j'}}, map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, - }) + }}) // test two contracts can be deployed which share deps - testLinkCase(t, map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'f': {'g', 'c', 'd', 'h'}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'f': {'g', 'c', 'd', 'h'}}, map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, - }) + }}) // test one contract with overrides for all lib deps - testLinkCase(t, map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}}, map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}}, map[rune]struct{}{ 'a': {}, - }) + }}) // test one contract with overrides for some lib deps - testLinkCase(t, map[rune][]rune{ - 'a': {'b', 'c'}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c'}}, map[rune]struct{}{'b': {}, 'c': {}}, map[rune]struct{}{ 'a': {}, - }) + }}) // test deployment of a contract with overrides - testLinkCase(t, map[rune][]rune{ - 'a': {}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {}}, map[rune]struct{}{'a': {}}, - map[rune]struct{}{}) + map[rune]struct{}{}}) // two contracts share some dependencies. one contract is marked as an override. all dependencies for the non-override // contract will be deployed - testLinkCase(t, map[rune][]rune{ + testLinkCase(t, linkTestCaseInput{map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'c', 'd', 'h'}}, map[rune]struct{}{'a': {}}, map[rune]struct{}{ 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}, - }) + }}) // test nested libraries that share deps at different levels of the tree.. with override. - testLinkCase(t, map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'e': {'f', 'g', 'h', 'i', 'm'}, - 'i': {'j', 'k', 'l', 'm'}}, + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i', 'm'}, + 'i': {'j', 'k', 'l', 'm'}}, map[rune]struct{}{ 'i': {}, }, map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}, - }) + }}) // TODO: same as the above case but nested one level of dependencies deep (?) } From 5bd9d714b9c017e2e07a8e35e80db0d542a71609 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 10 Dec 2024 12:23:23 +0700 Subject: [PATCH 058/104] rewrite contract link/deploy again --- accounts/abi/bind/v2/contract_linking_test.go | 23 +--- accounts/abi/bind/v2/lib.go | 105 ++++++++++++------ accounts/abi/bind/v2/lib_test.go | 26 +---- 3 files changed, 80 insertions(+), 74 deletions(-) diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index ab102e12bdc9..81266800dcef 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -120,17 +120,13 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { } var ( - contracts []ContractDeployParams - libs []*bind.MetaData + deployParams DeploymentParams ) for pattern, bin := range tc.contractCodes { - contracts = append(contracts, ContractDeployParams{ - Meta: &bind.MetaData{Pattern: pattern, Bin: "0x" + bin}, - Input: nil, - }) + deployParams.Contracts = append(deployParams.Contracts, &bind.MetaData{Pattern: pattern, Bin: "0x" + bin}) } for pattern, bin := range tc.libCodes { - libs = append(libs, &bind.MetaData{ + deployParams.Contracts = append(deployParams.Contracts, &bind.MetaData{ Bin: "0x" + bin, Pattern: pattern, }) @@ -140,11 +136,7 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { for pattern, override := range tc.overrides { overridePatterns[pattern] = override } - deployParams := DeploymentParams{ - Contracts: contracts, - Libraries: libs, - Overrides: overridePatterns, - } + deployParams.Overrides = overridePatterns res, err := LinkAndDeploy(deployParams, mockDeploy) if err != nil { @@ -160,11 +152,6 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { t.Fatalf("expected contract %s was not deployed\n", string(contract)) } } - - // note that the link-and-deploy functionality assumes that the combined-abi is well-formed. - - // test-case ideas: - // * libraries that are disjount from the rest of dep graph (they don't get deployed) } func TestContractLinking(t *testing.T) { @@ -263,7 +250,7 @@ func TestContractLinking(t *testing.T) { 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}, }}) - // test nested libraries that share deps at different levels of the tree.. with override. + // test nested libraries that share deps at different levels of the tree... with override. testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index dd7a7b827980..b3a064ba24a9 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -39,12 +39,8 @@ type ContractDeployParams struct { // set of contracts, their dependency libraries. It takes an optional override // list to specify libraries that have already been deployed on-chain. type DeploymentParams struct { - // Contracts is the set of contract deployment parameters for contracts - // that are about to be deployed. - Contracts []ContractDeployParams - // Libraries is a map of pattern to metadata for library contracts that - // are to be deployed. - Libraries []*bind.MetaData + Contracts []*bind.MetaData + Inputs map[string][]byte // Overrides is an optional map of pattern to deployment address. // Contracts/libraries that refer to dependencies in the override // set are linked to the provided address (an already-deployed contract). @@ -69,13 +65,15 @@ func (d *DeploymentResult) Accumulate(other *DeploymentResult) { } } -type ContractDeployer interface { - DeployContract(input []byte, deployer []byte) (common.Address, *types.Transaction, error) -} - type depTreeBuilder struct { overrides map[string]common.Address - libs map[string]string + // map of pattern to unlinked contract bytecode (for libraries or contracts) + contracts map[string]string + // map of pattern to subtree represented by contract + subtrees map[string]*depTreeNode + + // map of nodes that aren't referenced by other dependencies (these can be libraries too if user is doing lib-only deployment) + roots map[string]struct{} } type depTreeNode struct { pattern string @@ -83,27 +81,58 @@ type depTreeNode struct { nodes []*depTreeNode } -func (d *depTreeBuilder) buildDepTree(pattern string, contractBin string) *depTreeNode { - node := depTreeNode{pattern, contractBin, nil} - +func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") if err != nil { panic(err) } - for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contractBin, -1) { - pattern := match[1] - if _, ok := d.overrides[pattern]; ok { + node := &depTreeNode{ + pattern: pattern, + unlinkedCode: contract, + } + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { + depPattern := match[1] + if _, ok := d.subtrees[depPattern]; ok { continue } - node.nodes = append(node.nodes, d.buildDepTree(pattern, d.libs[pattern])) + delete(d.roots, depPattern) + d.buildDepTrees(depPattern, d.contracts[depPattern]) + node.nodes = append(node.nodes, d.subtrees[depPattern]) } - return &node + d.subtrees[pattern] = node +} + +func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode) { + for pattern, _ := range d.contracts { + d.roots[pattern] = struct{}{} + } + for pattern, contract := range d.contracts { + if _, ok := d.subtrees[pattern]; ok { + continue + } + reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") + if err != nil { + panic(err) + } + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { + depPattern := match[1] + delete(d.roots, depPattern) + if _, ok := d.subtrees[depPattern]; ok { + continue + } + d.buildDepTrees(depPattern, d.contracts[depPattern]) + } + } + for pattern, _ := range d.roots { + roots = append(roots, d.subtrees[pattern]) + } + return roots } type treeDeployer struct { deployedAddrs map[string]common.Address deployerTxs map[string]*types.Transaction - inputs map[string][]byte + input map[string][]byte // map of the root contract pattern to the constructor input (if there is any) deploy func(input, deployer []byte) (common.Address, *types.Transaction, error) err error } @@ -114,11 +143,13 @@ func (d *treeDeployer) linkAndDeploy(node *depTreeNode) { } // link in all node dependencies and produce the deployer bytecode deployerCode := node.unlinkedCode + for _, child := range node.nodes { - deployerCode = strings.ReplaceAll(deployerCode, child.pattern, d.deployedAddrs[child.pattern].String()[2:]) + deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(d.deployedAddrs[child.pattern].String()[2:])) } + // deploy the contract. - addr, tx, err := d.deploy(d.inputs[node.pattern], common.Hex2Bytes(deployerCode)) + addr, tx, err := d.deploy(d.input[node.pattern], common.Hex2Bytes(deployerCode)) if err != nil { d.err = err } else { @@ -141,32 +172,34 @@ func (d *treeDeployer) Result() (*DeploymentResult, error) { // libraries. If an error occurs, only contracts which were successfully // deployed are returned in the result. func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer []byte) (common.Address, *types.Transaction, error)) (res *DeploymentResult, err error) { - // re-express libraries as a map of pattern -> pre-link binary - unlinkedLibs := make(map[string]string) - for _, meta := range deployParams.Libraries { - unlinkedLibs[meta.Pattern] = meta.Bin - } + unlinkedContracts := make(map[string]string) accumRes := &DeploymentResult{ Txs: make(map[string]*types.Transaction), Addrs: make(map[string]common.Address), } - for _, contract := range deployParams.Contracts { - if _, ok := deployParams.Overrides[contract.Meta.Pattern]; ok { - continue - } - treeBuilder := depTreeBuilder{deployParams.Overrides, unlinkedLibs} - tree := treeBuilder.buildDepTree(contract.Meta.Pattern, contract.Meta.Bin) + for _, meta := range deployParams.Contracts { + unlinkedContracts[meta.Pattern] = meta.Bin + } + // TODO: instantiate this using constructor + treeBuilder := depTreeBuilder{ + overrides: deployParams.Overrides, + contracts: unlinkedContracts, + } + + deps := treeBuilder.BuildDepTrees() + for _, tr := range deps { + // TODO: instantiate deployer with its tree? deployer := treeDeployer{ deploy: deploy, deployedAddrs: make(map[string]common.Address), - deployerTxs: make(map[string]*types.Transaction)} - deployer.linkAndDeploy(tree) + deployerTxs: make(map[string]*types.Transaction), + input: map[string][]byte{tr.pattern: deployParams.Inputs[tr.pattern]}} + deployer.linkAndDeploy(tr) res, err := deployer.Result() if err != nil { return accumRes, err } accumRes.Accumulate(res) - } return accumRes, nil } diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index f621762ccf8f..27b346f73ded 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -122,13 +122,8 @@ func TestDeploymentLibraries(t *testing.T) { t.Fatalf("failed to pack constructor: %v", err) } deploymentParams := DeploymentParams{ - Contracts: []ContractDeployParams{ - { - Meta: nested_libraries.C1MetaData, - Input: constructorInput, - }, - }, - Libraries: nested_libraries.C1LibraryDeps, + Contracts: append(nested_libraries.C1LibraryDeps, nested_libraries.C1MetaData), + Inputs: map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, Overrides: nil, } @@ -186,7 +181,7 @@ func TestDeploymentWithOverrides(t *testing.T) { // deploy some library deps deploymentParams := DeploymentParams{ - Libraries: nested_libraries.C1LibraryDeps, + Contracts: nested_libraries.C1LibraryDeps, } res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) @@ -216,13 +211,8 @@ func TestDeploymentWithOverrides(t *testing.T) { overrides := res.Addrs // deploy the contract deploymentParams = DeploymentParams{ - Contracts: []ContractDeployParams{ - { - Meta: nested_libraries.C1MetaData, - Input: constructorInput, - }, - }, - Libraries: nil, + Contracts: []*bind.MetaData{nested_libraries.C1MetaData}, + Inputs: map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, Overrides: overrides, } res, err = LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) @@ -281,11 +271,7 @@ func TestEvents(t *testing.T) { } deploymentParams := DeploymentParams{ - Contracts: []ContractDeployParams{ - { - Meta: events.CMetaData, - }, - }, + Contracts: []*bind.MetaData{events.CMetaData}, } res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(txAuth, backend)) From 8c6173d0c41668ba34c0df17909384006c8fe615 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 10 Dec 2024 14:01:58 +0700 Subject: [PATCH 059/104] fix linking tests --- accounts/abi/bind/v2/contract_linking_test.go | 10 +++--- accounts/abi/bind/v2/lib.go | 34 ++++++++++--------- 2 files changed, 23 insertions(+), 21 deletions(-) diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index 81266800dcef..30e10d215fd9 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -155,7 +155,6 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { } func TestContractLinking(t *testing.T) { - testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}}, @@ -240,14 +239,15 @@ func TestContractLinking(t *testing.T) { map[rune]struct{}{'a': {}}, map[rune]struct{}{}}) - // two contracts share some dependencies. one contract is marked as an override. all dependencies for the non-override - // contract will be deployed + // two contracts share some dependencies. one contract is marked as an override. only the override contract + // is not deployed. its dependencies are all deployed (even the ones not used by f), and the ones shared with f + // are not redeployed testLinkCase(t, linkTestCaseInput{map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'c', 'd', 'h'}}, map[rune]struct{}{'a': {}}, map[rune]struct{}{ - 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}, + 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, }}) // test nested libraries that share deps at different levels of the tree... with override. @@ -260,7 +260,7 @@ func TestContractLinking(t *testing.T) { 'i': {}, }, map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}, + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'j': {}, 'k': {}, 'l': {}, 'm': {}, }}) // TODO: same as the above case but nested one level of dependencies deep (?) } diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index b3a064ba24a9..b7e65b2b134c 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -95,7 +95,13 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { if _, ok := d.subtrees[depPattern]; ok { continue } + if _, ok := d.overrides[depPattern]; ok { + continue + } + + // this library was referenced by another contract. it's not a dependency tree root. delete(d.roots, depPattern) + d.buildDepTrees(depPattern, d.contracts[depPattern]) node.nodes = append(node.nodes, d.subtrees[depPattern]) } @@ -103,25 +109,16 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { } func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode) { - for pattern, _ := range d.contracts { - d.roots[pattern] = struct{}{} - } for pattern, contract := range d.contracts { if _, ok := d.subtrees[pattern]; ok { continue } - reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") - if err != nil { - panic(err) - } - for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { - depPattern := match[1] - delete(d.roots, depPattern) - if _, ok := d.subtrees[depPattern]; ok { - continue - } - d.buildDepTrees(depPattern, d.contracts[depPattern]) + if _, ok := d.overrides[pattern]; ok { + continue } + // pattern has not been explored, it's potentially a root + d.roots[pattern] = struct{}{} + d.buildDepTrees(pattern, contract) } for pattern, _ := range d.roots { roots = append(roots, d.subtrees[pattern]) @@ -184,16 +181,21 @@ func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer [] treeBuilder := depTreeBuilder{ overrides: deployParams.Overrides, contracts: unlinkedContracts, + subtrees: make(map[string]*depTreeNode), + roots: make(map[string]struct{}), } deps := treeBuilder.BuildDepTrees() for _, tr := range deps { // TODO: instantiate deployer with its tree? + deployer := treeDeployer{ deploy: deploy, deployedAddrs: make(map[string]common.Address), - deployerTxs: make(map[string]*types.Transaction), - input: map[string][]byte{tr.pattern: deployParams.Inputs[tr.pattern]}} + deployerTxs: make(map[string]*types.Transaction)} + if deployParams.Inputs != nil { + deployer.input = map[string][]byte{tr.pattern: deployParams.Inputs[tr.pattern]} + } deployer.linkAndDeploy(tr) res, err := deployer.Result() if err != nil { From 2e0de31afd2cd32b0a3fd8ad24404e6b1eb07031 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 10 Dec 2024 15:57:36 +0700 Subject: [PATCH 060/104] tests working now --- accounts/abi/bind/v2/contract_linking_test.go | 3 + accounts/abi/bind/v2/lib.go | 91 ++++++++++++------- 2 files changed, 59 insertions(+), 35 deletions(-) diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index 30e10d215fd9..ffe157fc0a2d 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -7,6 +7,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "golang.org/x/exp/rand" + "runtime/debug" "testing" ) @@ -144,6 +145,7 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { } if len(res.Addrs) != len(tcInput.expectDeployed) { + debug.PrintStack() t.Fatalf("got %d deployed contracts. expected %d.\n", len(res.Addrs), len(tcInput.expectDeployed)) } for contract, _ := range tcInput.expectDeployed { @@ -164,6 +166,7 @@ func TestContractLinking(t *testing.T) { }, }) + fmt.Println("2") testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index b7e65b2b134c..c834e0b2d76d 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -70,58 +70,66 @@ type depTreeBuilder struct { // map of pattern to unlinked contract bytecode (for libraries or contracts) contracts map[string]string // map of pattern to subtree represented by contract - subtrees map[string]*depTreeNode - + subtrees map[string]any // map of nodes that aren't referenced by other dependencies (these can be libraries too if user is doing lib-only deployment) roots map[string]struct{} } + type depTreeNode struct { pattern string unlinkedCode string - nodes []*depTreeNode + nodes []any +} + +type overrideNode struct { + pattern string + addr common.Address } func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { - reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") - if err != nil { - panic(err) + // if the node is in the subtree set already, bail out early + if _, ok := d.subtrees[pattern]; ok { + return } - node := &depTreeNode{ - pattern: pattern, - unlinkedCode: contract, - } - for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { - depPattern := match[1] - if _, ok := d.subtrees[depPattern]; ok { - continue + if addr, ok := d.overrides[pattern]; ok { + node := &overrideNode{ + pattern: pattern, + addr: addr, } - if _, ok := d.overrides[depPattern]; ok { - continue + d.subtrees[pattern] = node + } else { + node := &depTreeNode{ + pattern: pattern, + unlinkedCode: contract, } + // if the node is an override node: add it to the node map but don't recurse on it. + // else if the node is depNode: recurse on it, and add it to the dep map. + reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") + if err != nil { + panic(err) + } + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { + depPattern := match[1] + d.buildDepTrees(depPattern, d.contracts[depPattern]) + node.nodes = append(node.nodes, d.subtrees[depPattern]) - // this library was referenced by another contract. it's not a dependency tree root. - delete(d.roots, depPattern) - - d.buildDepTrees(depPattern, d.contracts[depPattern]) - node.nodes = append(node.nodes, d.subtrees[depPattern]) + // this dep can't be a root dependency if it is referenced by other contracts. + delete(d.roots, depPattern) + } + d.subtrees[pattern] = node } - d.subtrees[pattern] = node } func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode) { for pattern, contract := range d.contracts { - if _, ok := d.subtrees[pattern]; ok { - continue - } - if _, ok := d.overrides[pattern]; ok { - continue - } - // pattern has not been explored, it's potentially a root d.roots[pattern] = struct{}{} d.buildDepTrees(pattern, contract) } for pattern, _ := range d.roots { - roots = append(roots, d.subtrees[pattern]) + switch node := d.subtrees[pattern].(type) { + case *depTreeNode: + roots = append(roots, node) + } } return roots } @@ -134,15 +142,28 @@ type treeDeployer struct { err error } -func (d *treeDeployer) linkAndDeploy(node *depTreeNode) { +func (d *treeDeployer) linkAndDeploy(n any) { + node, ok := n.(*depTreeNode) + if !ok { + // this was an override node + return + } + for _, childNode := range node.nodes { d.linkAndDeploy(childNode) } // link in all node dependencies and produce the deployer bytecode deployerCode := node.unlinkedCode + for _, c := range node.nodes { + switch child := c.(type) { + case *depTreeNode: + deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(d.deployedAddrs[child.pattern].String()[2:])) + case *overrideNode: + deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(child.addr.String()[2:])) + default: + panic("invalid node type") + } - for _, child := range node.nodes { - deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(d.deployedAddrs[child.pattern].String()[2:])) } // deploy the contract. @@ -175,13 +196,13 @@ func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer [] Addrs: make(map[string]common.Address), } for _, meta := range deployParams.Contracts { - unlinkedContracts[meta.Pattern] = meta.Bin + unlinkedContracts[meta.Pattern] = meta.Bin[2:] } // TODO: instantiate this using constructor treeBuilder := depTreeBuilder{ overrides: deployParams.Overrides, contracts: unlinkedContracts, - subtrees: make(map[string]*depTreeNode), + subtrees: make(map[string]any), roots: make(map[string]struct{}), } From 8e1f4f91b4d3032abdc03d2172cc12dded188b0e Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 10 Dec 2024 16:07:05 +0700 Subject: [PATCH 061/104] remove debug prints. fix contract linking test condition --- accounts/abi/bind/v2/contract_linking_test.go | 17 ++++++++--------- accounts/abi/bind/v2/lib.go | 2 -- 2 files changed, 8 insertions(+), 11 deletions(-) diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index ffe157fc0a2d..d37b16a1fac3 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -7,7 +7,6 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "golang.org/x/exp/rand" - "runtime/debug" "testing" ) @@ -107,12 +106,14 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { contractAddr := crypto.CreateAddress(testAddr, testAddrNonce) testAddrNonce++ - // assert that this contract only references libs that are known to be deployed or in the override set - for i := 0; i < len(deployer)/20; i += 20 { - var dep common.Address - dep.SetBytes(deployer[i : i+20]) - if _, ok := overridesAddrs[dep]; !ok { - t.Fatalf("reference to dependent contract that has not yet been deployed: %x\n", dep) + if len(deployer) >= 20 { + // assert that this contract only references libs that are known to be deployed or in the override set + for i := 0; i < len(deployer); i += 20 { + var dep common.Address + dep.SetBytes(deployer[i : i+20]) + if _, ok := overridesAddrs[dep]; !ok { + t.Fatalf("reference to dependent contract that has not yet been deployed: %x\n", dep) + } } } overridesAddrs[contractAddr] = struct{}{} @@ -145,7 +146,6 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { } if len(res.Addrs) != len(tcInput.expectDeployed) { - debug.PrintStack() t.Fatalf("got %d deployed contracts. expected %d.\n", len(res.Addrs), len(tcInput.expectDeployed)) } for contract, _ := range tcInput.expectDeployed { @@ -166,7 +166,6 @@ func TestContractLinking(t *testing.T) { }, }) - fmt.Println("2") testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index c834e0b2d76d..a3c236dc7abf 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -208,8 +208,6 @@ func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer [] deps := treeBuilder.BuildDepTrees() for _, tr := range deps { - // TODO: instantiate deployer with its tree? - deployer := treeDeployer{ deploy: deploy, deployedAddrs: make(map[string]common.Address), From 3f758c3a1985c7232d78fc6819c43e5b7eb1daf8 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 12 Dec 2024 13:28:03 +0700 Subject: [PATCH 062/104] generation of custom error unpacking builds (not tested yet) --- accounts/abi/bind/bind.go | 5 +++++ accounts/abi/bind/source2.go.tpl | 18 ++++++++++++++++++ .../bind/v2/internal/solc_errors/bindings.go | 9 +++++++++ 3 files changed, 32 insertions(+) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index ea4ed555403e..c25aff450fa9 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -70,6 +70,10 @@ func isKeyWord(arg string) bool { return true } +func add(val1, val2 int) int { + return val1 + val1 +} + // Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant // to be used as is in client code, but rather as an intermediate struct which // enforces compile time type safety and naming convention as opposed to having to @@ -146,6 +150,7 @@ func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[strin "bindtopictype": bindTopicType, "capitalise": capitalise, "decapitalise": decapitalise, + "add": add, } tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSourceV2)) if err := tmpl.Execute(buffer, data); err != nil { diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index 990988bbf18b..62d17d2c17b3 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -151,6 +151,24 @@ var ( } {{end}} + {{ if .Errors }} + func (_{{$contract.Type}} *{{$contract.Type}}) UnpackError(raw []byte) any { + {{$i := 0}} + {{range $k, $v := .Errors}} + {{ if eq $i 0 }} + if val, err := _{{$contract.Type}}.Unpack{{.Normalized.Name}}Error(raw); err != nil { + return val + {{ else }} + } else if val, err := _{{$contract.Type}}.Unpack{{.Normalized.Name}}Error(raw); err != nil { + return val + {{ end -}} + {{$i = add $i 1}} + {{end -}} + } + return nil + } + {{ end -}} + {{range .Errors}} // {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} error raised by the {{$contract.Type}} contract. type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}} diff --git a/accounts/abi/bind/v2/internal/solc_errors/bindings.go b/accounts/abi/bind/v2/internal/solc_errors/bindings.go index 1af79d97b375..8067dd2e96ae 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/bindings.go +++ b/accounts/abi/bind/v2/internal/solc_errors/bindings.go @@ -58,6 +58,15 @@ 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 + + } + return nil +} + // CBadThing represents a BadThing error raised by the C contract. type CBadThing struct { Arg1 *big.Int From 326da991563053360a7bf1b1c74e85820d4363f4 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 12 Dec 2024 15:20:16 +0700 Subject: [PATCH 063/104] wip (just committing so that I can rebase off master to use ethclient.RevertErrorData) --- accounts/abi/bind/bind.go | 2 +- .../bind/v2/internal/solc_errors/bindings.go | 35 +++++++++++++++++-- .../v2/internal/solc_errors/combined-abi.json | 2 +- .../bind/v2/internal/solc_errors/contract.sol | 9 +++++ accounts/abi/bind/v2/lib_test.go | 35 +++++++++++++++++++ 5 files changed, 79 insertions(+), 4 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index c25aff450fa9..4b33dacc58ce 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -71,7 +71,7 @@ func isKeyWord(arg string) bool { } func add(val1, val2 int) int { - return val1 + val1 + return val1 + val2 } // Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant diff --git a/accounts/abi/bind/v2/internal/solc_errors/bindings.go b/accounts/abi/bind/v2/internal/solc_errors/bindings.go index 8067dd2e96ae..1b7d50e9d54d 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/bindings.go +++ b/accounts/abi/bind/v2/internal/solc_errors/bindings.go @@ -28,9 +28,9 @@ var CLibraryDeps = []*bind.MetaData{} // 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\":[],\"name\":\"Foo\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + 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: "0x6080604052348015600e575f80fd5b506101148061001c5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c8063bfb4ebcf14602a575b5f80fd5b60306032565b005b5f600160025f6040517fbb6a82f1000000000000000000000000000000000000000000000000000000008152600401606c949392919060a3565b60405180910390fd5b5f819050919050565b6085816075565b82525050565b5f8115159050919050565b609d81608b565b82525050565b5f60808201905060b45f830187607e565b60bf6020830186607e565b60ca6040830185607e565b60d560608301846096565b9594505050505056fea26469706673582212205ce065ab1cfe16beba2b766e14009fc67ac66c214872149c889f0589720b870a64736f6c634300081a0033", + Bin: "0x6080604052348015600e575f80fd5b506101c58061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063b0a378b014610038578063bfb4ebcf14610042575b5f80fd5b61004061004c565b005b61004a610092565b005b5f6001600260036040517fd233a24f00000000000000000000000000000000000000000000000000000000815260040161008994939291906100ef565b60405180910390fd5b5f600160025f6040517fbb6a82f10000000000000000000000000000000000000000000000000000000081526004016100ce949392919061014c565b60405180910390fd5b5f819050919050565b6100e9816100d7565b82525050565b5f6080820190506101025f8301876100e0565b61010f60208301866100e0565b61011c60408301856100e0565b61012960608301846100e0565b95945050505050565b5f8115159050919050565b61014681610132565b82525050565b5f60808201905061015f5f8301876100e0565b61016c60208301866100e0565b61017960408301856100e0565b610186606083018461013d565b9594505050505056fea26469706673582212203f89da086f6d7e52e75f82a20ebbf7337f166a6dbae309180c8bb95e1a157e6e64736f6c634300081a0033", } // C is an auto generated Go binding around an Ethereum contract. @@ -51,6 +51,13 @@ func (_C *C) PackConstructor() ([]byte, error) { return _C.abi.Pack("") } +// 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() @@ -63,6 +70,9 @@ 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 } @@ -87,3 +97,24 @@ func (_C *C) UnpackBadThingError(raw []byte) (*CBadThing, error) { } 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 { + return nil, err + } + return out, nil +} diff --git a/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json b/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json index e9f5d2e00f42..6ec7ecef43ad 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json +++ b/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json @@ -1 +1 @@ -{"contracts":{"contract.sol:C":{"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"}],"bin":"6080604052348015600e575f80fd5b506101148061001c5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c8063bfb4ebcf14602a575b5f80fd5b60306032565b005b5f600160025f6040517fbb6a82f1000000000000000000000000000000000000000000000000000000008152600401606c949392919060a3565b60405180910390fd5b5f819050919050565b6085816075565b82525050565b5f8115159050919050565b609d81608b565b82525050565b5f60808201905060b45f830187607e565b60bf6020830186607e565b60ca6040830185607e565b60d560608301846096565b9594505050505056fea26469706673582212205ce065ab1cfe16beba2b766e14009fc67ac66c214872149c889f0589720b870a64736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} +{"contracts":{"contract.sol:C":{"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"}],"bin":"6080604052348015600e575f80fd5b506101c58061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063b0a378b014610038578063bfb4ebcf14610042575b5f80fd5b61004061004c565b005b61004a610092565b005b5f6001600260036040517fd233a24f00000000000000000000000000000000000000000000000000000000815260040161008994939291906100ef565b60405180910390fd5b5f600160025f6040517fbb6a82f10000000000000000000000000000000000000000000000000000000081526004016100ce949392919061014c565b60405180910390fd5b5f819050919050565b6100e9816100d7565b82525050565b5f6080820190506101025f8301876100e0565b61010f60208301866100e0565b61011c60408301856100e0565b61012960608301846100e0565b95945050505050565b5f8115159050919050565b61014681610132565b82525050565b5f60808201905061015f5f8301876100e0565b61016c60208301866100e0565b61017960408301856100e0565b610186606083018461013d565b9594505050505056fea26469706673582212203f89da086f6d7e52e75f82a20ebbf7337f166a6dbae309180c8bb95e1a157e6e64736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/v2/internal/solc_errors/contract.sol b/accounts/abi/bind/v2/internal/solc_errors/contract.sol index aa2218cdc331..1b8004d6b8e9 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/contract.sol +++ b/accounts/abi/bind/v2/internal/solc_errors/contract.sol @@ -2,6 +2,7 @@ pragma solidity ^0.8.26; error BadThing(uint256 arg1, uint256 arg2, uint256 arg3, bool arg4); +error BadThing2(uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4); contract C { function Foo() public pure { @@ -12,4 +13,12 @@ contract C { arg4: false }); } + function Bar() public pure { + revert BadThing2({ + arg1: uint256(0), + arg2: uint256(1), + arg3: uint256(2), + arg4: uint256(3) + }); + } } \ No newline at end of file diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 27b346f73ded..dc7b8301bd17 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -25,6 +25,7 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/events" "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/nested_libraries" + "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/solc_errors" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/compiler" @@ -263,6 +264,7 @@ func TestDeploymentWithOverrides(t *testing.T) { t.Fatalf("expected internal call count of 6. got %d.", internalCallCount.Uint64()) } } + func TestEvents(t *testing.T) { // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) txAuth, backend, err := testSetup() @@ -373,6 +375,39 @@ done: } } +func TestErrors(t *testing.T) { + // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) + txAuth, backend, err := testSetup() + if err != nil { + t.Fatalf("error setting up testing env: %v", err) + } + + deploymentParams := DeploymentParams{ + Contracts: []*bind.MetaData{solc_errors.CMetaData}, + } + + res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(txAuth, backend)) + if err != nil { + t.Fatalf("error deploying contract for testing: %v", err) + } + + backend.Commit() + if _, err := bind.WaitDeployed(context.Background(), backend, res.Txs[solc_errors.CMetaData.Pattern]); err != nil { + t.Fatalf("WaitDeployed failed %v", err) + } + + var packedInput []byte + opts := &bind.CallOpts{ + From: res.Addrs[solc_errors.CMetaData.Pattern], + } + instance := ContractInstance{res.Addrs[solc_errors.CMetaData.Pattern], backend} + _, err := Call[struct{}](&instance, opts, packedInput, func(packed []byte) (*struct{}, error) { return nil, nil }) + if err == nil { + t.Fatalf("expected call to fail") + } + +} + func TestBindingGeneration(t *testing.T) { matches, _ := filepath.Glob("internal/*") var dirs []string From f9a9db6a3937a9e8eb313a76174ffb274b561b61 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 12 Dec 2024 22:06:39 +0700 Subject: [PATCH 064/104] full support for errors with working test --- accounts/abi/bind/source2.go.tpl | 4 ++-- .../bind/v2/internal/solc_errors/bindings.go | 4 ++-- .../v2/internal/solc_errors/combined-abi.json | 2 +- .../bind/v2/internal/solc_errors/contract.sol | 12 ++++++++++++ accounts/abi/bind/v2/lib.go | 12 ++++++++++++ accounts/abi/bind/v2/lib_test.go | 19 +++++++++++++++++-- accounts/abi/error.go | 13 ++++++++----- 7 files changed, 54 insertions(+), 12 deletions(-) diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index 62d17d2c17b3..a77bc676578b 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -156,10 +156,10 @@ var ( {{$i := 0}} {{range $k, $v := .Errors}} {{ if eq $i 0 }} - if val, err := _{{$contract.Type}}.Unpack{{.Normalized.Name}}Error(raw); err != nil { + if val, err := _{{$contract.Type}}.Unpack{{.Normalized.Name}}Error(raw); err == nil { return val {{ else }} - } else if val, err := _{{$contract.Type}}.Unpack{{.Normalized.Name}}Error(raw); err != nil { + } else if val, err := _{{$contract.Type}}.Unpack{{.Normalized.Name}}Error(raw); err == nil { return val {{ end -}} {{$i = add $i 1}} diff --git a/accounts/abi/bind/v2/internal/solc_errors/bindings.go b/accounts/abi/bind/v2/internal/solc_errors/bindings.go index 1b7d50e9d54d..af9cf68f8744 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/bindings.go +++ b/accounts/abi/bind/v2/internal/solc_errors/bindings.go @@ -67,10 +67,10 @@ func (_C *C) PackFoo() ([]byte, error) { func (_C *C) UnpackError(raw []byte) any { - if val, err := _C.UnpackBadThingError(raw); err != nil { + if val, err := _C.UnpackBadThingError(raw); err == nil { return val - } else if val, err := _C.UnpackBadThing2Error(raw); err != nil { + } else if val, err := _C.UnpackBadThing2Error(raw); err == nil { return val } diff --git a/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json b/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json index 6ec7ecef43ad..8ad075d2bb00 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json +++ b/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json @@ -1 +1 @@ -{"contracts":{"contract.sol:C":{"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"}],"bin":"6080604052348015600e575f80fd5b506101c58061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063b0a378b014610038578063bfb4ebcf14610042575b5f80fd5b61004061004c565b005b61004a610092565b005b5f6001600260036040517fd233a24f00000000000000000000000000000000000000000000000000000000815260040161008994939291906100ef565b60405180910390fd5b5f600160025f6040517fbb6a82f10000000000000000000000000000000000000000000000000000000081526004016100ce949392919061014c565b60405180910390fd5b5f819050919050565b6100e9816100d7565b82525050565b5f6080820190506101025f8301876100e0565b61010f60208301866100e0565b61011c60408301856100e0565b61012960608301846100e0565b95945050505050565b5f8115159050919050565b61014681610132565b82525050565b5f60808201905061015f5f8301876100e0565b61016c60208301866100e0565b61017960408301856100e0565b610186606083018461013d565b9594505050505056fea26469706673582212203f89da086f6d7e52e75f82a20ebbf7337f166a6dbae309180c8bb95e1a157e6e64736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} +{"contracts":{"contract.sol:C":{"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"}],"bin":"6080604052348015600e575f80fd5b506101c58061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063b0a378b014610038578063bfb4ebcf14610042575b5f80fd5b61004061004c565b005b61004a610092565b005b5f6001600260036040517fd233a24f00000000000000000000000000000000000000000000000000000000815260040161008994939291906100ef565b60405180910390fd5b5f600160025f6040517fbb6a82f10000000000000000000000000000000000000000000000000000000081526004016100ce949392919061014c565b60405180910390fd5b5f819050919050565b6100e9816100d7565b82525050565b5f6080820190506101025f8301876100e0565b61010f60208301866100e0565b61011c60408301856100e0565b61012960608301846100e0565b95945050505050565b5f8115159050919050565b61014681610132565b82525050565b5f60808201905061015f5f8301876100e0565b61016c60208301866100e0565b61017960408301856100e0565b610186606083018461013d565b9594505050505056fea264697066735822122043974fbdd5c75b36bb8fe9dd68c112de4d094a0d8626d74e03edd5e48f18118164736f6c634300081a0033"},"contract.sol:C2":{"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"}],"bin":"6080604052348015600e575f80fd5b506101148061001c5f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c8063bfb4ebcf14602a575b5f80fd5b60306032565b005b5f600160025f6040517fbb6a82f1000000000000000000000000000000000000000000000000000000008152600401606c949392919060a3565b60405180910390fd5b5f819050919050565b6085816075565b82525050565b5f8115159050919050565b609d81608b565b82525050565b5f60808201905060b45f830187607e565b60bf6020830186607e565b60ca6040830185607e565b60d560608301846096565b9594505050505056fea264697066735822122073ad1e2383066bba44481ee5aaadd9a60a3e08e602e13ebf1c67c51ef47d191564736f6c634300081a0033"}},"version":"0.8.26+commit.8a97fa7a.Darwin.appleclang"} diff --git a/accounts/abi/bind/v2/internal/solc_errors/contract.sol b/accounts/abi/bind/v2/internal/solc_errors/contract.sol index 1b8004d6b8e9..541352a1d831 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/contract.sol +++ b/accounts/abi/bind/v2/internal/solc_errors/contract.sol @@ -21,4 +21,16 @@ contract C { arg4: uint256(3) }); } +} + +// purpose of this is to test that generation of metadata for contract that emits one error produces valid Go code +contract C2 { + function Foo() public pure { + revert BadThing({ + arg1: uint256(0), + arg2: uint256(1), + arg3: uint256(2), + arg4: false + }); + } } \ No newline at end of file diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index a3c236dc7abf..cfc493bf3324 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -373,3 +373,15 @@ func Call[T any](instance *ContractInstance, opts *bind.CallOpts, packedInput [] } return unpack(packedOutput) } + +/* +func UnpackError(metadata *bind.MetaData, raw []byte) (any, error) { + fmt.Printf("raw is %x\n", raw[0:4]) + errType := metadata.Errors[fmt.Sprintf("%x", raw[0:4])] + abi, _ := metadata.GetAbi() // TODO: check error here? + res := reflect.New(errType).Interface() + fmt.Printf("err type name is %s\n", errType.Name()) + err := abi.UnpackIntoInterface(&res, errType.Name(), raw) + return res, err +} +*/ diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index dc7b8301bd17..2d9f8378be5c 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -32,6 +32,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/ethconfig" + "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/ethclient/simulated" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/params" @@ -396,18 +397,32 @@ func TestErrors(t *testing.T) { t.Fatalf("WaitDeployed failed %v", err) } + ctrct, _ := solc_errors.NewC() + var packedInput []byte opts := &bind.CallOpts{ From: res.Addrs[solc_errors.CMetaData.Pattern], } + packedInput, _ = ctrct.PackFoo() + instance := ContractInstance{res.Addrs[solc_errors.CMetaData.Pattern], backend} - _, err := Call[struct{}](&instance, opts, packedInput, func(packed []byte) (*struct{}, error) { return nil, nil }) + _, err = Call[struct{}](&instance, opts, packedInput, func(packed []byte) (*struct{}, error) { return nil, nil }) if err == nil { t.Fatalf("expected call to fail") } - + raw, hasRevertErrorData := ethclient.RevertErrorData(err) + if !hasRevertErrorData { + t.Fatalf("expected call error to contain revert error data.") + } + unpackedErr := ctrct.UnpackError(raw) + if unpackedErr == nil { + t.Fatalf("expected to unpack error") + } + // TODO: check anything about the error? } +// TODO: this test will pass if the code is changed but not compiled to a combined-abi.json. +// Not really possible to test this without including solc in the path when running CI. func TestBindingGeneration(t *testing.T) { matches, _ := filepath.Glob("internal/*") var dirs []string diff --git a/accounts/abi/error.go b/accounts/abi/error.go index 8e50112ec5df..203aab04036a 100644 --- a/accounts/abi/error.go +++ b/accounts/abi/error.go @@ -38,6 +38,8 @@ type Error struct { // ID returns the canonical representation of the error's signature used by the // abi definition to identify event names and types. ID common.Hash + + Selector string } func NewError(name string, inputs Arguments) Error { @@ -69,11 +71,12 @@ func NewError(name string, inputs Arguments) Error { id := common.BytesToHash(crypto.Keccak256([]byte(sig))) return Error{ - Name: name, - Inputs: inputs, - str: str, - Sig: sig, - ID: id, + Name: name, + Inputs: inputs, + str: str, + Sig: sig, + ID: id, + Selector: fmt.Sprintf("%x", id[0:4]), } } From 8da5bcd635bf2cadad379efbc6e3ee9636829773 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Fri, 13 Dec 2024 15:39:44 +0700 Subject: [PATCH 065/104] change semantics of contract overrides again: any direct/indirect dependencies of contracts/libraries specified with override addresses should not be deployed if they are not elsewhere referenced as direct/indirect deps of non-override contracts. --- accounts/abi/bind/base.go | 2 + accounts/abi/bind/bind.go | 4 +- accounts/abi/bind/v2/contract_linking_test.go | 13 +- accounts/abi/bind/v2/lib.go | 112 ++++++++---------- 4 files changed, 58 insertions(+), 73 deletions(-) diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index 2380d137c7f9..bb675461481f 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -194,6 +194,8 @@ func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method stri return c.abi.UnpackIntoInterface(res[0], method, output) } +// CallRaw executes an eth_call against the contract with the raw calldata as +// input. It returns the call's return data or an error. func (c *BoundContract) CallRaw(opts *CallOpts, input []byte) ([]byte, error) { return c.call(opts, input) } diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 4b33dacc58ce..3ce73019f8ce 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -311,10 +311,10 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} } for _, original := range evmABI.Errors { - // TODO: I copied this from events. I think it should be correct but not totally sure + // TODO: I copied this from events (above in this function). I think it should be correct but not totally sure // even if it is correct, should consider deduplicating this into its own function. - // Normalize the event for capital cases and non-anonymous outputs + // Normalize the error for capital cases and non-anonymous outputs normalized := original // Ensure there is no duplicated identifier diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index d37b16a1fac3..0091c2a88c09 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -241,28 +241,29 @@ func TestContractLinking(t *testing.T) { map[rune]struct{}{'a': {}}, map[rune]struct{}{}}) - // two contracts share some dependencies. one contract is marked as an override. only the override contract - // is not deployed. its dependencies are all deployed (even the ones not used by f), and the ones shared with f - // are not redeployed + // two contracts ('a' and 'f') share some dependencies. contract 'a' is marked as an override. expect that any of + // its depdencies that aren't shared with 'f' are not deployed. testLinkCase(t, linkTestCaseInput{map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'c', 'd', 'h'}}, map[rune]struct{}{'a': {}}, map[rune]struct{}{ - 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, + 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}, }}) // test nested libraries that share deps at different levels of the tree... with override. + // same condition as above test: no sub-dependencies of testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'e': {'f', 'g', 'h', 'i', 'm'}, - 'i': {'j', 'k', 'l', 'm'}}, + 'i': {'j', 'k', 'l', 'm'}, + 'l': {'n', 'o', 'p'}}, map[rune]struct{}{ 'i': {}, }, map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'j': {}, 'k': {}, 'l': {}, 'm': {}, + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}, }}) // TODO: same as the above case but nested one level of dependencies deep (?) } diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index cfc493bf3324..281fad4a07a2 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -65,12 +65,14 @@ func (d *DeploymentResult) Accumulate(other *DeploymentResult) { } } +// depTreeBuilder turns a set of unlinked contracts and their dependent libraries into a collection of trees +// representing the relation of their dependencies. type depTreeBuilder struct { overrides map[string]common.Address // map of pattern to unlinked contract bytecode (for libraries or contracts) contracts map[string]string // map of pattern to subtree represented by contract - subtrees map[string]any + subtrees map[string]*depTreeNode // map of nodes that aren't referenced by other dependencies (these can be libraries too if user is doing lib-only deployment) roots map[string]struct{} } @@ -78,12 +80,8 @@ type depTreeBuilder struct { type depTreeNode struct { pattern string unlinkedCode string - nodes []any -} - -type overrideNode struct { - pattern string - addr common.Address + nodes []*depTreeNode + overrideAddr *common.Address } func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { @@ -91,50 +89,49 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { if _, ok := d.subtrees[pattern]; ok { return } + + node := &depTreeNode{ + pattern: pattern, + unlinkedCode: contract, + } if addr, ok := d.overrides[pattern]; ok { - node := &overrideNode{ - pattern: pattern, - addr: addr, - } - d.subtrees[pattern] = node - } else { - node := &depTreeNode{ - pattern: pattern, - unlinkedCode: contract, - } - // if the node is an override node: add it to the node map but don't recurse on it. - // else if the node is depNode: recurse on it, and add it to the dep map. - reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") - if err != nil { - panic(err) - } - for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { - depPattern := match[1] - d.buildDepTrees(depPattern, d.contracts[depPattern]) - node.nodes = append(node.nodes, d.subtrees[depPattern]) + node.overrideAddr = &addr + } - // this dep can't be a root dependency if it is referenced by other contracts. - delete(d.roots, depPattern) - } - d.subtrees[pattern] = node + reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") + if err != nil { + panic(err) } + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { + depPattern := match[1] + d.buildDepTrees(depPattern, d.contracts[depPattern]) + node.nodes = append(node.nodes, d.subtrees[depPattern]) + + // this dep can't be a root dependency if it is referenced by other contracts. + delete(d.roots, depPattern) + } + d.subtrees[pattern] = node } func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode) { - for pattern, contract := range d.contracts { + // before the trees of dependencies are known, consider that any provided contract could be a root. + for pattern, _ := range d.contracts { d.roots[pattern] = struct{}{} + } + + // recursively build each part of the dependency subtree by starting at + for pattern, contract := range d.contracts { d.buildDepTrees(pattern, contract) } for pattern, _ := range d.roots { - switch node := d.subtrees[pattern].(type) { - case *depTreeNode: - roots = append(roots, node) - } + roots = append(roots, d.subtrees[pattern]) } return roots } -type treeDeployer struct { +// depTreeDeployer is responsible for taking a built dependency, deploying-and-linking its components in the proper +// order. +type depTreeDeployer struct { deployedAddrs map[string]common.Address deployerTxs map[string]*types.Transaction input map[string][]byte // map of the root contract pattern to the constructor input (if there is any) @@ -142,10 +139,9 @@ type treeDeployer struct { err error } -func (d *treeDeployer) linkAndDeploy(n any) { - node, ok := n.(*depTreeNode) - if !ok { - // this was an override node +func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) { + if node.overrideAddr != nil { + // don't recurse on override nodes return } @@ -154,16 +150,14 @@ func (d *treeDeployer) linkAndDeploy(n any) { } // link in all node dependencies and produce the deployer bytecode deployerCode := node.unlinkedCode - for _, c := range node.nodes { - switch child := c.(type) { - case *depTreeNode: - deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(d.deployedAddrs[child.pattern].String()[2:])) - case *overrideNode: - deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(child.addr.String()[2:])) - default: - panic("invalid node type") + for _, child := range node.nodes { + var linkAddr common.Address + if child.overrideAddr != nil { + linkAddr = *child.overrideAddr + } else { + linkAddr = d.deployedAddrs[child.pattern] } - + deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(linkAddr.String()[2:])) } // deploy the contract. @@ -176,7 +170,7 @@ func (d *treeDeployer) linkAndDeploy(n any) { } } -func (d *treeDeployer) Result() (*DeploymentResult, error) { +func (d *depTreeDeployer) Result() (*DeploymentResult, error) { if d.err != nil { return nil, d.err } @@ -202,13 +196,13 @@ func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer [] treeBuilder := depTreeBuilder{ overrides: deployParams.Overrides, contracts: unlinkedContracts, - subtrees: make(map[string]any), + subtrees: make(map[string]*depTreeNode), roots: make(map[string]struct{}), } deps := treeBuilder.BuildDepTrees() for _, tr := range deps { - deployer := treeDeployer{ + deployer := depTreeDeployer{ deploy: deploy, deployedAddrs: make(map[string]common.Address), deployerTxs: make(map[string]*types.Transaction)} @@ -373,15 +367,3 @@ func Call[T any](instance *ContractInstance, opts *bind.CallOpts, packedInput [] } return unpack(packedOutput) } - -/* -func UnpackError(metadata *bind.MetaData, raw []byte) (any, error) { - fmt.Printf("raw is %x\n", raw[0:4]) - errType := metadata.Errors[fmt.Sprintf("%x", raw[0:4])] - abi, _ := metadata.GetAbi() // TODO: check error here? - res := reflect.New(errType).Interface() - fmt.Printf("err type name is %s\n", errType.Name()) - err := abi.UnpackIntoInterface(&res, errType.Name(), raw) - return res, err -} -*/ From 5297dd06ee973a760b8e2f62b69c9d96de251333 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Fri, 13 Dec 2024 17:54:07 +0700 Subject: [PATCH 066/104] clean up link/deploy code. add docs --- accounts/abi/bind/v2/lib.go | 74 ++++++++++++++++++++++++------------- 1 file changed, 49 insertions(+), 25 deletions(-) diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 281fad4a07a2..434df783ebf9 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -77,6 +77,9 @@ type depTreeBuilder struct { roots map[string]struct{} } +// depTreeNode represents a node (contract) in a dependency tree. it contains its unlinked code, and references to any +// library contracts that it requires. If it is specified as an override, it contains the address where it has already +// been deployed at. type depTreeNode struct { pattern string unlinkedCode string @@ -85,11 +88,10 @@ type depTreeNode struct { } func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { - // if the node is in the subtree set already, bail out early + // if the node is in the subtree set already, it has already been fully recursed/built so we can bail out. if _, ok := d.subtrees[pattern]; ok { return } - node := &depTreeNode{ pattern: pattern, unlinkedCode: contract, @@ -97,7 +99,7 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { if addr, ok := d.overrides[pattern]; ok { node.overrideAddr = &addr } - + // iterate each referenced library in the unlinked code, recurse and built its subtree. reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") if err != nil { panic(err) @@ -107,12 +109,15 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { d.buildDepTrees(depPattern, d.contracts[depPattern]) node.nodes = append(node.nodes, d.subtrees[depPattern]) - // this dep can't be a root dependency if it is referenced by other contracts. + // this library can't be a root dependency if it is referenced by other contracts. delete(d.roots, depPattern) } d.subtrees[pattern] = node } +// BuildDepTrees will compute a set of dependency trees from a set of unlinked contracts. The root of each tree +// corresponds to a contract/library that is not referenced as a dependency anywhere else. Children of each node are +// its library dependencies. func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode) { // before the trees of dependencies are known, consider that any provided contract could be a root. for pattern, _ := range d.contracts { @@ -129,26 +134,46 @@ func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode) { return roots } -// depTreeDeployer is responsible for taking a built dependency, deploying-and-linking its components in the proper -// order. +func newDepTreeBuilder(overrides map[string]common.Address, contracts map[string]string) *depTreeBuilder { + return &depTreeBuilder{ + overrides: overrides, + contracts: contracts, + subtrees: make(map[string]*depTreeNode), + roots: make(map[string]struct{}), + } +} + +type deployFn func(input, deployer []byte) (common.Address, *types.Transaction, error) + +// depTreeDeployer is responsible for taking a dependency, deploying-and-linking its components in the proper +// order. A depTreeDeployer cannot be used after calling LinkAndDeploy other than to retrieve the deployment result. type depTreeDeployer struct { deployedAddrs map[string]common.Address deployerTxs map[string]*types.Transaction input map[string][]byte // map of the root contract pattern to the constructor input (if there is any) - deploy func(input, deployer []byte) (common.Address, *types.Transaction, error) + deploy deployFn err error } +// linkAndDeploy recursively deploys a contract/library: starting by linking/deploying its dependencies. +// The deployment result (deploy addresses/txs or an error) is stored in the depTreeDeployer object. func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) { + // short-circuit further deployment of contracts if a previous deployment encountered an error. + if d.err != nil { + return + } + + // don't deploy contracts specified as overrides. don't deploy their dependencies. if node.overrideAddr != nil { - // don't recurse on override nodes return } + // if this contract/library depends on other libraries deploy them (and their dependencies) first for _, childNode := range node.nodes { d.linkAndDeploy(childNode) } - // link in all node dependencies and produce the deployer bytecode + // if we just deployed any prerequisite contracts, link their deployed addresses into the bytecode to produce + // a deployer bytecode for this contract. deployerCode := node.unlinkedCode for _, child := range node.nodes { var linkAddr common.Address @@ -160,7 +185,7 @@ func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) { deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(linkAddr.String()[2:])) } - // deploy the contract. + // Finally, deploy the contract. addr, tx, err := d.deploy(d.input[node.pattern], common.Hex2Bytes(deployerCode)) if err != nil { d.err = err @@ -170,7 +195,8 @@ func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) { } } -func (d *depTreeDeployer) Result() (*DeploymentResult, error) { +// result returns a result for this deployment, or an error if it failed. +func (d *depTreeDeployer) result() (*DeploymentResult, error) { if d.err != nil { return nil, d.err } @@ -180,10 +206,17 @@ func (d *depTreeDeployer) Result() (*DeploymentResult, error) { }, nil } +func newDepTreeDeployer(deploy deployFn) *depTreeDeployer { + return &depTreeDeployer{ + deploy: deploy, + deployedAddrs: make(map[string]common.Address), + deployerTxs: make(map[string]*types.Transaction)} +} + // LinkAndDeploy deploys a specified set of contracts and their dependent // libraries. If an error occurs, only contracts which were successfully // deployed are returned in the result. -func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer []byte) (common.Address, *types.Transaction, error)) (res *DeploymentResult, err error) { +func LinkAndDeploy(deployParams DeploymentParams, deploy deployFn) (res *DeploymentResult, err error) { unlinkedContracts := make(map[string]string) accumRes := &DeploymentResult{ Txs: make(map[string]*types.Transaction), @@ -192,25 +225,16 @@ func LinkAndDeploy(deployParams DeploymentParams, deploy func(input, deployer [] for _, meta := range deployParams.Contracts { unlinkedContracts[meta.Pattern] = meta.Bin[2:] } - // TODO: instantiate this using constructor - treeBuilder := depTreeBuilder{ - overrides: deployParams.Overrides, - contracts: unlinkedContracts, - subtrees: make(map[string]*depTreeNode), - roots: make(map[string]struct{}), - } - + treeBuilder := newDepTreeBuilder(deployParams.Overrides, unlinkedContracts) deps := treeBuilder.BuildDepTrees() + for _, tr := range deps { - deployer := depTreeDeployer{ - deploy: deploy, - deployedAddrs: make(map[string]common.Address), - deployerTxs: make(map[string]*types.Transaction)} + deployer := newDepTreeDeployer(deploy) if deployParams.Inputs != nil { deployer.input = map[string][]byte{tr.pattern: deployParams.Inputs[tr.pattern]} } deployer.linkAndDeploy(tr) - res, err := deployer.Result() + res, err := deployer.result() if err != nil { return accumRes, err } From 55778ba6e283ad7e95a6d6b00a9725e12e6bef8d Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Fri, 13 Dec 2024 19:44:01 +0700 Subject: [PATCH 067/104] gofmt files. add a TODO comment and remove another useless comment --- accounts/abi/bind/bind.go | 2 +- accounts/abi/bind/source2.go.tpl | 3 +- accounts/abi/bind/v2/backend.go | 3 +- accounts/abi/bind/v2/contract_linking_test.go | 18 +++++++++- accounts/abi/bind/v2/lib.go | 7 ++-- accounts/abi/bind/v2/lib_test.go | 33 +++++++++++-------- 6 files changed, 45 insertions(+), 21 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 3ce73019f8ce..b9c1457225a0 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -421,7 +421,7 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] var findDeps func(contract *tmplContract) map[string]struct{} findDeps = func(contract *tmplContract) map[string]struct{} { // 1) match all libraries that this contract depends on - re, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") + re, err := regexp.Compile(`__\\$([a-f0-9]+)\\$__`) if err != nil { panic(err) } diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index a77bc676578b..a3d099b56874 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -125,8 +125,6 @@ var ( } func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log *types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { - // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. - // and we only need normalized name when dealing with generated go symbols. event := "{{.Original.Name}}" if log.Topics[0] != _{{$contract.Type}}.abi.Events[event].ID { return nil, errors.New("event signature mismatch") @@ -183,6 +181,7 @@ var ( errName := "{{.Normalized.Name}}" out := new({{$contract.Type}}{{.Normalized.Name}}) if err := _{{$contract.Type}}.abi.UnpackIntoInterface(out, errName, raw); err != nil { + // TODO: output can be non-pointer type. return nil, err } return out, nil diff --git a/accounts/abi/bind/v2/backend.go b/accounts/abi/bind/v2/backend.go index ca4162efab19..4f20c89e181e 100644 --- a/accounts/abi/bind/v2/backend.go +++ b/accounts/abi/bind/v2/backend.go @@ -18,10 +18,11 @@ package v2 import ( "context" + "math/big" + "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" - "math/big" ) type BackendV2 interface { diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/v2/contract_linking_test.go index 0091c2a88c09..644e438bc76a 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/v2/contract_linking_test.go @@ -1,13 +1,29 @@ +// Copyright 2024 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . package v2 import ( "fmt" + "testing" + "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "golang.org/x/exp/rand" - "testing" ) type linkTestCase struct { diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 434df783ebf9..e565eb5e805c 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -17,14 +17,15 @@ package v2 import ( + "regexp" + "strings" + "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/event" - "regexp" - "strings" ) // ContractDeployParams represents state needed to deploy a contract: @@ -100,7 +101,7 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { node.overrideAddr = &addr } // iterate each referenced library in the unlinked code, recurse and built its subtree. - reMatchSpecificPattern, err := regexp.Compile("__\\$([a-f0-9]+)\\$__") + reMatchSpecificPattern, err := regexp.Compile(`__\\$([a-f0-9]+)\\$__`) if err != nil { panic(err) } diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 2d9f8378be5c..3c24bec514ca 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -19,7 +19,14 @@ package v2 import ( "context" "encoding/json" - "fmt" + "io" + "math/big" + "os" + "path/filepath" + "strings" + "testing" + "time" + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" @@ -36,13 +43,6 @@ import ( "github.com/ethereum/go-ethereum/ethclient/simulated" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/params" - "io" - "math/big" - "os" - "path/filepath" - "strings" - "testing" - "time" ) var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") @@ -76,12 +76,10 @@ func testSetup() (*bind.TransactOpts, *backends.SimulatedBackend, error) { Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) { signature, err := crypto.Sign(signer.Hash(tx).Bytes(), testKey) if err != nil { - panic(fmt.Sprintf("error signing tx: %v", err)) return nil, err } signedTx, err := tx.WithSignature(signer, signature) if err != nil { - panic(fmt.Sprintf("error creating tx with sig: %v", err)) return nil, err } return signedTx, nil @@ -304,7 +302,13 @@ func TestEvents(t *testing.T) { Context: context.Background(), } sub1, err := WatchEvents(&boundContract, watchOpts, events.CBasic1EventID(), ctrct.UnpackBasic1Event, newCBasic1Ch) + if err != nil { + t.Fatalf("WatchEvents returned error: %v", err) + } sub2, err := WatchEvents(&boundContract, watchOpts, events.CBasic2EventID(), ctrct.UnpackBasic2Event, newCBasic2Ch) + if err != nil { + t.Fatalf("WatchEvents returned error: %v", err) + } defer sub1.Unsubscribe() defer sub2.Unsubscribe() @@ -327,11 +331,11 @@ func TestEvents(t *testing.T) { e2Count := 0 for { select { - case _ = <-newCBasic1Ch: + case <-newCBasic1Ch: e1Count++ - case _ = <-newCBasic2Ch: + case <-newCBasic2Ch: e2Count++ - case _ = <-timeout.C: + case <-timeout.C: goto done } if e1Count == 2 && e2Count == 1 { @@ -478,6 +482,9 @@ func TestBindingGeneration(t *testing.T) { } existingBindings, err := os.ReadFile(filepath.Join(basePath, "bindings.go")) + if err != nil { + t.Fatalf("ReadFile returned error: %v", err) + } if code != string(existingBindings) { t.Fatalf("code mismatch for %s", dir) } From 68f40195633a047a1f9c1b4e6c6680b8fa68b418 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Fri, 13 Dec 2024 19:55:13 +0700 Subject: [PATCH 068/104] fix regex for solc pattern matching --- accounts/abi/bind/bind.go | 2 +- accounts/abi/bind/v2/lib.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index b9c1457225a0..27d38eb09641 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -421,7 +421,7 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] var findDeps func(contract *tmplContract) map[string]struct{} findDeps = func(contract *tmplContract) map[string]struct{} { // 1) match all libraries that this contract depends on - re, err := regexp.Compile(`__\\$([a-f0-9]+)\\$__`) + re, err := regexp.Compile(`__\$([a-f0-9]+)\$__`) if err != nil { panic(err) } diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index e565eb5e805c..2fb7a60a6823 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -101,7 +101,7 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { node.overrideAddr = &addr } // iterate each referenced library in the unlinked code, recurse and built its subtree. - reMatchSpecificPattern, err := regexp.Compile(`__\\$([a-f0-9]+)\\$__`) + reMatchSpecificPattern, err := regexp.Compile(`__\$([a-f0-9]+)\$__`) if err != nil { panic(err) } From e140c3d3d820885ea5563c5acfdef704c4f677f3 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Sun, 15 Dec 2024 17:35:25 +0700 Subject: [PATCH 069/104] move contract dep tree, link-and-deploy to bind package. This is so that bind can build the dependency tree for each library to populate their exported deps. --- accounts/abi/bind/bind.go | 64 ++--- accounts/abi/bind/dep_tree.go | 242 ++++++++++++++++++ ...tract_linking_test.go => dep_tree_test.go} | 9 +- .../v2/internal/nested_libraries/bindings.go | 19 +- accounts/abi/bind/v2/lib.go | 219 ---------------- accounts/abi/bind/v2/lib_test.go | 20 +- 6 files changed, 291 insertions(+), 282 deletions(-) create mode 100644 accounts/abi/bind/dep_tree.go rename accounts/abi/bind/{v2/contract_linking_test.go => dep_tree_test.go} (96%) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 27d38eb09641..f5ddda240e65 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -404,51 +404,6 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] contracts[types[i]].Library = ok } - // compute the full set of libraries that each contract depends on. - for _, contract := range contracts { - if contract.Library { - continue - } - // recursively traverse the library dependency graph - // of the contract, flattening it into a set. - // - // For abigenv2, we do not generate contract deploy - // methods (which in v1 recursively deploy their - // library dependencies). So, the entire set of - // library dependencies is required, and we will - // determine the order to deploy and link them at - // runtime. - var findDeps func(contract *tmplContract) map[string]struct{} - findDeps = func(contract *tmplContract) map[string]struct{} { - // 1) match all libraries that this contract depends on - re, err := regexp.Compile(`__\$([a-f0-9]+)\$__`) - if err != nil { - panic(err) - } - libBin := contracts[contract.Type].InputBin - matches := re.FindAllStringSubmatch(libBin, -1) - result := make(map[string]struct{}) - - // 2) recurse, gathering nested library dependencies - for _, match := range matches { - pattern := match[1] - result[pattern] = struct{}{} - depContract := contracts[libs[pattern]] - for subPattern, _ := range findDeps(depContract) { - result[subPattern] = struct{}{} - } - } - return result - } - // take the set of library patterns, convert it to a map of type -> pattern - deps := findDeps(contract) - contract.AllLibraries = make(map[string]string) - for contractPattern, _ := range deps { - contractType := libs[contractPattern] - contract.AllLibraries[contractType] = contractPattern - } - } - // map of contract name -> pattern invertedLibs := make(map[string]string) // assume that this is invertible/onto because I assume library names are unique now @@ -457,6 +412,25 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] invertedLibs[name] = pattern } + contractsBins := make(map[string]string) + for typ, contract := range contracts { + pattern := invertedLibs[typ] + contractsBins[pattern] = contract.InputBin + } + builder := newDepTreeBuilder(nil, contractsBins) + roots, deps := builder.BuildDepTrees() + allNodes := append(roots, deps...) + for _, dep := range allNodes { + contractType := libs[dep.pattern] + for subDepPattern, _ := range dep.Flatten() { + if subDepPattern == dep.pattern { + continue + } + subDepType := libs[subDepPattern] + contracts[contractType].AllLibraries[subDepType] = subDepPattern + } + } + // Generate the contract template data content and render it data := &tmplData{ Package: pkg, diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go new file mode 100644 index 000000000000..21e5bbf685cf --- /dev/null +++ b/accounts/abi/bind/dep_tree.go @@ -0,0 +1,242 @@ +package bind + +import ( + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "regexp" + "strings" +) + +// ContractDeployParams represents state needed to deploy a contract: +// the metdata and constructor input (which can be nil if no input is specified). +type ContractDeployParams struct { + Meta *MetaData + // Input is the ABI-encoded constructor input for the contract deployment. + Input []byte +} + +// DeploymentParams represents parameters needed to deploy a +// set of contracts, their dependency libraries. It takes an optional override +// list to specify libraries that have already been deployed on-chain. +type DeploymentParams struct { + Contracts []*MetaData + Inputs map[string][]byte + // Overrides is an optional map of pattern to deployment address. + // Contracts/libraries that refer to dependencies in the override + // set are linked to the provided address (an already-deployed contract). + Overrides map[string]common.Address +} + +// DeploymentResult contains the relevant information from the deployment of +// multiple contracts: their deployment txs and addresses. +type DeploymentResult struct { + // map of contract library pattern -> deploy transaction + Txs map[string]*types.Transaction + // map of contract library pattern -> deployed address + Addrs map[string]common.Address +} + +func (d *DeploymentResult) Accumulate(other *DeploymentResult) { + for pattern, tx := range other.Txs { + d.Txs[pattern] = tx + } + for pattern, addr := range other.Addrs { + d.Addrs[pattern] = addr + } +} + +// depTreeBuilder turns a set of unlinked contracts and their dependent libraries into a collection of trees +// representing the relation of their dependencies. +type depTreeBuilder struct { + overrides map[string]common.Address + // map of pattern to unlinked contract bytecode (for libraries or contracts) + contracts map[string]string + // map of pattern to subtree represented by contract + subtrees map[string]*depTreeNode + // map of nodes that aren't referenced by other dependencies (these can be libraries too if user is doing lib-only deployment) + roots map[string]struct{} +} + +// depTreeNode represents a node (contract) in a dependency tree. it contains its unlinked code, and references to any +// library contracts that it requires. If it is specified as an override, it contains the address where it has already +// been deployed at. +type depTreeNode struct { + pattern string + unlinkedCode string + children []*depTreeNode + overrideAddr *common.Address +} + +// returns the subtree as a map of pattern -> unlinked contract bytecode. it excludes the code of the top-level +// node. +func (n *depTreeNode) Flatten() (res map[string]string) { + res = map[string]string{n.pattern: n.unlinkedCode} + for _, child := range n.children { + subtree := child.Flatten() + + for k, v := range subtree { + res[k] = v + } + } + return res +} + +func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { + // if the node is in the subtree set already, it has already been fully recursed/built so we can bail out. + if _, ok := d.subtrees[pattern]; ok { + return + } + node := &depTreeNode{ + pattern: pattern, + unlinkedCode: contract, + } + if addr, ok := d.overrides[pattern]; ok { + node.overrideAddr = &addr + } + // iterate each referenced library in the unlinked code, recurse and built its subtree. + reMatchSpecificPattern, err := regexp.Compile(`__\$([a-f0-9]+)\$__`) + if err != nil { + panic(err) + } + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { + depPattern := match[1] + d.buildDepTrees(depPattern, d.contracts[depPattern]) + node.children = append(node.children, d.subtrees[depPattern]) + + // this library can't be a root dependency if it is referenced by other contracts. + delete(d.roots, depPattern) + } + d.subtrees[pattern] = node +} + +// BuildDepTrees will compute a set of dependency trees from a set of unlinked contracts. The root of each tree +// corresponds to a contract/library that is not referenced as a dependency anywhere else. Children of each node are +// its library dependencies. +func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode, nonRoots []*depTreeNode) { + // before the trees of dependencies are known, consider that any provided contract could be a root. + for pattern, _ := range d.contracts { + d.roots[pattern] = struct{}{} + } + + // recursively build each part of the dependency subtree by starting at + for pattern, contract := range d.contracts { + d.buildDepTrees(pattern, contract) + } + for pattern, _ := range d.contracts { + if _, ok := d.roots[pattern]; ok { + roots = append(roots, d.subtrees[pattern]) + } else { + nonRoots = append(nonRoots, d.subtrees[pattern]) + } + } + return roots, nonRoots +} + +func newDepTreeBuilder(overrides map[string]common.Address, contracts map[string]string) *depTreeBuilder { + return &depTreeBuilder{ + overrides: overrides, + contracts: contracts, + subtrees: make(map[string]*depTreeNode), + roots: make(map[string]struct{}), + } +} + +type deployFn func(input, deployer []byte) (common.Address, *types.Transaction, error) + +// depTreeDeployer is responsible for taking a dependency, deploying-and-linking its components in the proper +// order. A depTreeDeployer cannot be used after calling LinkAndDeploy other than to retrieve the deployment result. +type depTreeDeployer struct { + deployedAddrs map[string]common.Address + deployerTxs map[string]*types.Transaction + input map[string][]byte // map of the root contract pattern to the constructor input (if there is any) + deploy deployFn + err error +} + +// linkAndDeploy recursively deploys a contract/library: starting by linking/deploying its dependencies. +// The deployment result (deploy addresses/txs or an error) is stored in the depTreeDeployer object. +func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) { + // short-circuit further deployment of contracts if a previous deployment encountered an error. + if d.err != nil { + return + } + + // don't deploy contracts specified as overrides. don't deploy their dependencies. + if node.overrideAddr != nil { + return + } + + // if this contract/library depends on other libraries deploy them (and their dependencies) first + for _, childNode := range node.children { + d.linkAndDeploy(childNode) + } + // if we just deployed any prerequisite contracts, link their deployed addresses into the bytecode to produce + // a deployer bytecode for this contract. + deployerCode := node.unlinkedCode + for _, child := range node.children { + var linkAddr common.Address + if child.overrideAddr != nil { + linkAddr = *child.overrideAddr + } else { + linkAddr = d.deployedAddrs[child.pattern] + } + deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(linkAddr.String()[2:])) + } + + // Finally, deploy the contract. + addr, tx, err := d.deploy(d.input[node.pattern], common.Hex2Bytes(deployerCode)) + if err != nil { + d.err = err + } else { + d.deployedAddrs[node.pattern] = addr + d.deployerTxs[node.pattern] = tx + } +} + +// result returns a result for this deployment, or an error if it failed. +func (d *depTreeDeployer) result() (*DeploymentResult, error) { + if d.err != nil { + return nil, d.err + } + return &DeploymentResult{ + Txs: d.deployerTxs, + Addrs: d.deployedAddrs, + }, nil +} + +func newDepTreeDeployer(deploy deployFn) *depTreeDeployer { + return &depTreeDeployer{ + deploy: deploy, + deployedAddrs: make(map[string]common.Address), + deployerTxs: make(map[string]*types.Transaction)} +} + +// LinkAndDeploy deploys a specified set of contracts and their dependent +// libraries. If an error occurs, only contracts which were successfully +// deployed are returned in the result. +func LinkAndDeploy(deployParams DeploymentParams, deploy deployFn) (res *DeploymentResult, err error) { + unlinkedContracts := make(map[string]string) + accumRes := &DeploymentResult{ + Txs: make(map[string]*types.Transaction), + Addrs: make(map[string]common.Address), + } + for _, meta := range deployParams.Contracts { + unlinkedContracts[meta.Pattern] = meta.Bin[2:] + } + treeBuilder := newDepTreeBuilder(deployParams.Overrides, unlinkedContracts) + deps, _ := treeBuilder.BuildDepTrees() + + for _, tr := range deps { + deployer := newDepTreeDeployer(deploy) + if deployParams.Inputs != nil { + deployer.input = map[string][]byte{tr.pattern: deployParams.Inputs[tr.pattern]} + } + deployer.linkAndDeploy(tr) + res, err := deployer.result() + if err != nil { + return accumRes, err + } + accumRes.Accumulate(res) + } + return accumRes, nil +} diff --git a/accounts/abi/bind/v2/contract_linking_test.go b/accounts/abi/bind/dep_tree_test.go similarity index 96% rename from accounts/abi/bind/v2/contract_linking_test.go rename to accounts/abi/bind/dep_tree_test.go index 644e438bc76a..06ba6cc5edf5 100644 --- a/accounts/abi/bind/v2/contract_linking_test.go +++ b/accounts/abi/bind/dep_tree_test.go @@ -13,13 +13,12 @@ // // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -package v2 +package bind import ( "fmt" "testing" - "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" @@ -87,6 +86,8 @@ func makeLinkTestCase(input map[rune][]rune, overrides map[rune]common.Address) } } +var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + type linkTestCaseInput struct { input map[rune][]rune overrides map[rune]struct{} @@ -141,10 +142,10 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { deployParams DeploymentParams ) for pattern, bin := range tc.contractCodes { - deployParams.Contracts = append(deployParams.Contracts, &bind.MetaData{Pattern: pattern, Bin: "0x" + bin}) + deployParams.Contracts = append(deployParams.Contracts, &MetaData{Pattern: pattern, Bin: "0x" + bin}) } for pattern, bin := range tc.libCodes { - deployParams.Contracts = append(deployParams.Contracts, &bind.MetaData{ + deployParams.Contracts = append(deployParams.Contracts, &MetaData{ Bin: "0x" + bin, Pattern: pattern, }) diff --git a/accounts/abi/bind/v2/internal/nested_libraries/bindings.go b/accounts/abi/bind/v2/internal/nested_libraries/bindings.go index 60c87095eea5..212c81bc8b48 100644 --- a/accounts/abi/bind/v2/internal/nested_libraries/bindings.go +++ b/accounts/abi/bind/v2/internal/nested_libraries/bindings.go @@ -176,7 +176,9 @@ func (_L1 *L1) UnpackDo(data []byte) (*big.Int, error) { } -var L2LibraryDeps = []*bind.MetaData{} +var L2LibraryDeps = []*bind.MetaData{ + L1MetaData, +} // TODO: convert this type to value type after everything works. // L2MetaData contains all meta data concerning the L2 contract. @@ -224,7 +226,9 @@ func (_L2 *L2) UnpackDo(data []byte) (*big.Int, error) { } -var L2bLibraryDeps = []*bind.MetaData{} +var L2bLibraryDeps = []*bind.MetaData{ + L1MetaData, +} // TODO: convert this type to value type after everything works. // L2bMetaData contains all meta data concerning the L2b contract. @@ -320,7 +324,11 @@ func (_L3 *L3) UnpackDo(data []byte) (*big.Int, error) { } -var L4LibraryDeps = []*bind.MetaData{} +var L4LibraryDeps = []*bind.MetaData{ + L1MetaData, + L2MetaData, + L3MetaData, +} // TODO: convert this type to value type after everything works. // L4MetaData contains all meta data concerning the L4 contract. @@ -368,7 +376,10 @@ func (_L4 *L4) UnpackDo(data []byte) (*big.Int, error) { } -var L4bLibraryDeps = []*bind.MetaData{} +var L4bLibraryDeps = []*bind.MetaData{ + L1MetaData, + L2bMetaData, +} // TODO: convert this type to value type after everything works. // L4bMetaData contains all meta data concerning the L4b contract. diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 2fb7a60a6823..ae8cf91c1d57 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -17,9 +17,6 @@ package v2 import ( - "regexp" - "strings" - "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" @@ -28,222 +25,6 @@ import ( "github.com/ethereum/go-ethereum/event" ) -// ContractDeployParams represents state needed to deploy a contract: -// the metdata and constructor input (which can be nil if no input is specified). -type ContractDeployParams struct { - Meta *bind.MetaData - // Input is the ABI-encoded constructor input for the contract deployment. - Input []byte -} - -// DeploymentParams represents parameters needed to deploy a -// set of contracts, their dependency libraries. It takes an optional override -// list to specify libraries that have already been deployed on-chain. -type DeploymentParams struct { - Contracts []*bind.MetaData - Inputs map[string][]byte - // Overrides is an optional map of pattern to deployment address. - // Contracts/libraries that refer to dependencies in the override - // set are linked to the provided address (an already-deployed contract). - Overrides map[string]common.Address -} - -// DeploymentResult contains the relevant information from the deployment of -// multiple contracts: their deployment txs and addresses. -type DeploymentResult struct { - // map of contract library pattern -> deploy transaction - Txs map[string]*types.Transaction - // map of contract library pattern -> deployed address - Addrs map[string]common.Address -} - -func (d *DeploymentResult) Accumulate(other *DeploymentResult) { - for pattern, tx := range other.Txs { - d.Txs[pattern] = tx - } - for pattern, addr := range other.Addrs { - d.Addrs[pattern] = addr - } -} - -// depTreeBuilder turns a set of unlinked contracts and their dependent libraries into a collection of trees -// representing the relation of their dependencies. -type depTreeBuilder struct { - overrides map[string]common.Address - // map of pattern to unlinked contract bytecode (for libraries or contracts) - contracts map[string]string - // map of pattern to subtree represented by contract - subtrees map[string]*depTreeNode - // map of nodes that aren't referenced by other dependencies (these can be libraries too if user is doing lib-only deployment) - roots map[string]struct{} -} - -// depTreeNode represents a node (contract) in a dependency tree. it contains its unlinked code, and references to any -// library contracts that it requires. If it is specified as an override, it contains the address where it has already -// been deployed at. -type depTreeNode struct { - pattern string - unlinkedCode string - nodes []*depTreeNode - overrideAddr *common.Address -} - -func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { - // if the node is in the subtree set already, it has already been fully recursed/built so we can bail out. - if _, ok := d.subtrees[pattern]; ok { - return - } - node := &depTreeNode{ - pattern: pattern, - unlinkedCode: contract, - } - if addr, ok := d.overrides[pattern]; ok { - node.overrideAddr = &addr - } - // iterate each referenced library in the unlinked code, recurse and built its subtree. - reMatchSpecificPattern, err := regexp.Compile(`__\$([a-f0-9]+)\$__`) - if err != nil { - panic(err) - } - for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { - depPattern := match[1] - d.buildDepTrees(depPattern, d.contracts[depPattern]) - node.nodes = append(node.nodes, d.subtrees[depPattern]) - - // this library can't be a root dependency if it is referenced by other contracts. - delete(d.roots, depPattern) - } - d.subtrees[pattern] = node -} - -// BuildDepTrees will compute a set of dependency trees from a set of unlinked contracts. The root of each tree -// corresponds to a contract/library that is not referenced as a dependency anywhere else. Children of each node are -// its library dependencies. -func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode) { - // before the trees of dependencies are known, consider that any provided contract could be a root. - for pattern, _ := range d.contracts { - d.roots[pattern] = struct{}{} - } - - // recursively build each part of the dependency subtree by starting at - for pattern, contract := range d.contracts { - d.buildDepTrees(pattern, contract) - } - for pattern, _ := range d.roots { - roots = append(roots, d.subtrees[pattern]) - } - return roots -} - -func newDepTreeBuilder(overrides map[string]common.Address, contracts map[string]string) *depTreeBuilder { - return &depTreeBuilder{ - overrides: overrides, - contracts: contracts, - subtrees: make(map[string]*depTreeNode), - roots: make(map[string]struct{}), - } -} - -type deployFn func(input, deployer []byte) (common.Address, *types.Transaction, error) - -// depTreeDeployer is responsible for taking a dependency, deploying-and-linking its components in the proper -// order. A depTreeDeployer cannot be used after calling LinkAndDeploy other than to retrieve the deployment result. -type depTreeDeployer struct { - deployedAddrs map[string]common.Address - deployerTxs map[string]*types.Transaction - input map[string][]byte // map of the root contract pattern to the constructor input (if there is any) - deploy deployFn - err error -} - -// linkAndDeploy recursively deploys a contract/library: starting by linking/deploying its dependencies. -// The deployment result (deploy addresses/txs or an error) is stored in the depTreeDeployer object. -func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) { - // short-circuit further deployment of contracts if a previous deployment encountered an error. - if d.err != nil { - return - } - - // don't deploy contracts specified as overrides. don't deploy their dependencies. - if node.overrideAddr != nil { - return - } - - // if this contract/library depends on other libraries deploy them (and their dependencies) first - for _, childNode := range node.nodes { - d.linkAndDeploy(childNode) - } - // if we just deployed any prerequisite contracts, link their deployed addresses into the bytecode to produce - // a deployer bytecode for this contract. - deployerCode := node.unlinkedCode - for _, child := range node.nodes { - var linkAddr common.Address - if child.overrideAddr != nil { - linkAddr = *child.overrideAddr - } else { - linkAddr = d.deployedAddrs[child.pattern] - } - deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(linkAddr.String()[2:])) - } - - // Finally, deploy the contract. - addr, tx, err := d.deploy(d.input[node.pattern], common.Hex2Bytes(deployerCode)) - if err != nil { - d.err = err - } else { - d.deployedAddrs[node.pattern] = addr - d.deployerTxs[node.pattern] = tx - } -} - -// result returns a result for this deployment, or an error if it failed. -func (d *depTreeDeployer) result() (*DeploymentResult, error) { - if d.err != nil { - return nil, d.err - } - return &DeploymentResult{ - Txs: d.deployerTxs, - Addrs: d.deployedAddrs, - }, nil -} - -func newDepTreeDeployer(deploy deployFn) *depTreeDeployer { - return &depTreeDeployer{ - deploy: deploy, - deployedAddrs: make(map[string]common.Address), - deployerTxs: make(map[string]*types.Transaction)} -} - -// LinkAndDeploy deploys a specified set of contracts and their dependent -// libraries. If an error occurs, only contracts which were successfully -// deployed are returned in the result. -func LinkAndDeploy(deployParams DeploymentParams, deploy deployFn) (res *DeploymentResult, err error) { - unlinkedContracts := make(map[string]string) - accumRes := &DeploymentResult{ - Txs: make(map[string]*types.Transaction), - Addrs: make(map[string]common.Address), - } - for _, meta := range deployParams.Contracts { - unlinkedContracts[meta.Pattern] = meta.Bin[2:] - } - treeBuilder := newDepTreeBuilder(deployParams.Overrides, unlinkedContracts) - deps := treeBuilder.BuildDepTrees() - - for _, tr := range deps { - deployer := newDepTreeDeployer(deploy) - if deployParams.Inputs != nil { - deployer.input = map[string][]byte{tr.pattern: deployParams.Inputs[tr.pattern]} - } - deployer.linkAndDeploy(tr) - res, err := deployer.result() - if err != nil { - return accumRes, err - } - accumRes.Accumulate(res) - } - return accumRes, nil -} - // TODO: this will be generated as part of the bindings, contain the ABI (or metadata object?) and errors type ContractInstance struct { Address common.Address diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 3c24bec514ca..40c8712a750c 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -121,13 +121,13 @@ func TestDeploymentLibraries(t *testing.T) { if err != nil { t.Fatalf("failed to pack constructor: %v", err) } - deploymentParams := DeploymentParams{ + deploymentParams := bind.DeploymentParams{ Contracts: append(nested_libraries.C1LibraryDeps, nested_libraries.C1MetaData), Inputs: map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, Overrides: nil, } - res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) + res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { t.Fatalf("err: %+v\n", err) } @@ -180,11 +180,11 @@ func TestDeploymentWithOverrides(t *testing.T) { defer bindBackend.Backend.Close() // deploy some library deps - deploymentParams := DeploymentParams{ + deploymentParams := bind.DeploymentParams{ Contracts: nested_libraries.C1LibraryDeps, } - res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) + res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { t.Fatalf("err: %+v\n", err) } @@ -210,12 +210,12 @@ func TestDeploymentWithOverrides(t *testing.T) { } overrides := res.Addrs // deploy the contract - deploymentParams = DeploymentParams{ + deploymentParams = bind.DeploymentParams{ Contracts: []*bind.MetaData{nested_libraries.C1MetaData}, Inputs: map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, Overrides: overrides, } - res, err = LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) + res, err = bind.LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { t.Fatalf("err: %+v\n", err) } @@ -271,11 +271,11 @@ func TestEvents(t *testing.T) { t.Fatalf("error setting up testing env: %v", err) } - deploymentParams := DeploymentParams{ + deploymentParams := bind.DeploymentParams{ Contracts: []*bind.MetaData{events.CMetaData}, } - res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(txAuth, backend)) + res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(txAuth, backend)) if err != nil { t.Fatalf("error deploying contract for testing: %v", err) } @@ -387,11 +387,11 @@ func TestErrors(t *testing.T) { t.Fatalf("error setting up testing env: %v", err) } - deploymentParams := DeploymentParams{ + deploymentParams := bind.DeploymentParams{ Contracts: []*bind.MetaData{solc_errors.CMetaData}, } - res, err := LinkAndDeploy(deploymentParams, makeTestDeployer(txAuth, backend)) + res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(txAuth, backend)) if err != nil { t.Fatalf("error deploying contract for testing: %v", err) } From d53b218fe618a4ac98343c310147e681f3518674 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Sun, 15 Dec 2024 20:59:55 +0700 Subject: [PATCH 070/104] add some docs --- accounts/abi/bind/v2/lib.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index ae8cf91c1d57..50237839bcc5 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -25,13 +25,14 @@ import ( "github.com/ethereum/go-ethereum/event" ) -// TODO: this will be generated as part of the bindings, contain the ABI (or metadata object?) and errors +// ContractInstance represents a contract deployed on-chain that can be interacted with (filter for past logs, watch +// for new logs, call, transact). type ContractInstance struct { Address common.Address Backend bind.ContractBackend } -// TODO: adding docs soon (jwasinger) +// FilterEvents returns an EventIterator instance for filtering historical events based on the event id and a block range. func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { backend := instance.Backend c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) From eec95b60c9e25f8f2565402c29077995b83f9d6e Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 16 Dec 2024 13:28:19 +0700 Subject: [PATCH 071/104] move abigen2 specific bind code into BindV2. fix broken v1 tests --- accounts/abi/bind/base.go | 10 +++--- accounts/abi/bind/bind.go | 65 ++++++++++++++++++++------------------- 2 files changed, 38 insertions(+), 37 deletions(-) diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index bb675461481f..bd12cd0f87bc 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -470,11 +470,11 @@ func (c *BoundContract) FilterLogsById(opts *FilterOpts, eventID common.Hash, qu // FilterLogs filters contract logs for past blocks, returning the necessary // channels to construct a strongly typed bound iterator on top of them. -func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { +func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { return c.filterLogs(opts, c.abi.Events[name].ID, query...) } -func (c *BoundContract) filterLogs(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { +func (c *BoundContract) filterLogs(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { // Don't crash on a lazy user if opts == nil { opts = new(FilterOpts) @@ -519,17 +519,17 @@ func (c *BoundContract) filterLogs(opts *FilterOpts, eventID common.Hash, query // WatchLogs filters subscribes to contract logs for future blocks, returning a // subscription object that can be used to tear down the watcher. -func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { +func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { return c.watchLogs(opts, c.abi.Events[name].ID, query...) } // WatchLogsForId filters subscribes to contract logs for future blocks, returning a // subscription object that can be used to tear down the watcher. -func (c *BoundContract) WatchLogsForId(opts *WatchOpts, id common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { +func (c *BoundContract) WatchLogsForId(opts *WatchOpts, id common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { return c.watchLogs(opts, id, query...) } -func (c *BoundContract) watchLogs(opts *WatchOpts, eventID common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { +func (c *BoundContract) watchLogs(opts *WatchOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { // Don't crash on a lazy user if opts == nil { opts = new(WatchOpts) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index f5ddda240e65..a813296045b7 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -144,6 +144,35 @@ func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[strin call.Structured = true } } + + // map of contract name -> pattern + invertedLibs := make(map[string]string) + // assume that this is invertible/onto because I assume library names are unique now + // TODO: check that they've been sanitized at this point. + for pattern, name := range libs { + invertedLibs[name] = pattern + } + data.InvertedLibs = invertedLibs + + contractsBins := make(map[string]string) + for typ, contract := range data.Contracts { + pattern := invertedLibs[typ] + contractsBins[pattern] = contract.InputBin + } + builder := newDepTreeBuilder(nil, contractsBins) + roots, deps := builder.BuildDepTrees() + allNodes := append(roots, deps...) + for _, dep := range allNodes { + contractType := libs[dep.pattern] + for subDepPattern, _ := range dep.Flatten() { + if subDepPattern == dep.pattern { + continue + } + subDepType := libs[subDepPattern] + data.Contracts[contractType].AllLibraries[subDepType] = subDepPattern + } + } + buffer := new(bytes.Buffer) funcs := map[string]interface{}{ "bindtype": bindType, @@ -404,40 +433,12 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] contracts[types[i]].Library = ok } - // map of contract name -> pattern - invertedLibs := make(map[string]string) - // assume that this is invertible/onto because I assume library names are unique now - // TODO: check that they've been sanitized at this point. - for pattern, name := range libs { - invertedLibs[name] = pattern - } - - contractsBins := make(map[string]string) - for typ, contract := range contracts { - pattern := invertedLibs[typ] - contractsBins[pattern] = contract.InputBin - } - builder := newDepTreeBuilder(nil, contractsBins) - roots, deps := builder.BuildDepTrees() - allNodes := append(roots, deps...) - for _, dep := range allNodes { - contractType := libs[dep.pattern] - for subDepPattern, _ := range dep.Flatten() { - if subDepPattern == dep.pattern { - continue - } - subDepType := libs[subDepPattern] - contracts[contractType].AllLibraries[subDepType] = subDepPattern - } - } - // Generate the contract template data content and render it data := &tmplData{ - Package: pkg, - Contracts: contracts, - Libraries: libs, - InvertedLibs: invertedLibs, - Structs: structs, + Package: pkg, + Contracts: contracts, + Libraries: libs, + Structs: structs, } return data, nil } From a009c60ae8c75bbb74b79fc71039189ae38aca43 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 16 Dec 2024 14:08:46 +0700 Subject: [PATCH 072/104] export event names in bindings. remove added APIs Filter/Watch-Logs which take event ids. --- accounts/abi/bind/base.go | 12 +---------- accounts/abi/bind/source2.go.tpl | 4 +--- .../abi/bind/v2/internal/events/bindings.go | 12 ++--------- accounts/abi/bind/v2/lib.go | 17 ++++++++------- accounts/abi/bind/v2/lib_test.go | 21 +++++++++---------- 5 files changed, 23 insertions(+), 43 deletions(-) diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index bd12cd0f87bc..e78726856083 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -462,25 +462,15 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i return signedTx, nil } -// FilterLogsById filters contract logs for past blocks, returning the necessary -// channels to construct a strongly typed bound iterator on top of them. -func (c *BoundContract) FilterLogsById(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) { - return c.filterLogs(opts, eventID, query...) -} - // FilterLogs filters contract logs for past blocks, returning the necessary // channels to construct a strongly typed bound iterator on top of them. func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { - return c.filterLogs(opts, c.abi.Events[name].ID, query...) -} - -func (c *BoundContract) filterLogs(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { // Don't crash on a lazy user if opts == nil { opts = new(FilterOpts) } // Append the event selector to the query parameters and construct the topic set - query = append([][]interface{}{{eventID}}, query...) + query = append([][]interface{}{{c.abi.Events[name].ID}}, query...) topics, err := abi.MakeTopics(query...) if err != nil { return nil, nil, err diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index a3d099b56874..cbccf31630ab 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -120,9 +120,7 @@ var ( Raw *types.Log // Blockchain specific contextual infos } - func {{$contract.Type}}{{.Normalized.Name}}EventID() common.Hash { - return common.HexToHash("{{.Original.ID}}") - } + const {{$contract.Type}}{{.Normalized.Name}}EventName = "{{.Original.Name}}" func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log *types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) { event := "{{.Original.Name}}" diff --git a/accounts/abi/bind/v2/internal/events/bindings.go b/accounts/abi/bind/v2/internal/events/bindings.go index c8c3944d95df..8331c9864ce1 100644 --- a/accounts/abi/bind/v2/internal/events/bindings.go +++ b/accounts/abi/bind/v2/internal/events/bindings.go @@ -129,13 +129,9 @@ type CBasic1 struct { Raw *types.Log // Blockchain specific contextual infos } -func CBasic1EventID() common.Hash { - return common.HexToHash("0x8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd207") -} +const CBasic1EventName = "basic1" func (_C *C) UnpackBasic1Event(log *types.Log) (*CBasic1, error) { - // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. - // and we only need normalized name when dealing with generated go symbols. event := "basic1" if log.Topics[0] != _C.abi.Events[event].ID { return nil, errors.New("event signature mismatch") @@ -166,13 +162,9 @@ type CBasic2 struct { Raw *types.Log // Blockchain specific contextual infos } -func CBasic2EventID() common.Hash { - return common.HexToHash("0x3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e") -} +const CBasic2EventName = "basic2" func (_C *C) UnpackBasic2Event(log *types.Log) (*CBasic2, error) { - // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. - // and we only need normalized name when dealing with generated go symbols. event := "basic2" if log.Topics[0] != _C.abi.Events[event].ID { return nil, errors.New("event signature mismatch") diff --git a/accounts/abi/bind/v2/lib.go b/accounts/abi/bind/v2/lib.go index 50237839bcc5..9d7c5e9739cf 100644 --- a/accounts/abi/bind/v2/lib.go +++ b/accounts/abi/bind/v2/lib.go @@ -30,13 +30,14 @@ import ( type ContractInstance struct { Address common.Address Backend bind.ContractBackend + abi abi.ABI } // FilterEvents returns an EventIterator instance for filtering historical events based on the event id and a block range. -func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { +func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, eventName string, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) { backend := instance.Backend - c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) - logs, sub, err := c.FilterLogsById(opts, eventID, topics...) + c := bind.NewBoundContract(instance.Address, instance.abi, backend, backend, backend) + logs, sub, err := c.FilterLogs(opts, eventName, topics...) if err != nil { return nil, err } @@ -47,10 +48,10 @@ func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, even // contract to be intercepted, unpacked, and forwarded to sink. If // unpack returns an error, the returned subscription is closed with the // error. -func WatchEvents[T any](instance *ContractInstance, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { +func WatchEvents[T any](instance *ContractInstance, opts *bind.WatchOpts, eventName string, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) { backend := instance.Backend - c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) - logs, sub, err := c.WatchLogsForId(opts, eventID, topics...) + c := bind.NewBoundContract(instance.Address, instance.abi, backend, backend, backend) + logs, sub, err := c.WatchLogs(opts, eventName, topics...) if err != nil { return nil, err } @@ -159,7 +160,7 @@ func Transact(instance *ContractInstance, opts *bind.TransactOpts, input []byte) addr = instance.Address backend = instance.Backend ) - c := bind.NewBoundContract(addr, abi.ABI{}, backend, backend, backend) + c := bind.NewBoundContract(addr, instance.abi, backend, backend, backend) return c.RawTransact(opts, input) } @@ -167,7 +168,7 @@ func Transact(instance *ContractInstance, opts *bind.TransactOpts, input []byte) // provided abi-encoded input (or nil). func Call[T any](instance *ContractInstance, opts *bind.CallOpts, packedInput []byte, unpack func([]byte) (*T, error)) (*T, error) { backend := instance.Backend - c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend) + c := bind.NewBoundContract(instance.Address, instance.abi, backend, backend, backend) packedOutput, err := c.CallRaw(opts, packedInput) if err != nil { return nil, err diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 40c8712a750c..c3e9de3536c5 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -290,9 +290,11 @@ func TestEvents(t *testing.T) { t.Fatalf("error instantiating contract instance: %v", err) } - boundContract := ContractInstance{ + ctrctABI, _ := events.CMetaData.GetAbi() + ctrctInstance := ContractInstance{ res.Addrs[events.CMetaData.Pattern], backend, + *ctrctABI, } newCBasic1Ch := make(chan *events.CBasic1) @@ -301,23 +303,19 @@ func TestEvents(t *testing.T) { Start: nil, Context: context.Background(), } - sub1, err := WatchEvents(&boundContract, watchOpts, events.CBasic1EventID(), ctrct.UnpackBasic1Event, newCBasic1Ch) + sub1, err := WatchEvents(&ctrctInstance, watchOpts, events.CBasic1EventName, ctrct.UnpackBasic1Event, newCBasic1Ch) if err != nil { t.Fatalf("WatchEvents returned error: %v", err) } - sub2, err := WatchEvents(&boundContract, watchOpts, events.CBasic2EventID(), ctrct.UnpackBasic2Event, newCBasic2Ch) + sub2, err := WatchEvents(&ctrctInstance, watchOpts, events.CBasic2EventName, ctrct.UnpackBasic2Event, newCBasic2Ch) if err != nil { t.Fatalf("WatchEvents returned error: %v", err) } defer sub1.Unsubscribe() defer sub2.Unsubscribe() - crtctInstance := &ContractInstance{ - Address: res.Addrs[events.CMetaData.Pattern], - Backend: backend, - } packedInput, _ := ctrct.PackEmitMulti() - tx, err := Transact(crtctInstance, txAuth, packedInput) + tx, err := Transact(&ctrctInstance, txAuth, packedInput) if err != nil { t.Fatalf("failed to send transaction: %v", err) } @@ -356,11 +354,11 @@ done: Start: 0, Context: context.Background(), } - it, err := FilterEvents[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), ctrct.UnpackBasic1Event) + it, err := FilterEvents[events.CBasic1](&ctrctInstance, filterOpts, events.CBasic1EventName, ctrct.UnpackBasic1Event) if err != nil { t.Fatalf("error filtering logs %v\n", err) } - it2, err := FilterEvents[events.CBasic2](crtctInstance, filterOpts, events.CBasic2EventID(), ctrct.UnpackBasic2Event) + it2, err := FilterEvents[events.CBasic2](&ctrctInstance, filterOpts, events.CBasic2EventName, ctrct.UnpackBasic2Event) if err != nil { t.Fatalf("error filtering logs %v\n", err) } @@ -409,7 +407,8 @@ func TestErrors(t *testing.T) { } packedInput, _ = ctrct.PackFoo() - instance := ContractInstance{res.Addrs[solc_errors.CMetaData.Pattern], backend} + ctrctABI, _ := solc_errors.CMetaData.GetAbi() + instance := ContractInstance{res.Addrs[solc_errors.CMetaData.Pattern], backend, *ctrctABI} _, err = Call[struct{}](&instance, opts, packedInput, func(packed []byte) (*struct{}, error) { return nil, nil }) if err == nil { t.Fatalf("expected call to fail") From a30ccd5defb3c3015bf3ab05a725f9a8a63b098b Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 16 Dec 2024 15:06:32 +0700 Subject: [PATCH 073/104] update dep tree --- accounts/abi/bind/bind.go | 8 ++-- accounts/abi/bind/dep_tree.go | 83 +++++++++++++++-------------------- 2 files changed, 39 insertions(+), 52 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index a813296045b7..615c6e8d97a5 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -70,10 +70,6 @@ func isKeyWord(arg string) bool { return true } -func add(val1, val2 int) int { - return val1 + val2 -} - // Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant // to be used as is in client code, but rather as an intermediate struct which // enforces compile time type safety and naming convention as opposed to having to @@ -179,7 +175,9 @@ func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[strin "bindtopictype": bindTopicType, "capitalise": capitalise, "decapitalise": decapitalise, - "add": add, + "add": func(val1, val2 int) int { + return val1 + val2 + }, } tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSourceV2)) if err := tmpl.Execute(buffer, data); err != nil { diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index 21e5bbf685cf..7f3d80a318bb 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -7,28 +7,22 @@ import ( "strings" ) -// ContractDeployParams represents state needed to deploy a contract: -// the metdata and constructor input (which can be nil if no input is specified). -type ContractDeployParams struct { - Meta *MetaData - // Input is the ABI-encoded constructor input for the contract deployment. - Input []byte -} - // DeploymentParams represents parameters needed to deploy a -// set of contracts, their dependency libraries. It takes an optional override -// list to specify libraries that have already been deployed on-chain. +// set of contracts. It takes an optional override +// list to specify contracts/libraries that have already been deployed on-chain. type DeploymentParams struct { Contracts []*MetaData - Inputs map[string][]byte + // map of solidity library pattern to constructor input. + Inputs map[string][]byte // Overrides is an optional map of pattern to deployment address. // Contracts/libraries that refer to dependencies in the override // set are linked to the provided address (an already-deployed contract). Overrides map[string]common.Address } -// DeploymentResult contains the relevant information from the deployment of -// multiple contracts: their deployment txs and addresses. +// DeploymentResult encapsulates information about the result of the deployment +// of a set of contracts: the pending deployment transactions, and the addresses +// where the contracts will be deployed at. type DeploymentResult struct { // map of contract library pattern -> deploy transaction Txs map[string]*types.Transaction @@ -36,6 +30,7 @@ type DeploymentResult struct { Addrs map[string]common.Address } +// Accumulate merges two DeploymentResult objects together. func (d *DeploymentResult) Accumulate(other *DeploymentResult) { for pattern, tx := range other.Txs { d.Txs[pattern] = tx @@ -45,8 +40,8 @@ func (d *DeploymentResult) Accumulate(other *DeploymentResult) { } } -// depTreeBuilder turns a set of unlinked contracts and their dependent libraries into a collection of trees -// representing the relation of their dependencies. +// depTreeBuilder turns a set of unlinked contracts libraries into a set of one +// or more dependency trees. type depTreeBuilder struct { overrides map[string]common.Address // map of pattern to unlinked contract bytecode (for libraries or contracts) @@ -67,8 +62,7 @@ type depTreeNode struct { overrideAddr *common.Address } -// returns the subtree as a map of pattern -> unlinked contract bytecode. it excludes the code of the top-level -// node. +// Flatten returns the subtree into a map of pattern -> unlinked contract bytecode. func (n *depTreeNode) Flatten() (res map[string]string) { res = map[string]string{n.pattern: n.unlinkedCode} for _, child := range n.children { @@ -81,6 +75,7 @@ func (n *depTreeNode) Flatten() (res map[string]string) { return res } +// buildDepTrees is the internal version of BuildDepTrees that recursively calls itself. func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { // if the node is in the subtree set already, it has already been fully recursed/built so we can bail out. if _, ok := d.subtrees[pattern]; ok { @@ -93,7 +88,7 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { if addr, ok := d.overrides[pattern]; ok { node.overrideAddr = &addr } - // iterate each referenced library in the unlinked code, recurse and built its subtree. + // iterate each referenced library in the unlinked code, recurse and build its subtree. reMatchSpecificPattern, err := regexp.Compile(`__\$([a-f0-9]+)\$__`) if err != nil { panic(err) @@ -111,14 +106,12 @@ func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { // BuildDepTrees will compute a set of dependency trees from a set of unlinked contracts. The root of each tree // corresponds to a contract/library that is not referenced as a dependency anywhere else. Children of each node are -// its library dependencies. +// its library dependencies. It returns nodes that are roots of a dependency tree and nodes that aren't. func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode, nonRoots []*depTreeNode) { // before the trees of dependencies are known, consider that any provided contract could be a root. for pattern, _ := range d.contracts { d.roots[pattern] = struct{}{} } - - // recursively build each part of the dependency subtree by starting at for pattern, contract := range d.contracts { d.buildDepTrees(pattern, contract) } @@ -141,7 +134,9 @@ func newDepTreeBuilder(overrides map[string]common.Address, contracts map[string } } -type deployFn func(input, deployer []byte) (common.Address, *types.Transaction, error) +// DeployFn deploys a contract given a deployer and optional input. It returns +// the address and a pending transaction, or an error if the deployment failed. +type DeployFn func(input, deployer []byte) (common.Address, *types.Transaction, error) // depTreeDeployer is responsible for taking a dependency, deploying-and-linking its components in the proper // order. A depTreeDeployer cannot be used after calling LinkAndDeploy other than to retrieve the deployment result. @@ -149,26 +144,22 @@ type depTreeDeployer struct { deployedAddrs map[string]common.Address deployerTxs map[string]*types.Transaction input map[string][]byte // map of the root contract pattern to the constructor input (if there is any) - deploy deployFn - err error + deploy DeployFn } -// linkAndDeploy recursively deploys a contract/library: starting by linking/deploying its dependencies. +// linkAndDeploy recursively deploys a contract and its dependencies: starting by linking/deploying its dependencies. // The deployment result (deploy addresses/txs or an error) is stored in the depTreeDeployer object. -func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) { - // short-circuit further deployment of contracts if a previous deployment encountered an error. - if d.err != nil { - return - } - +func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) error { // don't deploy contracts specified as overrides. don't deploy their dependencies. if node.overrideAddr != nil { - return + return nil } // if this contract/library depends on other libraries deploy them (and their dependencies) first for _, childNode := range node.children { - d.linkAndDeploy(childNode) + if err := d.linkAndDeploy(childNode); err != nil { + return err + } } // if we just deployed any prerequisite contracts, link their deployed addresses into the bytecode to produce // a deployer bytecode for this contract. @@ -186,25 +177,23 @@ func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) { // Finally, deploy the contract. addr, tx, err := d.deploy(d.input[node.pattern], common.Hex2Bytes(deployerCode)) if err != nil { - d.err = err - } else { - d.deployedAddrs[node.pattern] = addr - d.deployerTxs[node.pattern] = tx + return err } + + d.deployedAddrs[node.pattern] = addr + d.deployerTxs[node.pattern] = tx + return nil } // result returns a result for this deployment, or an error if it failed. -func (d *depTreeDeployer) result() (*DeploymentResult, error) { - if d.err != nil { - return nil, d.err - } +func (d *depTreeDeployer) result() *DeploymentResult { return &DeploymentResult{ Txs: d.deployerTxs, Addrs: d.deployedAddrs, - }, nil + } } -func newDepTreeDeployer(deploy deployFn) *depTreeDeployer { +func newDepTreeDeployer(deploy DeployFn) *depTreeDeployer { return &depTreeDeployer{ deploy: deploy, deployedAddrs: make(map[string]common.Address), @@ -214,7 +203,7 @@ func newDepTreeDeployer(deploy deployFn) *depTreeDeployer { // LinkAndDeploy deploys a specified set of contracts and their dependent // libraries. If an error occurs, only contracts which were successfully // deployed are returned in the result. -func LinkAndDeploy(deployParams DeploymentParams, deploy deployFn) (res *DeploymentResult, err error) { +func LinkAndDeploy(deployParams DeploymentParams, deploy DeployFn) (res *DeploymentResult, err error) { unlinkedContracts := make(map[string]string) accumRes := &DeploymentResult{ Txs: make(map[string]*types.Transaction), @@ -231,12 +220,12 @@ func LinkAndDeploy(deployParams DeploymentParams, deploy deployFn) (res *Deploym if deployParams.Inputs != nil { deployer.input = map[string][]byte{tr.pattern: deployParams.Inputs[tr.pattern]} } - deployer.linkAndDeploy(tr) - res, err := deployer.result() + err := deployer.linkAndDeploy(tr) + res := deployer.result() + accumRes.Accumulate(res) if err != nil { return accumRes, err } - accumRes.Accumulate(res) } return accumRes, nil } From ff2050f9a293bde4764a26b878167ba95f07ec2d Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 16 Dec 2024 15:07:54 +0700 Subject: [PATCH 074/104] remove TODO comment about adding a test case that I have added --- accounts/abi/bind/dep_tree_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/accounts/abi/bind/dep_tree_test.go b/accounts/abi/bind/dep_tree_test.go index 06ba6cc5edf5..3e02599822d5 100644 --- a/accounts/abi/bind/dep_tree_test.go +++ b/accounts/abi/bind/dep_tree_test.go @@ -282,5 +282,4 @@ func TestContractLinking(t *testing.T) { map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}, }}) - // TODO: same as the above case but nested one level of dependencies deep (?) } From fae212e50f291a66a033e1af0f04030e72dc2085 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 16 Dec 2024 15:21:06 +0700 Subject: [PATCH 075/104] regenerate bindings --- accounts/abi/bind/v2/internal/db/bindings.go | 12 +--- .../bind/v2/internal/solc_errors/bindings.go | 70 ++++++++++++++++++- 2 files changed, 71 insertions(+), 11 deletions(-) diff --git a/accounts/abi/bind/v2/internal/db/bindings.go b/accounts/abi/bind/v2/internal/db/bindings.go index c288910584bd..a6e1aeed42a3 100644 --- a/accounts/abi/bind/v2/internal/db/bindings.go +++ b/accounts/abi/bind/v2/internal/db/bindings.go @@ -184,13 +184,9 @@ type DBInsert struct { Raw *types.Log // Blockchain specific contextual infos } -func DBInsertEventID() common.Hash { - return common.HexToHash("0x8b39ff47dca36ab5b8b80845238af53aa579625ac7fb173dc09376adada41769") -} +const DBInsertEventName = "Insert" func (_DB *DB) UnpackInsertEvent(log *types.Log) (*DBInsert, error) { - // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. - // and we only need normalized name when dealing with generated go symbols. event := "Insert" if log.Topics[0] != _DB.abi.Events[event].ID { return nil, errors.New("event signature mismatch") @@ -221,13 +217,9 @@ type DBKeyedInsert struct { Raw *types.Log // Blockchain specific contextual infos } -func DBKeyedInsertEventID() common.Hash { - return common.HexToHash("0x40bed843c6c5f72002f9b469cf4c1ee9f7fb1eb48f091c1267970f98522ac02d") -} +const DBKeyedInsertEventName = "KeyedInsert" func (_DB *DB) UnpackKeyedInsertEvent(log *types.Log) (*DBKeyedInsert, error) { - // TODO: okay to index by the original name here? I think so because we assume that the abi json is well-formed. - // and we only need normalized name when dealing with generated go symbols. event := "KeyedInsert" if log.Topics[0] != _DB.abi.Events[event].ID { return nil, errors.New("event signature mismatch") diff --git a/accounts/abi/bind/v2/internal/solc_errors/bindings.go b/accounts/abi/bind/v2/internal/solc_errors/bindings.go index af9cf68f8744..5b1a0cba5e6f 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/bindings.go +++ b/accounts/abi/bind/v2/internal/solc_errors/bindings.go @@ -30,7 +30,7 @@ var CLibraryDeps = []*bind.MetaData{} 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: "0x6080604052348015600e575f80fd5b506101c58061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063b0a378b014610038578063bfb4ebcf14610042575b5f80fd5b61004061004c565b005b61004a610092565b005b5f6001600260036040517fd233a24f00000000000000000000000000000000000000000000000000000000815260040161008994939291906100ef565b60405180910390fd5b5f600160025f6040517fbb6a82f10000000000000000000000000000000000000000000000000000000081526004016100ce949392919061014c565b60405180910390fd5b5f819050919050565b6100e9816100d7565b82525050565b5f6080820190506101025f8301876100e0565b61010f60208301866100e0565b61011c60408301856100e0565b61012960608301846100e0565b95945050505050565b5f8115159050919050565b61014681610132565b82525050565b5f60808201905061015f5f8301876100e0565b61016c60208301866100e0565b61017960408301856100e0565b610186606083018461013d565b9594505050505056fea26469706673582212203f89da086f6d7e52e75f82a20ebbf7337f166a6dbae309180c8bb95e1a157e6e64736f6c634300081a0033", + Bin: "0x6080604052348015600e575f80fd5b506101c58061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610034575f3560e01c8063b0a378b014610038578063bfb4ebcf14610042575b5f80fd5b61004061004c565b005b61004a610092565b005b5f6001600260036040517fd233a24f00000000000000000000000000000000000000000000000000000000815260040161008994939291906100ef565b60405180910390fd5b5f600160025f6040517fbb6a82f10000000000000000000000000000000000000000000000000000000081526004016100ce949392919061014c565b60405180910390fd5b5f819050919050565b6100e9816100d7565b82525050565b5f6080820190506101025f8301876100e0565b61010f60208301866100e0565b61011c60408301856100e0565b61012960608301846100e0565b95945050505050565b5f8115159050919050565b61014681610132565b82525050565b5f60808201905061015f5f8301876100e0565b61016c60208301866100e0565b61017960408301856100e0565b610186606083018461013d565b9594505050505056fea264697066735822122043974fbdd5c75b36bb8fe9dd68c112de4d094a0d8626d74e03edd5e48f18118164736f6c634300081a0033", } // C is an auto generated Go binding around an Ethereum contract. @@ -93,6 +93,7 @@ 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 @@ -114,6 +115,73 @@ 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 +} + +var C2LibraryDeps = []*bind.MetaData{} + +// 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, error) { + return _C2.abi.Pack("") +} + +// 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 From 2c76a7112f8fe89c9443a74606ee4faaa6d8dad5 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 16 Dec 2024 15:35:49 +0700 Subject: [PATCH 076/104] add comment for tmplError struct and remove unused v2 backend interface --- accounts/abi/bind/template.go | 2 ++ accounts/abi/bind/v2/backend.go | 37 --------------------------------- 2 files changed, 2 insertions(+), 37 deletions(-) delete mode 100644 accounts/abi/bind/v2/backend.go diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index 7481bf06f656..be941d0114d8 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -64,6 +64,8 @@ type tmplEvent struct { Normalized abi.Event // Normalized version of the parsed fields } +// tmplError is a wrapper around an abi.Error that contains a few preprocessed +// and cached data fields. type tmplError struct { Original abi.Error Normalized abi.Error diff --git a/accounts/abi/bind/v2/backend.go b/accounts/abi/bind/v2/backend.go deleted file mode 100644 index 4f20c89e181e..000000000000 --- a/accounts/abi/bind/v2/backend.go +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright 2024 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package v2 - -import ( - "context" - "math/big" - - "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -type BackendV2 interface { - SuggestGasPrice(ctx context.Context) (*big.Int, error) - PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) - PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) - SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) - HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) - SendTransaction(ctx context.Context, tx *types.Transaction) error - SuggestGasTipCap(ctx context.Context) (*big.Int, error) - EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error) -} From 78202cd7ea671873ac761c5966586ca95da86e31 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 16 Dec 2024 15:50:26 +0700 Subject: [PATCH 077/104] remove field that I added to abi.Error and never used --- accounts/abi/error.go | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/accounts/abi/error.go b/accounts/abi/error.go index 203aab04036a..8e50112ec5df 100644 --- a/accounts/abi/error.go +++ b/accounts/abi/error.go @@ -38,8 +38,6 @@ type Error struct { // ID returns the canonical representation of the error's signature used by the // abi definition to identify event names and types. ID common.Hash - - Selector string } func NewError(name string, inputs Arguments) Error { @@ -71,12 +69,11 @@ func NewError(name string, inputs Arguments) Error { id := common.BytesToHash(crypto.Keccak256([]byte(sig))) return Error{ - Name: name, - Inputs: inputs, - str: str, - Sig: sig, - ID: id, - Selector: fmt.Sprintf("%x", id[0:4]), + Name: name, + Inputs: inputs, + str: str, + Sig: sig, + ID: id, } } From 36ecad057fdc4f112ed3c444bcb57bc8ec9c9c35 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 17 Dec 2024 17:25:47 +0700 Subject: [PATCH 078/104] wip... --- accounts/abi/bind/bind.go | 223 ++++++++++++++++++++++++++++++++++ accounts/abi/bind/template.go | 20 ++- 2 files changed, 242 insertions(+), 1 deletion(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 615c6e8d97a5..d1e0a39a32bd 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -99,6 +99,229 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] return string(code), nil } +type binder struct { + // contracts is the map of each individual contract requested binding + contracts map[string]*tmplContractV2 + + // structs is the map of all redeclared structs shared by passed contracts. + structs map[string]*tmplStruct + + // isLib is the map used to flag each encountered library as such + isLib map[string]struct{} + + // identifiers are used to detect duplicated identifiers of functions + // and events. For all calls, transacts and events, abigen will generate + // corresponding bindings. However we have to ensure there is no + // identifier collisions in the bindings of these categories. + callIdentifiers map[string]bool + eventIdentifiers map[string]bool + errorIdentifiers map[string]bool + + aliases map[string]string +} + +func (b *binder) registerIdentifier(identifiers map[string]bool, original string) (normalized string, err error) { + normalized = alias(b.aliases, methodNormalizer(original)) + // Name shouldn't start with a digit. It will make the generated code invalid. + if len(normalized) > 0 && unicode.IsDigit(rune(normalized[0])) { + normalized = fmt.Sprintf("E%s", normalized) + normalized = abi.ResolveNameConflict(normalized, func(name string) bool { + _, ok := identifiers[name] + return ok + }) + } + + if _, ok := identifiers[normalized]; ok { + return "", fmt.Errorf("duplicate symbol '%s'", normalized) + } + identifiers[normalized] = true + return normalized, nil +} + +func (b *binder) RegisterCallIdentifier(id string) (string, error) { + return b.registerIdentifier(b.callIdentifiers, id) +} + +func (b *binder) RegisterEventIdentifier(id string) (string, error) { + return b.registerIdentifier(b.eventIdentifiers, id) +} + +func (b *binder) RegisterErrorIdentifier(id string) (string, error) { + return b.registerIdentifier(b.errorIdentifiers, id) +} + +func (b *binder) BindStructType(typ abi.Type) { + bindStructType(typ, b.structs) +} + +type contractBinder struct { + binder *binder + calls map[string]*tmplMethod + transacts map[string]*tmplMethod + events map[string]*tmplEvent + errors map[string]*tmplError +} + +func bindArguments() { + +} + +func (cb *contractBinder) bindMethod(original abi.Method) error { + normalized := original + normalizedName, err := cb.binder.RegisterCallIdentifier(original.Name) + if err != nil { + return err + } + + normalized.Name = normalizedName + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" || isKeyWord(input.Name) { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + if hasStruct(input.Type) { + cb.binder.BindStructType(input.Type) + } + } + normalized.Outputs = make([]abi.Argument, len(original.Outputs)) + copy(normalized.Outputs, original.Outputs) + for j, output := range normalized.Outputs { + if output.Name != "" { + normalized.Outputs[j].Name = capitalise(output.Name) + } + if hasStruct(output.Type) { + cb.binder.BindStructType(output.Type) + } + } + + cb.calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} + return nil +} + +func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Arguments) abi.Arguments { + normalizedArguments := make([]abi.Argument, len(originalInputs)) + used := make(map[string]bool) + + for i, input := range normalizedArguments { + if input.Name == "" || isKeyWord(input.Name) { + normalizedArguments[i].Name = fmt.Sprintf("arg%d", i) + } + for index := 0; ; index++ { + if !used[capitalise(normalizedArguments[i].Name)] { + used[capitalise(normalizedArguments[i].Name)] = true + break + } + normalizedArguments[i].Name = fmt.Sprintf("%s%d", normalizedArguments[i].Name, index) + } + if hasStruct(input.Type) { + cb.binder.BindStructType(input.Type) + } + } + return normalizedArguments +} + +func (cb *contractBinder) bindEvent(original abi.Event) error { + // Skip anonymous events as they don't support explicit filtering + if original.Anonymous { + return nil + } + normalizedName, err := cb.binder.RegisterEventIdentifier(original.Name) + if err != nil { + return err + } + + normalized := original + normalized.Name = normalizedName + normalized.Inputs = cb.normalizeErrorOrEventFields(original.Inputs) + cb.events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} + return nil +} + +func (cb *contractBinder) bindError(original abi.Error) error { + normalizedName, err := cb.binder.RegisterErrorIdentifier(original.Name) + if err != nil { + return err + } + + normalized := original + normalized.Name = normalizedName + normalized.Inputs = cb.normalizeErrorOrEventFields(original.Inputs) + cb.errors[original.Name] = &tmplError{Original: original, Normalized: normalized} + return nil +} + +func BindV22(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { + + // TODO: validate each alias (ensure it doesn't begin with a digit or other invalid character) + + b := binder{} + for i := 0; i < len(types); i++ { + // Parse the actual ABI to generate the binding for + evmABI, err := abi.JSON(strings.NewReader(abis[i])) + if err != nil { + return nil, err + } + // Strip any whitespace from the JSON ABI + strippedABI := strings.Map(func(r rune) rune { + if unicode.IsSpace(r) { + return -1 + } + return r + }, abis[i]) + + for _, input := range evmABI.Constructor.Inputs { + if hasStruct(input.Type) { + bindStructType(input.Type, b.structs) + } + } + + cb := contractBinder{} + for _, original := range evmABI.Methods { + if err := cb.bindMethod(original); err != nil { + // TODO: do something bad here... + } + } + + for _, original := range evmABI.Events { + if err := cb.bindEvent(original); err != nil { + // TODO: do something bad here... + } + } + for _, original := range evmABI.Errors { + if err := cb.bindError(original); err != nil { + // TODO: do something bad here... + } + } + + // replace this with a method call to cb (name it BoundContract()?) + b.contracts[types[i]] = &tmplContractV2{ + Type: capitalise(types[i]), + InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), + InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), + Constructor: evmABI.Constructor, + Calls: cb.calls, + Events: cb.events, + Errors: cb.errors, + Libraries: make(map[string]string), + } + } + + invertedLibs := make(map[string]string) // map of pattern -> unlinked bytecode + for pattern, name := range libs { + invertedLibs[name] = pattern + } + + data := tmplDataV2{ + Package: pkg, + Contracts: b.contracts, + InvertedLibs: invertedLibs, + Libraries: b + Structs: b.structs, + } + +} + func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { data, err := bind(types, abis, bytecodes, fsigs, pkg, libs, aliases) diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index be941d0114d8..d526dcbb4dc1 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -46,7 +46,25 @@ type tmplContract struct { Libraries map[string]string // Same as tmplData, but filtered to only keep direct deps that the contract needs AllLibraries map[string]string // same as Libraries, but all direct/indirect library dependencies Library bool // Indicator whether the contract is a library - Errors map[string]*tmplError +} + +type tmplContractV2 struct { + Type string // Type name of the main contract binding + InputABI string // JSON ABI used as the input to generate the binding from + InputBin string // Optional EVM bytecode used to generate deploy code from + Constructor abi.Method // Contract constructor for deploy parametrization + Calls map[string]*tmplMethod // All contract methods (excluding fallback, receive) + Events map[string]*tmplEvent // Contract events accessors + Libraries map[string]string // all direct/indirect library dependencies + Errors map[string]*tmplError // all errors defined +} + +type tmplDataV2 struct { + Package string // Name of the package to place the generated file in + Contracts map[string]*tmplContractV2 // List of contracts to generate into this file + Libraries map[string]string // Map the bytecode's link pattern to the library name + InvertedLibs map[string]string // map of the contract's name to the link pattern + Structs map[string]*tmplStruct // Contract struct type definitions } // tmplMethod is a wrapper around an abi.Method that contains a few preprocessed From 49a9c51049b1d81908528920455a0f306f692ec2 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Tue, 17 Dec 2024 19:57:03 +0700 Subject: [PATCH 079/104] refactor builds --- accounts/abi/bind/bind.go | 361 ++++++++++++++---- accounts/abi/bind/template.go | 9 +- .../bind/v2/internal/solc_errors/contract.sol | 2 +- cmd/abigen/main.go | 2 +- 4 files changed, 292 insertions(+), 82 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index d1e0a39a32bd..6ab327b60ae0 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -75,9 +75,250 @@ func isKeyWord(arg string) bool { // enforces compile time type safety and naming convention as opposed to having to // manually maintain hard coded strings that break on runtime. func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { - data, err := bind(types, abis, bytecodes, fsigs, pkg, libs, aliases) - if err != nil { - return "", err + var ( + // contracts is the map of each individual contract requested binding + contracts = make(map[string]*tmplContract) + + // structs is the map of all redeclared structs shared by passed contracts. + structs = make(map[string]*tmplStruct) + + // isLib is the map used to flag each encountered library as such + isLib = make(map[string]struct{}) + ) + for i := 0; i < len(types); i++ { + // Parse the actual ABI to generate the binding for + evmABI, err := abi.JSON(strings.NewReader(abis[i])) + if err != nil { + return "", err + } + // Strip any whitespace from the JSON ABI + strippedABI := strings.Map(func(r rune) rune { + if unicode.IsSpace(r) { + return -1 + } + return r + }, abis[i]) + + // Extract the call and transact methods; events, struct definitions; and sort them alphabetically + var ( + calls = make(map[string]*tmplMethod) + transacts = make(map[string]*tmplMethod) + events = make(map[string]*tmplEvent) + errors = make(map[string]*tmplError) + fallback *tmplMethod + receive *tmplMethod + + // identifiers are used to detect duplicated identifiers of functions + // and events. For all calls, transacts and events, abigen will generate + // corresponding bindings. However we have to ensure there is no + // identifier collisions in the bindings of these categories. + callIdentifiers = make(map[string]bool) + transactIdentifiers = make(map[string]bool) + eventIdentifiers = make(map[string]bool) + ) + + for _, input := range evmABI.Constructor.Inputs { + if hasStruct(input.Type) { + bindStructType(input.Type, structs) + } + } + + for _, original := range evmABI.Methods { + // Normalize the method for capital cases and non-anonymous inputs/outputs + normalized := original + normalizedName := methodNormalizer(alias(aliases, original.Name)) + // Ensure there is no duplicated identifier + var identifiers = callIdentifiers + if !original.IsConstant() { + identifiers = transactIdentifiers + } + // Name shouldn't start with a digit. It will make the generated code invalid. + if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { + normalizedName = fmt.Sprintf("M%s", normalizedName) + normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { + _, ok := identifiers[name] + return ok + }) + } + if identifiers[normalizedName] { + return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + } + identifiers[normalizedName] = true + + normalized.Name = normalizedName + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" || isKeyWord(input.Name) { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + if hasStruct(input.Type) { + bindStructType(input.Type, structs) + } + } + normalized.Outputs = make([]abi.Argument, len(original.Outputs)) + copy(normalized.Outputs, original.Outputs) + for j, output := range normalized.Outputs { + if output.Name != "" { + normalized.Outputs[j].Name = capitalise(output.Name) + } + if hasStruct(output.Type) { + bindStructType(output.Type, structs) + } + } + // Append the methods to the call or transact lists + if original.IsConstant() { + calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} + } else { + transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} + } + } + for _, original := range evmABI.Events { + // Skip anonymous events as they don't support explicit filtering + if original.Anonymous { + continue + } + // Normalize the event for capital cases and non-anonymous outputs + normalized := original + + // Ensure there is no duplicated identifier + normalizedName := methodNormalizer(alias(aliases, original.Name)) + // Name shouldn't start with a digit. It will make the generated code invalid. + if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { + normalizedName = fmt.Sprintf("E%s", normalizedName) + normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { + _, ok := eventIdentifiers[name] + return ok + }) + } + if eventIdentifiers[normalizedName] { + return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + } + eventIdentifiers[normalizedName] = true + normalized.Name = normalizedName + + used := make(map[string]bool) + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" || isKeyWord(input.Name) { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + // Event is a bit special, we need to define event struct in binding, + // ensure there is no camel-case-style name conflict. + for index := 0; ; index++ { + if !used[capitalise(normalized.Inputs[j].Name)] { + used[capitalise(normalized.Inputs[j].Name)] = true + break + } + normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index) + } + if hasStruct(input.Type) { + bindStructType(input.Type, structs) + } + } + // Append the event to the accumulator list + events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} + } + for _, original := range evmABI.Errors { + // TODO: I copied this from events (above in this function). I think it should be correct but not totally sure + // even if it is correct, should consider deduplicating this into its own function. + + // Normalize the error for capital cases and non-anonymous outputs + normalized := original + + // Ensure there is no duplicated identifier + normalizedName := methodNormalizer(alias(aliases, original.Name)) + // Name shouldn't start with a digit. It will make the generated code invalid. + if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { + normalizedName = fmt.Sprintf("E%s", normalizedName) + normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { + _, ok := eventIdentifiers[name] + return ok + }) + } + if eventIdentifiers[normalizedName] { + return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) + } + eventIdentifiers[normalizedName] = true + normalized.Name = normalizedName + + used := make(map[string]bool) + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" || isKeyWord(input.Name) { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + // Event is a bit special, we need to define event struct in binding, + // ensure there is no camel-case-style name conflict. + for index := 0; ; index++ { + if !used[capitalise(normalized.Inputs[j].Name)] { + used[capitalise(normalized.Inputs[j].Name)] = true + break + } + normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index) + } + if hasStruct(input.Type) { + bindStructType(input.Type, structs) + } + } + errors[original.Name] = &tmplError{Original: original, Normalized: normalized} + } + // Add two special fallback functions if they exist + if evmABI.HasFallback() { + fallback = &tmplMethod{Original: evmABI.Fallback} + } + if evmABI.HasReceive() { + receive = &tmplMethod{Original: evmABI.Receive} + } + + contracts[types[i]] = &tmplContract{ + Type: capitalise(types[i]), + InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), + InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), + Constructor: evmABI.Constructor, + Calls: calls, + Transacts: transacts, + Fallback: fallback, + Receive: receive, + Events: events, + Libraries: make(map[string]string), + AllLibraries: make(map[string]string), + } + + // Function 4-byte signatures are stored in the same sequence + // as types, if available. + if len(fsigs) > i { + contracts[types[i]].FuncSigs = fsigs[i] + } + // Parse library references. + for pattern, name := range libs { + matched, err := regexp.MatchString("__\\$"+pattern+"\\$__", contracts[types[i]].InputBin) + if err != nil { + log.Error("Could not search for pattern", "pattern", pattern, "contract", contracts[types[i]], "err", err) + } + if matched { + contracts[types[i]].Libraries[pattern] = name + // keep track that this type is a library + if _, ok := isLib[name]; !ok { + isLib[name] = struct{}{} + } + } + } + } + // Check if that type has already been identified as a library + for i := 0; i < len(types); i++ { + _, ok := isLib[types[i]] + contracts[types[i]].Library = ok + } + + // Generate the contract template data content and render it + data := &tmplData{ + Package: pkg, + Contracts: contracts, + Libraries: libs, + Structs: structs, } buffer := new(bytes.Buffer) @@ -106,9 +347,6 @@ type binder struct { // structs is the map of all redeclared structs shared by passed contracts. structs map[string]*tmplStruct - // isLib is the map used to flag each encountered library as such - isLib map[string]struct{} - // identifiers are used to detect duplicated identifiers of functions // and events. For all calls, transacts and events, abigen will generate // corresponding bindings. However we have to ensure there is no @@ -194,8 +432,29 @@ func (cb *contractBinder) bindMethod(original abi.Method) error { cb.binder.BindStructType(output.Type) } } + isStructured := structured(original.Outputs) + // if the call returns multiple values, coallesce them into a struct + if len(normalized.Outputs) > 1 { + // Build up dictionary of existing arg names. + keys := make(map[string]struct{}) + for _, o := range normalized.Outputs { + if o.Name != "" { + keys[strings.ToLower(o.Name)] = struct{}{} + } + } + // Assign names to anonymous fields. + for i, o := range normalized.Outputs { + if o.Name != "" { + continue + } + o.Name = capitalise(abi.ResolveNameConflict("arg", func(name string) bool { _, ok := keys[name]; return ok })) + normalized.Outputs[i] = o + keys[strings.ToLower(o.Name)] = struct{}{} + } + isStructured = true + } - cb.calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} + cb.calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: isStructured} return nil } @@ -251,16 +510,23 @@ func (cb *contractBinder) bindError(original abi.Error) error { return nil } -func BindV22(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { +func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { // TODO: validate each alias (ensure it doesn't begin with a digit or other invalid character) - b := binder{} + b := binder{ + contracts: make(map[string]*tmplContractV2), + structs: make(map[string]*tmplStruct), + callIdentifiers: nil, + eventIdentifiers: nil, + errorIdentifiers: nil, + aliases: nil, + } for i := 0; i < len(types); i++ { // Parse the actual ABI to generate the binding for evmABI, err := abi.JSON(strings.NewReader(abis[i])) if err != nil { - return nil, err + return "", err } // Strip any whitespace from the JSON ABI strippedABI := strings.Map(func(r rune) rune { @@ -279,18 +545,18 @@ func BindV22(types []string, abis []string, bytecodes []string, fsigs []map[stri cb := contractBinder{} for _, original := range evmABI.Methods { if err := cb.bindMethod(original); err != nil { - // TODO: do something bad here... + return "", err } } for _, original := range evmABI.Events { if err := cb.bindEvent(original); err != nil { - // TODO: do something bad here... + return "", err } } for _, original := range evmABI.Errors { if err := cb.bindError(original); err != nil { - // TODO: do something bad here... + return "", err } } @@ -307,71 +573,17 @@ func BindV22(types []string, abis []string, bytecodes []string, fsigs []map[stri } } - invertedLibs := make(map[string]string) // map of pattern -> unlinked bytecode + invertedLibs := make(map[string]string) for pattern, name := range libs { invertedLibs[name] = pattern } data := tmplDataV2{ - Package: pkg, - Contracts: b.contracts, - InvertedLibs: invertedLibs, - Libraries: b - Structs: b.structs, - } - -} - -func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { - data, err := bind(types, abis, bytecodes, fsigs, pkg, libs, aliases) - - if err != nil { - return "", err - } - for _, c := range data.Contracts { - // We want pack/unpack methods for all existing methods. - for name, t := range c.Transacts { - c.Calls[name] = t - } - c.Transacts = nil - - // Make sure we return one argument. If multiple exist - // merge them into a struct. - for _, call := range c.Calls { - if call.Structured { - continue - } - if len(call.Normalized.Outputs) < 2 { - continue - } - // Build up dictionary of existing arg names. - keys := make(map[string]struct{}) - for _, o := range call.Normalized.Outputs { - if o.Name != "" { - keys[strings.ToLower(o.Name)] = struct{}{} - } - } - // Assign names to anonymous fields. - for i, o := range call.Normalized.Outputs { - if o.Name != "" { - continue - } - o.Name = capitalise(abi.ResolveNameConflict("arg", func(name string) bool { _, ok := keys[name]; return ok })) - call.Normalized.Outputs[i] = o - keys[strings.ToLower(o.Name)] = struct{}{} - } - call.Structured = true - } - } - - // map of contract name -> pattern - invertedLibs := make(map[string]string) - // assume that this is invertible/onto because I assume library names are unique now - // TODO: check that they've been sanitized at this point. - for pattern, name := range libs { - invertedLibs[name] = pattern + Package: pkg, + Contracts: b.contracts, + Libraries: invertedLibs, + Structs: b.structs, } - data.InvertedLibs = invertedLibs contractsBins := make(map[string]string) for typ, contract := range data.Contracts { @@ -385,13 +597,13 @@ func BindV2(types []string, abis []string, bytecodes []string, fsigs []map[strin contractType := libs[dep.pattern] for subDepPattern, _ := range dep.Flatten() { if subDepPattern == dep.pattern { + // don't include the dep as a dependency of itself continue } subDepType := libs[subDepPattern] - data.Contracts[contractType].AllLibraries[subDepType] = subDepPattern + data.Contracts[contractType].Libraries[subDepType] = subDepPattern } } - buffer := new(bytes.Buffer) funcs := map[string]interface{}{ "bindtype": bindType, @@ -625,7 +837,6 @@ func bind(types []string, abis []string, bytecodes []string, fsigs []map[string] Events: events, Libraries: make(map[string]string), AllLibraries: make(map[string]string), - Errors: errors, } // Function 4-byte signatures are stored in the same sequence diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index d526dcbb4dc1..79051a5d66fe 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -60,11 +60,10 @@ type tmplContractV2 struct { } type tmplDataV2 struct { - Package string // Name of the package to place the generated file in - Contracts map[string]*tmplContractV2 // List of contracts to generate into this file - Libraries map[string]string // Map the bytecode's link pattern to the library name - InvertedLibs map[string]string // map of the contract's name to the link pattern - Structs map[string]*tmplStruct // Contract struct type definitions + Package string // Name of the package to place the generated file in + Contracts map[string]*tmplContractV2 // List of contracts to generate into this file + Libraries map[string]string // Map of the contract's name to link pattern + Structs map[string]*tmplStruct // Contract struct type definitions } // tmplMethod is a wrapper around an abi.Method that contains a few preprocessed diff --git a/accounts/abi/bind/v2/internal/solc_errors/contract.sol b/accounts/abi/bind/v2/internal/solc_errors/contract.sol index 541352a1d831..02c90e76eff1 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/contract.sol +++ b/accounts/abi/bind/v2/internal/solc_errors/contract.sol @@ -24,7 +24,7 @@ contract C { } // purpose of this is to test that generation of metadata for contract that emits one error produces valid Go code -contract C2 { +contract 2C2 { function Foo() public pure { revert BadThing({ arg1: uint256(0), diff --git a/cmd/abigen/main.go b/cmd/abigen/main.go index c182c42ab26c..d57317637296 100644 --- a/cmd/abigen/main.go +++ b/cmd/abigen/main.go @@ -213,7 +213,7 @@ func abigen(c *cli.Context) error { err error ) if c.IsSet(v2Flag.Name) { - code, err = bind.BindV2(types, abis, bins, sigs, c.String(pkgFlag.Name), libs, aliases) + code, err = bind.BindV2(types, abis, bins, c.String(pkgFlag.Name), libs, aliases) } else { code, err = bind.Bind(types, abis, bins, sigs, c.String(pkgFlag.Name), libs, aliases) } From 724792c0af36c1b60d9c4338911e30431a02cbb3 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 18 Dec 2024 14:06:33 +0700 Subject: [PATCH 080/104] tests pass --- accounts/abi/bind/bind.go | 309 +++---------------------------- accounts/abi/bind/source2.go.tpl | 10 +- accounts/abi/bind/v2/lib_test.go | 2 +- 3 files changed, 32 insertions(+), 289 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 6ab327b60ae0..91b52f95e84b 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -347,19 +347,11 @@ type binder struct { // structs is the map of all redeclared structs shared by passed contracts. structs map[string]*tmplStruct - // identifiers are used to detect duplicated identifiers of functions - // and events. For all calls, transacts and events, abigen will generate - // corresponding bindings. However we have to ensure there is no - // identifier collisions in the bindings of these categories. - callIdentifiers map[string]bool - eventIdentifiers map[string]bool - errorIdentifiers map[string]bool - aliases map[string]string } -func (b *binder) registerIdentifier(identifiers map[string]bool, original string) (normalized string, err error) { - normalized = alias(b.aliases, methodNormalizer(original)) +func (b *contractBinder) registerIdentifier(identifiers map[string]bool, original string) (normalized string, err error) { + normalized = alias(b.binder.aliases, methodNormalizer(original)) // Name shouldn't start with a digit. It will make the generated code invalid. if len(normalized) > 0 && unicode.IsDigit(rune(normalized[0])) { normalized = fmt.Sprintf("E%s", normalized) @@ -376,15 +368,15 @@ func (b *binder) registerIdentifier(identifiers map[string]bool, original string return normalized, nil } -func (b *binder) RegisterCallIdentifier(id string) (string, error) { +func (b *contractBinder) RegisterCallIdentifier(id string) (string, error) { return b.registerIdentifier(b.callIdentifiers, id) } -func (b *binder) RegisterEventIdentifier(id string) (string, error) { +func (b *contractBinder) RegisterEventIdentifier(id string) (string, error) { return b.registerIdentifier(b.eventIdentifiers, id) } -func (b *binder) RegisterErrorIdentifier(id string) (string, error) { +func (b *contractBinder) RegisterErrorIdentifier(id string) (string, error) { return b.registerIdentifier(b.errorIdentifiers, id) } @@ -393,20 +385,19 @@ func (b *binder) BindStructType(typ abi.Type) { } type contractBinder struct { - binder *binder - calls map[string]*tmplMethod - transacts map[string]*tmplMethod - events map[string]*tmplEvent - errors map[string]*tmplError -} - -func bindArguments() { + binder *binder + calls map[string]*tmplMethod + events map[string]*tmplEvent + errors map[string]*tmplError + callIdentifiers map[string]bool + eventIdentifiers map[string]bool + errorIdentifiers map[string]bool } func (cb *contractBinder) bindMethod(original abi.Method) error { normalized := original - normalizedName, err := cb.binder.RegisterCallIdentifier(original.Name) + normalizedName, err := cb.RegisterCallIdentifier(original.Name) if err != nil { return err } @@ -460,6 +451,7 @@ func (cb *contractBinder) bindMethod(original abi.Method) error { func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Arguments) abi.Arguments { normalizedArguments := make([]abi.Argument, len(originalInputs)) + copy(normalizedArguments, originalInputs) used := make(map[string]bool) for i, input := range normalizedArguments { @@ -485,7 +477,7 @@ func (cb *contractBinder) bindEvent(original abi.Event) error { if original.Anonymous { return nil } - normalizedName, err := cb.binder.RegisterEventIdentifier(original.Name) + normalizedName, err := cb.RegisterEventIdentifier(original.Name) if err != nil { return err } @@ -498,7 +490,7 @@ func (cb *contractBinder) bindEvent(original abi.Event) error { } func (cb *contractBinder) bindError(original abi.Error) error { - normalizedName, err := cb.binder.RegisterErrorIdentifier(original.Name) + normalizedName, err := cb.RegisterErrorIdentifier(original.Name) if err != nil { return err } @@ -515,12 +507,9 @@ func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs // TODO: validate each alias (ensure it doesn't begin with a digit or other invalid character) b := binder{ - contracts: make(map[string]*tmplContractV2), - structs: make(map[string]*tmplStruct), - callIdentifiers: nil, - eventIdentifiers: nil, - errorIdentifiers: nil, - aliases: nil, + contracts: make(map[string]*tmplContractV2), + structs: make(map[string]*tmplStruct), + aliases: make(map[string]string), } for i := 0; i < len(types); i++ { // Parse the actual ABI to generate the binding for @@ -542,7 +531,16 @@ func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs } } - cb := contractBinder{} + cb := contractBinder{ + binder: &b, + calls: make(map[string]*tmplMethod), + events: make(map[string]*tmplEvent), + errors: make(map[string]*tmplError), + + callIdentifiers: make(map[string]bool), + errorIdentifiers: make(map[string]bool), + eventIdentifiers: make(map[string]bool), + } for _, original := range evmABI.Methods { if err := cb.bindMethod(original); err != nil { return "", err @@ -626,255 +624,6 @@ func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs return string(code), nil } -func bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, libs map[string]string, aliases map[string]string) (*tmplData, error) { - var ( - // contracts is the map of each individual contract requested binding - contracts = make(map[string]*tmplContract) - - // structs is the map of all redeclared structs shared by passed contracts. - structs = make(map[string]*tmplStruct) - - // isLib is the map used to flag each encountered library as such - isLib = make(map[string]struct{}) - ) - for i := 0; i < len(types); i++ { - // Parse the actual ABI to generate the binding for - evmABI, err := abi.JSON(strings.NewReader(abis[i])) - if err != nil { - return nil, err - } - // Strip any whitespace from the JSON ABI - strippedABI := strings.Map(func(r rune) rune { - if unicode.IsSpace(r) { - return -1 - } - return r - }, abis[i]) - - // Extract the call and transact methods; events, struct definitions; and sort them alphabetically - var ( - calls = make(map[string]*tmplMethod) - transacts = make(map[string]*tmplMethod) - events = make(map[string]*tmplEvent) - errors = make(map[string]*tmplError) - fallback *tmplMethod - receive *tmplMethod - - // identifiers are used to detect duplicated identifiers of functions - // and events. For all calls, transacts and events, abigen will generate - // corresponding bindings. However we have to ensure there is no - // identifier collisions in the bindings of these categories. - callIdentifiers = make(map[string]bool) - transactIdentifiers = make(map[string]bool) - eventIdentifiers = make(map[string]bool) - ) - - for _, input := range evmABI.Constructor.Inputs { - if hasStruct(input.Type) { - bindStructType(input.Type, structs) - } - } - - for _, original := range evmABI.Methods { - // Normalize the method for capital cases and non-anonymous inputs/outputs - normalized := original - normalizedName := methodNormalizer(alias(aliases, original.Name)) - // Ensure there is no duplicated identifier - var identifiers = callIdentifiers - if !original.IsConstant() { - identifiers = transactIdentifiers - } - // Name shouldn't start with a digit. It will make the generated code invalid. - if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { - normalizedName = fmt.Sprintf("M%s", normalizedName) - normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { - _, ok := identifiers[name] - return ok - }) - } - if identifiers[normalizedName] { - return nil, fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) - } - identifiers[normalizedName] = true - - normalized.Name = normalizedName - normalized.Inputs = make([]abi.Argument, len(original.Inputs)) - copy(normalized.Inputs, original.Inputs) - for j, input := range normalized.Inputs { - if input.Name == "" || isKeyWord(input.Name) { - normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) - } - if hasStruct(input.Type) { - bindStructType(input.Type, structs) - } - } - normalized.Outputs = make([]abi.Argument, len(original.Outputs)) - copy(normalized.Outputs, original.Outputs) - for j, output := range normalized.Outputs { - if output.Name != "" { - normalized.Outputs[j].Name = capitalise(output.Name) - } - if hasStruct(output.Type) { - bindStructType(output.Type, structs) - } - } - // Append the methods to the call or transact lists - if original.IsConstant() { - calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} - } else { - transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} - } - } - for _, original := range evmABI.Events { - // Skip anonymous events as they don't support explicit filtering - if original.Anonymous { - continue - } - // Normalize the event for capital cases and non-anonymous outputs - normalized := original - - // Ensure there is no duplicated identifier - normalizedName := methodNormalizer(alias(aliases, original.Name)) - // Name shouldn't start with a digit. It will make the generated code invalid. - if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { - normalizedName = fmt.Sprintf("E%s", normalizedName) - normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { - _, ok := eventIdentifiers[name] - return ok - }) - } - if eventIdentifiers[normalizedName] { - return nil, fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) - } - eventIdentifiers[normalizedName] = true - normalized.Name = normalizedName - - used := make(map[string]bool) - normalized.Inputs = make([]abi.Argument, len(original.Inputs)) - copy(normalized.Inputs, original.Inputs) - for j, input := range normalized.Inputs { - if input.Name == "" || isKeyWord(input.Name) { - normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) - } - // Event is a bit special, we need to define event struct in binding, - // ensure there is no camel-case-style name conflict. - for index := 0; ; index++ { - if !used[capitalise(normalized.Inputs[j].Name)] { - used[capitalise(normalized.Inputs[j].Name)] = true - break - } - normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index) - } - if hasStruct(input.Type) { - bindStructType(input.Type, structs) - } - } - // Append the event to the accumulator list - events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} - } - for _, original := range evmABI.Errors { - // TODO: I copied this from events (above in this function). I think it should be correct but not totally sure - // even if it is correct, should consider deduplicating this into its own function. - - // Normalize the error for capital cases and non-anonymous outputs - normalized := original - - // Ensure there is no duplicated identifier - normalizedName := methodNormalizer(alias(aliases, original.Name)) - // Name shouldn't start with a digit. It will make the generated code invalid. - if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { - normalizedName = fmt.Sprintf("E%s", normalizedName) - normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { - _, ok := eventIdentifiers[name] - return ok - }) - } - if eventIdentifiers[normalizedName] { - return nil, fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) - } - eventIdentifiers[normalizedName] = true - normalized.Name = normalizedName - - used := make(map[string]bool) - normalized.Inputs = make([]abi.Argument, len(original.Inputs)) - copy(normalized.Inputs, original.Inputs) - for j, input := range normalized.Inputs { - if input.Name == "" || isKeyWord(input.Name) { - normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) - } - // Event is a bit special, we need to define event struct in binding, - // ensure there is no camel-case-style name conflict. - for index := 0; ; index++ { - if !used[capitalise(normalized.Inputs[j].Name)] { - used[capitalise(normalized.Inputs[j].Name)] = true - break - } - normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index) - } - if hasStruct(input.Type) { - bindStructType(input.Type, structs) - } - } - errors[original.Name] = &tmplError{Original: original, Normalized: normalized} - } - // Add two special fallback functions if they exist - if evmABI.HasFallback() { - fallback = &tmplMethod{Original: evmABI.Fallback} - } - if evmABI.HasReceive() { - receive = &tmplMethod{Original: evmABI.Receive} - } - - contracts[types[i]] = &tmplContract{ - Type: capitalise(types[i]), - InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), - InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), - Constructor: evmABI.Constructor, - Calls: calls, - Transacts: transacts, - Fallback: fallback, - Receive: receive, - Events: events, - Libraries: make(map[string]string), - AllLibraries: make(map[string]string), - } - - // Function 4-byte signatures are stored in the same sequence - // as types, if available. - if len(fsigs) > i { - contracts[types[i]].FuncSigs = fsigs[i] - } - // Parse library references. - for pattern, name := range libs { - matched, err := regexp.MatchString("__\\$"+pattern+"\\$__", contracts[types[i]].InputBin) - if err != nil { - log.Error("Could not search for pattern", "pattern", pattern, "contract", contracts[types[i]], "err", err) - } - if matched { - contracts[types[i]].Libraries[pattern] = name - // keep track that this type is a library - if _, ok := isLib[name]; !ok { - isLib[name] = struct{}{} - } - } - } - } - // Check if that type has already been identified as a library - for i := 0; i < len(types); i++ { - _, ok := isLib[types[i]] - contracts[types[i]].Library = ok - } - - // Generate the contract template data content and render it - data := &tmplData{ - Package: pkg, - Contracts: contracts, - Libraries: libs, - Structs: structs, - } - return data, nil -} - // bindBasicType converts basic solidity types(except array, slice and tuple) to Go ones. func bindBasicType(kind abi.Type) string { switch kind.T { diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index cbccf31630ab..89e4673def0c 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -34,7 +34,7 @@ var ( {{range $contract := .Contracts}} var {{$contract.Type}}LibraryDeps = []*bind.MetaData{ - {{range $name, $pattern := .AllLibraries -}} + {{range $name, $pattern := .Libraries -}} {{$name}}MetaData, {{ end}} } @@ -43,13 +43,7 @@ var ( // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract. var {{.Type}}MetaData = &bind.MetaData{ ABI: "{{.InputABI}}", - Pattern: "{{index $.InvertedLibs .Type}}", - {{if $contract.FuncSigs -}} - Sigs: map[string]string{ - {{range $strsig, $binsig := .FuncSigs}}"{{$binsig}}": "{{$strsig}}", - {{end}} - }, - {{end -}} + Pattern: "{{index $.Libraries .Type}}", {{if .InputBin -}} Bin: "0x{{.InputBin}}", {{end}} diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index c3e9de3536c5..6ae87ea0341d 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -475,7 +475,7 @@ func TestBindingGeneration(t *testing.T) { libPattern := crypto.Keccak256Hash([]byte(name)).String()[2:36] // the first 2 chars are 0x libs[libPattern] = typeName } - code, err := bind.BindV2(types, abis, bins, sigs, dir, libs, make(map[string]string)) + code, err := bind.BindV2(types, abis, bins, dir, libs, make(map[string]string)) if err != nil { t.Fatalf("error creating bindings for package %s: %v", dir, err) } From be372ef509869dac3c35f8b566c79df063c4f1c3 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 18 Dec 2024 14:42:54 +0700 Subject: [PATCH 081/104] remove unecessarily-added method --- accounts/abi/bind/base.go | 12 +----------- accounts/abi/bind/v2/lib_test.go | 3 +-- 2 files changed, 2 insertions(+), 13 deletions(-) diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index e78726856083..69e3b94bb35c 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -510,22 +510,12 @@ func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]int // WatchLogs filters subscribes to contract logs for future blocks, returning a // subscription object that can be used to tear down the watcher. func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { - return c.watchLogs(opts, c.abi.Events[name].ID, query...) -} - -// WatchLogsForId filters subscribes to contract logs for future blocks, returning a -// subscription object that can be used to tear down the watcher. -func (c *BoundContract) WatchLogsForId(opts *WatchOpts, id common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { - return c.watchLogs(opts, id, query...) -} - -func (c *BoundContract) watchLogs(opts *WatchOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) { // Don't crash on a lazy user if opts == nil { opts = new(WatchOpts) } // Append the event selector to the query parameters and construct the topic set - query = append([][]interface{}{{eventID}}, query...) + query = append([][]interface{}{{c.abi.Events[name].ID}}, query...) topics, err := abi.MakeTopics(query...) if err != nil { diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 6ae87ea0341d..07d9230f0a24 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -424,8 +424,7 @@ func TestErrors(t *testing.T) { // TODO: check anything about the error? } -// TODO: this test will pass if the code is changed but not compiled to a combined-abi.json. -// Not really possible to test this without including solc in the path when running CI. +// TestBindingGeneration tests that re-running generation of bindings does not result in mutations to the binding code func TestBindingGeneration(t *testing.T) { matches, _ := filepath.Glob("internal/*") var dirs []string From 4736f762e84f95138e994f4bcf8c2f065da57022 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 18 Dec 2024 15:00:01 +0700 Subject: [PATCH 082/104] add docs --- accounts/abi/bind/bind.go | 29 ++++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 91b52f95e84b..3550f607829e 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -347,11 +347,14 @@ type binder struct { // structs is the map of all redeclared structs shared by passed contracts. structs map[string]*tmplStruct + // aliases is a map for renaming instances of named events/functions/errors to specified values aliases map[string]string } +// registerIdentifier applies alias renaming, name normalization (conversion to camel case), and registers the normalized +// name in the specified identifier map. It returns an error if the normalized name already exists in the map. func (b *contractBinder) registerIdentifier(identifiers map[string]bool, original string) (normalized string, err error) { - normalized = alias(b.binder.aliases, methodNormalizer(original)) + normalized = methodNormalizer(alias(b.binder.aliases, original)) // Name shouldn't start with a digit. It will make the generated code invalid. if len(normalized) > 0 && unicode.IsDigit(rune(normalized[0])) { normalized = fmt.Sprintf("E%s", normalized) @@ -368,22 +371,28 @@ func (b *contractBinder) registerIdentifier(identifiers map[string]bool, origina return normalized, nil } +// RegisterCallIdentifier applies registerIdentifier for contract methods. func (b *contractBinder) RegisterCallIdentifier(id string) (string, error) { return b.registerIdentifier(b.callIdentifiers, id) } +// RegisterEventIdentifier applies registerIdentifier for contract events. func (b *contractBinder) RegisterEventIdentifier(id string) (string, error) { return b.registerIdentifier(b.eventIdentifiers, id) } +// RegisterErrorIdentifier applies registerIdentifier for contract errors. func (b *contractBinder) RegisterErrorIdentifier(id string) (string, error) { return b.registerIdentifier(b.errorIdentifiers, id) } +// BindStructType register the type to be emitted as a struct in the +// bindings. func (b *binder) BindStructType(typ abi.Type) { bindStructType(typ, b.structs) } +// contractBinder holds state for binding of a single contract type contractBinder struct { binder *binder calls map[string]*tmplMethod @@ -395,6 +404,11 @@ type contractBinder struct { errorIdentifiers map[string]bool } +// bindMethod registers a method to be emitted in the bindings. +// The name, inputs and outputs are normalized. If any inputs are +// struct-type their structs are registered to be emitted in the bindings. +// Any methods that return more than one output have their result coalesced +// into a struct. func (cb *contractBinder) bindMethod(original abi.Method) error { normalized := original normalizedName, err := cb.RegisterCallIdentifier(original.Name) @@ -449,6 +463,8 @@ func (cb *contractBinder) bindMethod(original abi.Method) error { return nil } +// normalizeErrorOrEventFields normalizes errors/events for emitting through bindings: +// Any anonymous fields are given generated names. func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Arguments) abi.Arguments { normalizedArguments := make([]abi.Argument, len(originalInputs)) copy(normalizedArguments, originalInputs) @@ -472,6 +488,7 @@ func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Argumen return normalizedArguments } +// bindEvent normalizes an event and registers it to be emitted in the bindings. func (cb *contractBinder) bindEvent(original abi.Event) error { // Skip anonymous events as they don't support explicit filtering if original.Anonymous { @@ -489,6 +506,7 @@ func (cb *contractBinder) bindEvent(original abi.Event) error { return nil } +// bindEvent normalizes an error and registers it to be emitted in the bindings. func (cb *contractBinder) bindError(original abi.Error) error { normalizedName, err := cb.RegisterErrorIdentifier(original.Name) if err != nil { @@ -502,14 +520,15 @@ func (cb *contractBinder) bindError(original abi.Error) error { return nil } +// BindV2 generates a Go wrapper around a contract ABI. This wrapper isn't meant +// to be used as is in client code, but rather as an intermediate struct which +// enforces compile time type safety and naming convention as opposed to having to +// manually maintain hard coded strings that break on runtime. func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { - - // TODO: validate each alias (ensure it doesn't begin with a digit or other invalid character) - b := binder{ contracts: make(map[string]*tmplContractV2), structs: make(map[string]*tmplStruct), - aliases: make(map[string]string), + aliases: aliases, } for i := 0; i < len(types); i++ { // Parse the actual ABI to generate the binding for From cf1cfedd7955b13fbd416da30e91fc3aced5fa44 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 18 Dec 2024 16:01:08 +0700 Subject: [PATCH 083/104] move BindV2 and methods it depends on into their own file. --- accounts/abi/bind/bind.go | 349 ------------------------------------ accounts/abi/bind/bindv2.go | 313 ++++++++++++++++++++++++++++++++ 2 files changed, 313 insertions(+), 349 deletions(-) create mode 100644 accounts/abi/bind/bindv2.go diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 3550f607829e..df54c7c643ad 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -104,7 +104,6 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] calls = make(map[string]*tmplMethod) transacts = make(map[string]*tmplMethod) events = make(map[string]*tmplEvent) - errors = make(map[string]*tmplError) fallback *tmplMethod receive *tmplMethod @@ -220,51 +219,6 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] // Append the event to the accumulator list events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} } - for _, original := range evmABI.Errors { - // TODO: I copied this from events (above in this function). I think it should be correct but not totally sure - // even if it is correct, should consider deduplicating this into its own function. - - // Normalize the error for capital cases and non-anonymous outputs - normalized := original - - // Ensure there is no duplicated identifier - normalizedName := methodNormalizer(alias(aliases, original.Name)) - // Name shouldn't start with a digit. It will make the generated code invalid. - if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { - normalizedName = fmt.Sprintf("E%s", normalizedName) - normalizedName = abi.ResolveNameConflict(normalizedName, func(name string) bool { - _, ok := eventIdentifiers[name] - return ok - }) - } - if eventIdentifiers[normalizedName] { - return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName) - } - eventIdentifiers[normalizedName] = true - normalized.Name = normalizedName - - used := make(map[string]bool) - normalized.Inputs = make([]abi.Argument, len(original.Inputs)) - copy(normalized.Inputs, original.Inputs) - for j, input := range normalized.Inputs { - if input.Name == "" || isKeyWord(input.Name) { - normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) - } - // Event is a bit special, we need to define event struct in binding, - // ensure there is no camel-case-style name conflict. - for index := 0; ; index++ { - if !used[capitalise(normalized.Inputs[j].Name)] { - used[capitalise(normalized.Inputs[j].Name)] = true - break - } - normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index) - } - if hasStruct(input.Type) { - bindStructType(input.Type, structs) - } - } - errors[original.Name] = &tmplError{Original: original, Normalized: normalized} - } // Add two special fallback functions if they exist if evmABI.HasFallback() { fallback = &tmplMethod{Original: evmABI.Fallback} @@ -340,309 +294,6 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] return string(code), nil } -type binder struct { - // contracts is the map of each individual contract requested binding - contracts map[string]*tmplContractV2 - - // structs is the map of all redeclared structs shared by passed contracts. - structs map[string]*tmplStruct - - // aliases is a map for renaming instances of named events/functions/errors to specified values - aliases map[string]string -} - -// registerIdentifier applies alias renaming, name normalization (conversion to camel case), and registers the normalized -// name in the specified identifier map. It returns an error if the normalized name already exists in the map. -func (b *contractBinder) registerIdentifier(identifiers map[string]bool, original string) (normalized string, err error) { - normalized = methodNormalizer(alias(b.binder.aliases, original)) - // Name shouldn't start with a digit. It will make the generated code invalid. - if len(normalized) > 0 && unicode.IsDigit(rune(normalized[0])) { - normalized = fmt.Sprintf("E%s", normalized) - normalized = abi.ResolveNameConflict(normalized, func(name string) bool { - _, ok := identifiers[name] - return ok - }) - } - - if _, ok := identifiers[normalized]; ok { - return "", fmt.Errorf("duplicate symbol '%s'", normalized) - } - identifiers[normalized] = true - return normalized, nil -} - -// RegisterCallIdentifier applies registerIdentifier for contract methods. -func (b *contractBinder) RegisterCallIdentifier(id string) (string, error) { - return b.registerIdentifier(b.callIdentifiers, id) -} - -// RegisterEventIdentifier applies registerIdentifier for contract events. -func (b *contractBinder) RegisterEventIdentifier(id string) (string, error) { - return b.registerIdentifier(b.eventIdentifiers, id) -} - -// RegisterErrorIdentifier applies registerIdentifier for contract errors. -func (b *contractBinder) RegisterErrorIdentifier(id string) (string, error) { - return b.registerIdentifier(b.errorIdentifiers, id) -} - -// BindStructType register the type to be emitted as a struct in the -// bindings. -func (b *binder) BindStructType(typ abi.Type) { - bindStructType(typ, b.structs) -} - -// contractBinder holds state for binding of a single contract -type contractBinder struct { - binder *binder - calls map[string]*tmplMethod - events map[string]*tmplEvent - errors map[string]*tmplError - - callIdentifiers map[string]bool - eventIdentifiers map[string]bool - errorIdentifiers map[string]bool -} - -// bindMethod registers a method to be emitted in the bindings. -// The name, inputs and outputs are normalized. If any inputs are -// struct-type their structs are registered to be emitted in the bindings. -// Any methods that return more than one output have their result coalesced -// into a struct. -func (cb *contractBinder) bindMethod(original abi.Method) error { - normalized := original - normalizedName, err := cb.RegisterCallIdentifier(original.Name) - if err != nil { - return err - } - - normalized.Name = normalizedName - normalized.Inputs = make([]abi.Argument, len(original.Inputs)) - copy(normalized.Inputs, original.Inputs) - for j, input := range normalized.Inputs { - if input.Name == "" || isKeyWord(input.Name) { - normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) - } - if hasStruct(input.Type) { - cb.binder.BindStructType(input.Type) - } - } - normalized.Outputs = make([]abi.Argument, len(original.Outputs)) - copy(normalized.Outputs, original.Outputs) - for j, output := range normalized.Outputs { - if output.Name != "" { - normalized.Outputs[j].Name = capitalise(output.Name) - } - if hasStruct(output.Type) { - cb.binder.BindStructType(output.Type) - } - } - isStructured := structured(original.Outputs) - // if the call returns multiple values, coallesce them into a struct - if len(normalized.Outputs) > 1 { - // Build up dictionary of existing arg names. - keys := make(map[string]struct{}) - for _, o := range normalized.Outputs { - if o.Name != "" { - keys[strings.ToLower(o.Name)] = struct{}{} - } - } - // Assign names to anonymous fields. - for i, o := range normalized.Outputs { - if o.Name != "" { - continue - } - o.Name = capitalise(abi.ResolveNameConflict("arg", func(name string) bool { _, ok := keys[name]; return ok })) - normalized.Outputs[i] = o - keys[strings.ToLower(o.Name)] = struct{}{} - } - isStructured = true - } - - cb.calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: isStructured} - return nil -} - -// normalizeErrorOrEventFields normalizes errors/events for emitting through bindings: -// Any anonymous fields are given generated names. -func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Arguments) abi.Arguments { - normalizedArguments := make([]abi.Argument, len(originalInputs)) - copy(normalizedArguments, originalInputs) - used := make(map[string]bool) - - for i, input := range normalizedArguments { - if input.Name == "" || isKeyWord(input.Name) { - normalizedArguments[i].Name = fmt.Sprintf("arg%d", i) - } - for index := 0; ; index++ { - if !used[capitalise(normalizedArguments[i].Name)] { - used[capitalise(normalizedArguments[i].Name)] = true - break - } - normalizedArguments[i].Name = fmt.Sprintf("%s%d", normalizedArguments[i].Name, index) - } - if hasStruct(input.Type) { - cb.binder.BindStructType(input.Type) - } - } - return normalizedArguments -} - -// bindEvent normalizes an event and registers it to be emitted in the bindings. -func (cb *contractBinder) bindEvent(original abi.Event) error { - // Skip anonymous events as they don't support explicit filtering - if original.Anonymous { - return nil - } - normalizedName, err := cb.RegisterEventIdentifier(original.Name) - if err != nil { - return err - } - - normalized := original - normalized.Name = normalizedName - normalized.Inputs = cb.normalizeErrorOrEventFields(original.Inputs) - cb.events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} - return nil -} - -// bindEvent normalizes an error and registers it to be emitted in the bindings. -func (cb *contractBinder) bindError(original abi.Error) error { - normalizedName, err := cb.RegisterErrorIdentifier(original.Name) - if err != nil { - return err - } - - normalized := original - normalized.Name = normalizedName - normalized.Inputs = cb.normalizeErrorOrEventFields(original.Inputs) - cb.errors[original.Name] = &tmplError{Original: original, Normalized: normalized} - return nil -} - -// BindV2 generates a Go wrapper around a contract ABI. This wrapper isn't meant -// to be used as is in client code, but rather as an intermediate struct which -// enforces compile time type safety and naming convention as opposed to having to -// manually maintain hard coded strings that break on runtime. -func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { - b := binder{ - contracts: make(map[string]*tmplContractV2), - structs: make(map[string]*tmplStruct), - aliases: aliases, - } - for i := 0; i < len(types); i++ { - // Parse the actual ABI to generate the binding for - evmABI, err := abi.JSON(strings.NewReader(abis[i])) - if err != nil { - return "", err - } - // Strip any whitespace from the JSON ABI - strippedABI := strings.Map(func(r rune) rune { - if unicode.IsSpace(r) { - return -1 - } - return r - }, abis[i]) - - for _, input := range evmABI.Constructor.Inputs { - if hasStruct(input.Type) { - bindStructType(input.Type, b.structs) - } - } - - cb := contractBinder{ - binder: &b, - calls: make(map[string]*tmplMethod), - events: make(map[string]*tmplEvent), - errors: make(map[string]*tmplError), - - callIdentifiers: make(map[string]bool), - errorIdentifiers: make(map[string]bool), - eventIdentifiers: make(map[string]bool), - } - for _, original := range evmABI.Methods { - if err := cb.bindMethod(original); err != nil { - return "", err - } - } - - for _, original := range evmABI.Events { - if err := cb.bindEvent(original); err != nil { - return "", err - } - } - for _, original := range evmABI.Errors { - if err := cb.bindError(original); err != nil { - return "", err - } - } - - // replace this with a method call to cb (name it BoundContract()?) - b.contracts[types[i]] = &tmplContractV2{ - Type: capitalise(types[i]), - InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), - InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), - Constructor: evmABI.Constructor, - Calls: cb.calls, - Events: cb.events, - Errors: cb.errors, - Libraries: make(map[string]string), - } - } - - invertedLibs := make(map[string]string) - for pattern, name := range libs { - invertedLibs[name] = pattern - } - - data := tmplDataV2{ - Package: pkg, - Contracts: b.contracts, - Libraries: invertedLibs, - Structs: b.structs, - } - - contractsBins := make(map[string]string) - for typ, contract := range data.Contracts { - pattern := invertedLibs[typ] - contractsBins[pattern] = contract.InputBin - } - builder := newDepTreeBuilder(nil, contractsBins) - roots, deps := builder.BuildDepTrees() - allNodes := append(roots, deps...) - for _, dep := range allNodes { - contractType := libs[dep.pattern] - for subDepPattern, _ := range dep.Flatten() { - if subDepPattern == dep.pattern { - // don't include the dep as a dependency of itself - continue - } - subDepType := libs[subDepPattern] - data.Contracts[contractType].Libraries[subDepType] = subDepPattern - } - } - buffer := new(bytes.Buffer) - funcs := map[string]interface{}{ - "bindtype": bindType, - "bindtopictype": bindTopicType, - "capitalise": capitalise, - "decapitalise": decapitalise, - "add": func(val1, val2 int) int { - return val1 + val2 - }, - } - tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSourceV2)) - if err := tmpl.Execute(buffer, data); err != nil { - return "", err - } - // Pass the code through gofmt to clean it up - code, err := format.Source(buffer.Bytes()) - if err != nil { - return "", fmt.Errorf("%v\n%s", err, buffer) - } - return string(code), nil -} - // bindBasicType converts basic solidity types(except array, slice and tuple) to Go ones. func bindBasicType(kind abi.Type) string { switch kind.T { diff --git a/accounts/abi/bind/bindv2.go b/accounts/abi/bind/bindv2.go new file mode 100644 index 000000000000..280ba2cb8c20 --- /dev/null +++ b/accounts/abi/bind/bindv2.go @@ -0,0 +1,313 @@ +package bind + +import ( + "bytes" + "fmt" + "github.com/ethereum/go-ethereum/accounts/abi" + "go/format" + "strings" + "text/template" + "unicode" +) + +type binder struct { + // contracts is the map of each individual contract requested binding + contracts map[string]*tmplContractV2 + + // structs is the map of all redeclared structs shared by passed contracts. + structs map[string]*tmplStruct + + // aliases is a map for renaming instances of named events/functions/errors to specified values + aliases map[string]string +} + +// registerIdentifier applies alias renaming, name normalization (conversion to camel case), and registers the normalized +// name in the specified identifier map. It returns an error if the normalized name already exists in the map. +func (b *contractBinder) registerIdentifier(identifiers map[string]bool, original string) (normalized string, err error) { + normalized = methodNormalizer(alias(b.binder.aliases, original)) + // Name shouldn't start with a digit. It will make the generated code invalid. + if len(normalized) > 0 && unicode.IsDigit(rune(normalized[0])) { + normalized = fmt.Sprintf("E%s", normalized) + normalized = abi.ResolveNameConflict(normalized, func(name string) bool { + _, ok := identifiers[name] + return ok + }) + } + + if _, ok := identifiers[normalized]; ok { + return "", fmt.Errorf("duplicate symbol '%s'", normalized) + } + identifiers[normalized] = true + return normalized, nil +} + +// RegisterCallIdentifier applies registerIdentifier for contract methods. +func (b *contractBinder) RegisterCallIdentifier(id string) (string, error) { + return b.registerIdentifier(b.callIdentifiers, id) +} + +// RegisterEventIdentifier applies registerIdentifier for contract events. +func (b *contractBinder) RegisterEventIdentifier(id string) (string, error) { + return b.registerIdentifier(b.eventIdentifiers, id) +} + +// RegisterErrorIdentifier applies registerIdentifier for contract errors. +func (b *contractBinder) RegisterErrorIdentifier(id string) (string, error) { + return b.registerIdentifier(b.errorIdentifiers, id) +} + +// BindStructType register the type to be emitted as a struct in the +// bindings. +func (b *binder) BindStructType(typ abi.Type) { + bindStructType(typ, b.structs) +} + +// contractBinder holds state for binding of a single contract +type contractBinder struct { + binder *binder + calls map[string]*tmplMethod + events map[string]*tmplEvent + errors map[string]*tmplError + + callIdentifiers map[string]bool + eventIdentifiers map[string]bool + errorIdentifiers map[string]bool +} + +// bindMethod registers a method to be emitted in the bindings. +// The name, inputs and outputs are normalized. If any inputs are +// struct-type their structs are registered to be emitted in the bindings. +// Any methods that return more than one output have their result coalesced +// into a struct. +func (cb *contractBinder) bindMethod(original abi.Method) error { + normalized := original + normalizedName, err := cb.RegisterCallIdentifier(original.Name) + if err != nil { + return err + } + + normalized.Name = normalizedName + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + if input.Name == "" || isKeyWord(input.Name) { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + if hasStruct(input.Type) { + cb.binder.BindStructType(input.Type) + } + } + normalized.Outputs = make([]abi.Argument, len(original.Outputs)) + copy(normalized.Outputs, original.Outputs) + for j, output := range normalized.Outputs { + if output.Name != "" { + normalized.Outputs[j].Name = capitalise(output.Name) + } + if hasStruct(output.Type) { + cb.binder.BindStructType(output.Type) + } + } + isStructured := structured(original.Outputs) + // if the call returns multiple values, coallesce them into a struct + if len(normalized.Outputs) > 1 { + // Build up dictionary of existing arg names. + keys := make(map[string]struct{}) + for _, o := range normalized.Outputs { + if o.Name != "" { + keys[strings.ToLower(o.Name)] = struct{}{} + } + } + // Assign names to anonymous fields. + for i, o := range normalized.Outputs { + if o.Name != "" { + continue + } + o.Name = capitalise(abi.ResolveNameConflict("arg", func(name string) bool { _, ok := keys[name]; return ok })) + normalized.Outputs[i] = o + keys[strings.ToLower(o.Name)] = struct{}{} + } + isStructured = true + } + + cb.calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: isStructured} + return nil +} + +// normalizeErrorOrEventFields normalizes errors/events for emitting through bindings: +// Any anonymous fields are given generated names. +func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Arguments) abi.Arguments { + normalizedArguments := make([]abi.Argument, len(originalInputs)) + copy(normalizedArguments, originalInputs) + used := make(map[string]bool) + + for i, input := range normalizedArguments { + if input.Name == "" || isKeyWord(input.Name) { + normalizedArguments[i].Name = fmt.Sprintf("arg%d", i) + } + for index := 0; ; index++ { + if !used[capitalise(normalizedArguments[i].Name)] { + used[capitalise(normalizedArguments[i].Name)] = true + break + } + normalizedArguments[i].Name = fmt.Sprintf("%s%d", normalizedArguments[i].Name, index) + } + if hasStruct(input.Type) { + cb.binder.BindStructType(input.Type) + } + } + return normalizedArguments +} + +// bindEvent normalizes an event and registers it to be emitted in the bindings. +func (cb *contractBinder) bindEvent(original abi.Event) error { + // Skip anonymous events as they don't support explicit filtering + if original.Anonymous { + return nil + } + normalizedName, err := cb.RegisterEventIdentifier(original.Name) + if err != nil { + return err + } + + normalized := original + normalized.Name = normalizedName + normalized.Inputs = cb.normalizeErrorOrEventFields(original.Inputs) + cb.events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} + return nil +} + +// bindEvent normalizes an error and registers it to be emitted in the bindings. +func (cb *contractBinder) bindError(original abi.Error) error { + normalizedName, err := cb.RegisterErrorIdentifier(original.Name) + if err != nil { + return err + } + + normalized := original + normalized.Name = normalizedName + normalized.Inputs = cb.normalizeErrorOrEventFields(original.Inputs) + cb.errors[original.Name] = &tmplError{Original: original, Normalized: normalized} + return nil +} + +// BindV2 generates a Go wrapper around a contract ABI. This wrapper isn't meant +// to be used as is in client code, but rather as an intermediate struct which +// enforces compile time type safety and naming convention as opposed to having to +// manually maintain hard coded strings that break on runtime. +func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs map[string]string, aliases map[string]string) (string, error) { + b := binder{ + contracts: make(map[string]*tmplContractV2), + structs: make(map[string]*tmplStruct), + aliases: aliases, + } + for i := 0; i < len(types); i++ { + // Parse the actual ABI to generate the binding for + evmABI, err := abi.JSON(strings.NewReader(abis[i])) + if err != nil { + return "", err + } + + for _, input := range evmABI.Constructor.Inputs { + if hasStruct(input.Type) { + bindStructType(input.Type, b.structs) + } + } + + cb := contractBinder{ + binder: &b, + calls: make(map[string]*tmplMethod), + events: make(map[string]*tmplEvent), + errors: make(map[string]*tmplError), + + callIdentifiers: make(map[string]bool), + errorIdentifiers: make(map[string]bool), + eventIdentifiers: make(map[string]bool), + } + for _, original := range evmABI.Methods { + if err := cb.bindMethod(original); err != nil { + return "", err + } + } + + for _, original := range evmABI.Events { + if err := cb.bindEvent(original); err != nil { + return "", err + } + } + for _, original := range evmABI.Errors { + if err := cb.bindError(original); err != nil { + return "", err + } + } + // Strip any whitespace from the JSON ABI + strippedABI := strings.Map(func(r rune) rune { + if unicode.IsSpace(r) { + return -1 + } + return r + }, abis[i]) + // replace this with a method call to cb (name it BoundContract()?) + b.contracts[types[i]] = &tmplContractV2{ + Type: capitalise(types[i]), + InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), + InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), + Constructor: evmABI.Constructor, + Calls: cb.calls, + Events: cb.events, + Errors: cb.errors, + Libraries: make(map[string]string), + } + } + + invertedLibs := make(map[string]string) + for pattern, name := range libs { + invertedLibs[name] = pattern + } + + data := tmplDataV2{ + Package: pkg, + Contracts: b.contracts, + Libraries: invertedLibs, + Structs: b.structs, + } + + contractsBins := make(map[string]string) + for typ, contract := range data.Contracts { + pattern := invertedLibs[typ] + contractsBins[pattern] = contract.InputBin + } + builder := newDepTreeBuilder(nil, contractsBins) + roots, deps := builder.BuildDepTrees() + allNodes := append(roots, deps...) + for _, dep := range allNodes { + contractType := libs[dep.pattern] + for subDepPattern, _ := range dep.Flatten() { + if subDepPattern == dep.pattern { + // don't include the dep as a dependency of itself + continue + } + subDepType := libs[subDepPattern] + data.Contracts[contractType].Libraries[subDepType] = subDepPattern + } + } + buffer := new(bytes.Buffer) + funcs := map[string]interface{}{ + "bindtype": bindType, + "bindtopictype": bindTopicType, + "capitalise": capitalise, + "decapitalise": decapitalise, + "add": func(val1, val2 int) int { + return val1 + val2 + }, + } + tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSourceV2)) + if err := tmpl.Execute(buffer, data); err != nil { + return "", err + } + // Pass the code through gofmt to clean it up + code, err := format.Source(buffer.Bytes()) + if err != nil { + return "", fmt.Errorf("%v\n%s", err, buffer) + } + return string(code), nil +} From 3f52ae8fe6a2f6590c17d9185eb8228cb7930876 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 18 Dec 2024 16:21:59 +0700 Subject: [PATCH 084/104] make DeploymentParams fields private. instantiate it with a constructor method --- accounts/abi/bind/dep_tree.go | 25 +++++++++++++++++-------- accounts/abi/bind/dep_tree_test.go | 15 +++++++-------- accounts/abi/bind/v2/lib_test.go | 26 +++++--------------------- 3 files changed, 29 insertions(+), 37 deletions(-) diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index 7f3d80a318bb..80bc0984b310 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -11,13 +11,22 @@ import ( // set of contracts. It takes an optional override // list to specify contracts/libraries that have already been deployed on-chain. type DeploymentParams struct { - Contracts []*MetaData + contracts []*MetaData // map of solidity library pattern to constructor input. - Inputs map[string][]byte + inputs map[string][]byte // Overrides is an optional map of pattern to deployment address. // Contracts/libraries that refer to dependencies in the override // set are linked to the provided address (an already-deployed contract). - Overrides map[string]common.Address + overrides map[string]common.Address +} + +// NewDeploymentParams instantiates a DeploymentParams instance. +func NewDeploymentParams(contracts []*MetaData, inputs map[string][]byte, overrides map[string]common.Address) *DeploymentParams { + return &DeploymentParams{ + contracts, + inputs, + overrides, + } } // DeploymentResult encapsulates information about the result of the deployment @@ -203,22 +212,22 @@ func newDepTreeDeployer(deploy DeployFn) *depTreeDeployer { // LinkAndDeploy deploys a specified set of contracts and their dependent // libraries. If an error occurs, only contracts which were successfully // deployed are returned in the result. -func LinkAndDeploy(deployParams DeploymentParams, deploy DeployFn) (res *DeploymentResult, err error) { +func LinkAndDeploy(deployParams *DeploymentParams, deploy DeployFn) (res *DeploymentResult, err error) { unlinkedContracts := make(map[string]string) accumRes := &DeploymentResult{ Txs: make(map[string]*types.Transaction), Addrs: make(map[string]common.Address), } - for _, meta := range deployParams.Contracts { + for _, meta := range deployParams.contracts { unlinkedContracts[meta.Pattern] = meta.Bin[2:] } - treeBuilder := newDepTreeBuilder(deployParams.Overrides, unlinkedContracts) + treeBuilder := newDepTreeBuilder(deployParams.overrides, unlinkedContracts) deps, _ := treeBuilder.BuildDepTrees() for _, tr := range deps { deployer := newDepTreeDeployer(deploy) - if deployParams.Inputs != nil { - deployer.input = map[string][]byte{tr.pattern: deployParams.Inputs[tr.pattern]} + if deployParams.inputs != nil { + deployer.input = map[string][]byte{tr.pattern: deployParams.inputs[tr.pattern]} } err := deployer.linkAndDeploy(tr) res := deployer.result() diff --git a/accounts/abi/bind/dep_tree_test.go b/accounts/abi/bind/dep_tree_test.go index 3e02599822d5..87390bb033b0 100644 --- a/accounts/abi/bind/dep_tree_test.go +++ b/accounts/abi/bind/dep_tree_test.go @@ -138,25 +138,24 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { return contractAddr, nil, nil } - var ( - deployParams DeploymentParams - ) + var contracts []*MetaData + overrides := make(map[string]common.Address) + for pattern, bin := range tc.contractCodes { - deployParams.Contracts = append(deployParams.Contracts, &MetaData{Pattern: pattern, Bin: "0x" + bin}) + contracts = append(contracts, &MetaData{Pattern: pattern, Bin: "0x" + bin}) } for pattern, bin := range tc.libCodes { - deployParams.Contracts = append(deployParams.Contracts, &MetaData{ + contracts = append(contracts, &MetaData{ Bin: "0x" + bin, Pattern: pattern, }) } - overridePatterns := make(map[string]common.Address) for pattern, override := range tc.overrides { - overridePatterns[pattern] = override + overrides[pattern] = override } - deployParams.Overrides = overridePatterns + deployParams := NewDeploymentParams(contracts, nil, overrides) res, err := LinkAndDeploy(deployParams, mockDeploy) if err != nil { t.Fatalf("got error from LinkAndDeploy: %v\n", err) diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 07d9230f0a24..cb1210396024 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -121,11 +121,7 @@ func TestDeploymentLibraries(t *testing.T) { if err != nil { t.Fatalf("failed to pack constructor: %v", err) } - deploymentParams := bind.DeploymentParams{ - Contracts: append(nested_libraries.C1LibraryDeps, nested_libraries.C1MetaData), - Inputs: map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, - Overrides: nil, - } + deploymentParams := bind.NewDeploymentParams(append(nested_libraries.C1LibraryDeps, nested_libraries.C1MetaData), map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, nil) res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { @@ -180,9 +176,7 @@ func TestDeploymentWithOverrides(t *testing.T) { defer bindBackend.Backend.Close() // deploy some library deps - deploymentParams := bind.DeploymentParams{ - Contracts: nested_libraries.C1LibraryDeps, - } + deploymentParams := bind.NewDeploymentParams(nested_libraries.C1LibraryDeps, nil, nil) res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { @@ -210,11 +204,7 @@ func TestDeploymentWithOverrides(t *testing.T) { } overrides := res.Addrs // deploy the contract - deploymentParams = bind.DeploymentParams{ - Contracts: []*bind.MetaData{nested_libraries.C1MetaData}, - Inputs: map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, - Overrides: overrides, - } + deploymentParams = bind.NewDeploymentParams([]*bind.MetaData{nested_libraries.C1MetaData}, map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, overrides) res, err = bind.LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { t.Fatalf("err: %+v\n", err) @@ -271,10 +261,7 @@ func TestEvents(t *testing.T) { t.Fatalf("error setting up testing env: %v", err) } - deploymentParams := bind.DeploymentParams{ - Contracts: []*bind.MetaData{events.CMetaData}, - } - + deploymentParams := bind.NewDeploymentParams([]*bind.MetaData{events.CMetaData}, nil, nil) res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(txAuth, backend)) if err != nil { t.Fatalf("error deploying contract for testing: %v", err) @@ -385,10 +372,7 @@ func TestErrors(t *testing.T) { t.Fatalf("error setting up testing env: %v", err) } - deploymentParams := bind.DeploymentParams{ - Contracts: []*bind.MetaData{solc_errors.CMetaData}, - } - + deploymentParams := bind.NewDeploymentParams([]*bind.MetaData{solc_errors.CMetaData}, nil, nil) res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(txAuth, backend)) if err != nil { t.Fatalf("error deploying contract for testing: %v", err) From f8f0d941c293ff65dbb2e1ab48124d4dc7c739f1 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 18 Dec 2024 16:24:09 +0700 Subject: [PATCH 085/104] fix comment for bindError method --- accounts/abi/bind/bindv2.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/accounts/abi/bind/bindv2.go b/accounts/abi/bind/bindv2.go index 280ba2cb8c20..72095934e7b4 100644 --- a/accounts/abi/bind/bindv2.go +++ b/accounts/abi/bind/bindv2.go @@ -176,7 +176,7 @@ func (cb *contractBinder) bindEvent(original abi.Event) error { return nil } -// bindEvent normalizes an error and registers it to be emitted in the bindings. +// bindError normalizes an error and registers it to be emitted in the bindings. func (cb *contractBinder) bindError(original abi.Error) error { normalizedName, err := cb.RegisterErrorIdentifier(original.Name) if err != nil { From 0381e2740759e2096df3d11b27351311cfbb8760 Mon Sep 17 00:00:00 2001 From: jwasinger Date: Wed, 18 Dec 2024 16:26:48 +0700 Subject: [PATCH 086/104] Update accounts/abi/bind/dep_tree.go Co-authored-by: Martin HS --- accounts/abi/bind/dep_tree.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index 80bc0984b310..b7bb7f2eeb1b 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -39,7 +39,7 @@ type DeploymentResult struct { Addrs map[string]common.Address } -// Accumulate merges two DeploymentResult objects together. +// Accumulate merges `other` into `d` func (d *DeploymentResult) Accumulate(other *DeploymentResult) { for pattern, tx := range other.Txs { d.Txs[pattern] = tx From 29137818114fda0cbd44acacf60c2304cf07ba86 Mon Sep 17 00:00:00 2001 From: jwasinger Date: Wed, 18 Dec 2024 16:27:05 +0700 Subject: [PATCH 087/104] Update accounts/abi/bind/dep_tree.go Co-authored-by: Martin HS --- accounts/abi/bind/dep_tree.go | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index b7bb7f2eeb1b..53052870b2d1 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -41,12 +41,8 @@ type DeploymentResult struct { // Accumulate merges `other` into `d` func (d *DeploymentResult) Accumulate(other *DeploymentResult) { - for pattern, tx := range other.Txs { - d.Txs[pattern] = tx - } - for pattern, addr := range other.Addrs { - d.Addrs[pattern] = addr - } + maps.Copy(d.Txs, other.Txs) + maps.Copy(d.Addrs, other.Addrs) } // depTreeBuilder turns a set of unlinked contracts libraries into a set of one From f6bffbb5a6d9af5a410f3cb440a8c2fab0e926cb Mon Sep 17 00:00:00 2001 From: jwasinger Date: Wed, 18 Dec 2024 16:28:43 +0700 Subject: [PATCH 088/104] Update accounts/abi/bind/dep_tree.go Co-authored-by: Martin HS --- accounts/abi/bind/dep_tree.go | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index 53052870b2d1..7bc3d3962117 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -170,11 +170,9 @@ func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) error { // a deployer bytecode for this contract. deployerCode := node.unlinkedCode for _, child := range node.children { - var linkAddr common.Address + linkAddr := d.deployedAddrs[child.pattern] if child.overrideAddr != nil { linkAddr = *child.overrideAddr - } else { - linkAddr = d.deployedAddrs[child.pattern] } deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(linkAddr.String()[2:])) } From 6d626c4618c548ec7411f5fa87415f93b905952e Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Wed, 18 Dec 2024 21:07:24 +0700 Subject: [PATCH 089/104] wip: embed library relations in metadata --- accounts/abi/bind/base.go | 1 + accounts/abi/bind/bindv2.go | 30 +++---- accounts/abi/bind/dep_tree.go | 136 ++++------------------------- accounts/abi/bind/dep_tree_test.go | 42 +++++++-- accounts/abi/bind/source2.go.tpl | 9 +- 5 files changed, 71 insertions(+), 147 deletions(-) diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index 69e3b94bb35c..54f4b7989e2d 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -95,6 +95,7 @@ type MetaData struct { ABI string ab *abi.ABI Pattern string + Deps []*MetaData } func (m *MetaData) GetAbi() (*abi.ABI, error) { diff --git a/accounts/abi/bind/bindv2.go b/accounts/abi/bind/bindv2.go index 72095934e7b4..66f4391f7816 100644 --- a/accounts/abi/bind/bindv2.go +++ b/accounts/abi/bind/bindv2.go @@ -5,6 +5,7 @@ import ( "fmt" "github.com/ethereum/go-ethereum/accounts/abi" "go/format" + "regexp" "strings" "text/template" "unicode" @@ -190,6 +191,17 @@ func (cb *contractBinder) bindError(original abi.Error) error { return nil } +func parseLibraryDeps(unlinkedCode string) (res []string) { + reMatchSpecificPattern, err := regexp.Compile(`__\$([a-f0-9]+)\$__`) + if err != nil { + panic(err) + } + for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(unlinkedCode, -1) { + res = append(res, match[1]) + } + return res +} + // BindV2 generates a Go wrapper around a contract ABI. This wrapper isn't meant // to be used as is in client code, but rather as an intermediate struct which // enforces compile time type safety and naming convention as opposed to having to @@ -271,23 +283,9 @@ func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs Structs: b.structs, } - contractsBins := make(map[string]string) for typ, contract := range data.Contracts { - pattern := invertedLibs[typ] - contractsBins[pattern] = contract.InputBin - } - builder := newDepTreeBuilder(nil, contractsBins) - roots, deps := builder.BuildDepTrees() - allNodes := append(roots, deps...) - for _, dep := range allNodes { - contractType := libs[dep.pattern] - for subDepPattern, _ := range dep.Flatten() { - if subDepPattern == dep.pattern { - // don't include the dep as a dependency of itself - continue - } - subDepType := libs[subDepPattern] - data.Contracts[contractType].Libraries[subDepType] = subDepPattern + for _, depPattern := range parseLibraryDeps(contract.InputBin) { + data.Contracts[typ].Libraries[libs[depPattern]] = depPattern } } buffer := new(bytes.Buffer) diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index 7bc3d3962117..072e716368dd 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -3,7 +3,7 @@ package bind import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" - "regexp" + "maps" "strings" ) @@ -45,100 +45,6 @@ func (d *DeploymentResult) Accumulate(other *DeploymentResult) { maps.Copy(d.Addrs, other.Addrs) } -// depTreeBuilder turns a set of unlinked contracts libraries into a set of one -// or more dependency trees. -type depTreeBuilder struct { - overrides map[string]common.Address - // map of pattern to unlinked contract bytecode (for libraries or contracts) - contracts map[string]string - // map of pattern to subtree represented by contract - subtrees map[string]*depTreeNode - // map of nodes that aren't referenced by other dependencies (these can be libraries too if user is doing lib-only deployment) - roots map[string]struct{} -} - -// depTreeNode represents a node (contract) in a dependency tree. it contains its unlinked code, and references to any -// library contracts that it requires. If it is specified as an override, it contains the address where it has already -// been deployed at. -type depTreeNode struct { - pattern string - unlinkedCode string - children []*depTreeNode - overrideAddr *common.Address -} - -// Flatten returns the subtree into a map of pattern -> unlinked contract bytecode. -func (n *depTreeNode) Flatten() (res map[string]string) { - res = map[string]string{n.pattern: n.unlinkedCode} - for _, child := range n.children { - subtree := child.Flatten() - - for k, v := range subtree { - res[k] = v - } - } - return res -} - -// buildDepTrees is the internal version of BuildDepTrees that recursively calls itself. -func (d *depTreeBuilder) buildDepTrees(pattern, contract string) { - // if the node is in the subtree set already, it has already been fully recursed/built so we can bail out. - if _, ok := d.subtrees[pattern]; ok { - return - } - node := &depTreeNode{ - pattern: pattern, - unlinkedCode: contract, - } - if addr, ok := d.overrides[pattern]; ok { - node.overrideAddr = &addr - } - // iterate each referenced library in the unlinked code, recurse and build its subtree. - reMatchSpecificPattern, err := regexp.Compile(`__\$([a-f0-9]+)\$__`) - if err != nil { - panic(err) - } - for _, match := range reMatchSpecificPattern.FindAllStringSubmatch(contract, -1) { - depPattern := match[1] - d.buildDepTrees(depPattern, d.contracts[depPattern]) - node.children = append(node.children, d.subtrees[depPattern]) - - // this library can't be a root dependency if it is referenced by other contracts. - delete(d.roots, depPattern) - } - d.subtrees[pattern] = node -} - -// BuildDepTrees will compute a set of dependency trees from a set of unlinked contracts. The root of each tree -// corresponds to a contract/library that is not referenced as a dependency anywhere else. Children of each node are -// its library dependencies. It returns nodes that are roots of a dependency tree and nodes that aren't. -func (d *depTreeBuilder) BuildDepTrees() (roots []*depTreeNode, nonRoots []*depTreeNode) { - // before the trees of dependencies are known, consider that any provided contract could be a root. - for pattern, _ := range d.contracts { - d.roots[pattern] = struct{}{} - } - for pattern, contract := range d.contracts { - d.buildDepTrees(pattern, contract) - } - for pattern, _ := range d.contracts { - if _, ok := d.roots[pattern]; ok { - roots = append(roots, d.subtrees[pattern]) - } else { - nonRoots = append(nonRoots, d.subtrees[pattern]) - } - } - return roots, nonRoots -} - -func newDepTreeBuilder(overrides map[string]common.Address, contracts map[string]string) *depTreeBuilder { - return &depTreeBuilder{ - overrides: overrides, - contracts: contracts, - subtrees: make(map[string]*depTreeNode), - roots: make(map[string]struct{}), - } -} - // DeployFn deploys a contract given a deployer and optional input. It returns // the address and a pending transaction, or an error if the deployment failed. type DeployFn func(input, deployer []byte) (common.Address, *types.Transaction, error) @@ -154,37 +60,34 @@ type depTreeDeployer struct { // linkAndDeploy recursively deploys a contract and its dependencies: starting by linking/deploying its dependencies. // The deployment result (deploy addresses/txs or an error) is stored in the depTreeDeployer object. -func (d *depTreeDeployer) linkAndDeploy(node *depTreeNode) error { +func (d *depTreeDeployer) linkAndDeploy(metadata *MetaData) error { // don't deploy contracts specified as overrides. don't deploy their dependencies. - if node.overrideAddr != nil { + if _, ok := d.deployedAddrs[metadata.Pattern]; ok { return nil } // if this contract/library depends on other libraries deploy them (and their dependencies) first - for _, childNode := range node.children { - if err := d.linkAndDeploy(childNode); err != nil { + for _, dep := range metadata.Deps { + if err := d.linkAndDeploy(dep); err != nil { return err } } // if we just deployed any prerequisite contracts, link their deployed addresses into the bytecode to produce // a deployer bytecode for this contract. - deployerCode := node.unlinkedCode - for _, child := range node.children { - linkAddr := d.deployedAddrs[child.pattern] - if child.overrideAddr != nil { - linkAddr = *child.overrideAddr - } - deployerCode = strings.ReplaceAll(deployerCode, "__$"+child.pattern+"$__", strings.ToLower(linkAddr.String()[2:])) + deployerCode := metadata.Bin + for _, dep := range metadata.Deps { + linkAddr := d.deployedAddrs[dep.Pattern] + deployerCode = strings.ReplaceAll(deployerCode, "__$"+dep.Pattern+"$__", strings.ToLower(linkAddr.String()[2:])) } // Finally, deploy the contract. - addr, tx, err := d.deploy(d.input[node.pattern], common.Hex2Bytes(deployerCode)) + addr, tx, err := d.deploy(d.input[metadata.Pattern], common.Hex2Bytes(deployerCode)) if err != nil { return err } - d.deployedAddrs[node.pattern] = addr - d.deployerTxs[node.pattern] = tx + d.deployedAddrs[metadata.Pattern] = addr + d.deployerTxs[metadata.Pattern] = tx return nil } @@ -207,23 +110,16 @@ func newDepTreeDeployer(deploy DeployFn) *depTreeDeployer { // libraries. If an error occurs, only contracts which were successfully // deployed are returned in the result. func LinkAndDeploy(deployParams *DeploymentParams, deploy DeployFn) (res *DeploymentResult, err error) { - unlinkedContracts := make(map[string]string) accumRes := &DeploymentResult{ Txs: make(map[string]*types.Transaction), Addrs: make(map[string]common.Address), } - for _, meta := range deployParams.contracts { - unlinkedContracts[meta.Pattern] = meta.Bin[2:] - } - treeBuilder := newDepTreeBuilder(deployParams.overrides, unlinkedContracts) - deps, _ := treeBuilder.BuildDepTrees() - - for _, tr := range deps { - deployer := newDepTreeDeployer(deploy) + deployer := newDepTreeDeployer(deploy) + for _, contract := range deployParams.contracts { if deployParams.inputs != nil { - deployer.input = map[string][]byte{tr.pattern: deployParams.inputs[tr.pattern]} + deployer.input = map[string][]byte{contract.Pattern: deployParams.inputs[contract.Pattern]} } - err := deployer.linkAndDeploy(tr) + err := deployer.linkAndDeploy(contract) res := deployer.result() accumRes.Accumulate(res) if err != nil { diff --git a/accounts/abi/bind/dep_tree_test.go b/accounts/abi/bind/dep_tree_test.go index 87390bb033b0..12f4c87f6a3f 100644 --- a/accounts/abi/bind/dep_tree_test.go +++ b/accounts/abi/bind/dep_tree_test.go @@ -94,6 +94,36 @@ type linkTestCaseInput struct { expectDeployed map[rune]struct{} } +// linkDeps will return a set of root dependencies and their sub-dependencies connected via the Deps field +func linkDeps(deps map[string]*MetaData) []*MetaData { + roots := make(map[string]struct{}) + for pattern, _ := range deps { + roots[pattern] = struct{}{} + } + + connectedDeps := make(map[string]MetaData) + for pattern, dep := range deps { + connectedDeps[pattern] = __linkDeps(*dep, deps, &roots) + } + rootMetadatas := []*MetaData{} + for pattern, _ := range roots { + dep := connectedDeps[pattern] + rootMetadatas = append(rootMetadatas, &dep) + } + return rootMetadatas +} + +func __linkDeps(metadata MetaData, depMap map[string]*MetaData, roots *map[string]struct{}) MetaData { + linked := metadata + depPatterns := parseLibraryDeps(metadata.Bin) + for _, pattern := range depPatterns { + delete(*roots, pattern) + connectedDep := __linkDeps(*depMap[pattern], depMap, roots) + linked.Deps = append(linked.Deps, &connectedDep) + } + return linked +} + func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { testAddr := crypto.PubkeyToAddress(testKey.PublicKey) var testAddrNonce uint64 @@ -138,24 +168,26 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { return contractAddr, nil, nil } - var contracts []*MetaData + var contracts map[string]*MetaData overrides := make(map[string]common.Address) for pattern, bin := range tc.contractCodes { - contracts = append(contracts, &MetaData{Pattern: pattern, Bin: "0x" + bin}) + contracts[pattern] = &MetaData{Pattern: pattern, Bin: "0x" + bin} } for pattern, bin := range tc.libCodes { - contracts = append(contracts, &MetaData{ + contracts[pattern] = &MetaData{ Bin: "0x" + bin, Pattern: pattern, - }) + } } + contractsList := linkDeps(contracts) + for pattern, override := range tc.overrides { overrides[pattern] = override } - deployParams := NewDeploymentParams(contracts, nil, overrides) + deployParams := NewDeploymentParams(contractsList, nil, overrides) res, err := LinkAndDeploy(deployParams, mockDeploy) if err != nil { t.Fatalf("got error from LinkAndDeploy: %v\n", err) diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index 89e4673def0c..7b60484189c9 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -33,12 +33,6 @@ var ( {{end}} {{range $contract := .Contracts}} - var {{$contract.Type}}LibraryDeps = []*bind.MetaData{ - {{range $name, $pattern := .Libraries -}} - {{$name}}MetaData, - {{ end}} - } - // TODO: convert this type to value type after everything works. // {{.Type}}MetaData contains all meta data concerning the {{.Type}} contract. var {{.Type}}MetaData = &bind.MetaData{ @@ -47,6 +41,9 @@ var ( {{if .InputBin -}} Bin: "0x{{.InputBin}}", {{end}} + {{if .Libraries -}}{{range $name, $pattern := .Libraries}} + {{$name}}MetaData, + {{end}}{{end}} } // {{.Type}} is an auto generated Go binding around an Ethereum contract. From 0d443b83fda37c590f78fe4f717e9062d63a78a4 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 19 Dec 2024 13:29:01 +0700 Subject: [PATCH 090/104] embed direct library relations in metadata in bindings. simplify dependency tree handling as a result of embedding it in the bindings. --- accounts/abi/bind/dep_tree.go | 22 +++++-- accounts/abi/bind/dep_tree_test.go | 41 ++++++------- accounts/abi/bind/source2.go.tpl | 10 +++- accounts/abi/bind/v2/internal/db/bindings.go | 2 - .../abi/bind/v2/internal/events/bindings.go | 2 - .../v2/internal/nested_libraries/bindings.go | 57 +++++++------------ .../bind/v2/internal/solc_errors/bindings.go | 4 -- accounts/abi/bind/v2/lib_test.go | 4 +- 8 files changed, 64 insertions(+), 78 deletions(-) diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index 072e716368dd..8bcf9aa51305 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -1,6 +1,8 @@ package bind import ( + "encoding/hex" + "fmt" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "maps" @@ -52,6 +54,7 @@ type DeployFn func(input, deployer []byte) (common.Address, *types.Transaction, // depTreeDeployer is responsible for taking a dependency, deploying-and-linking its components in the proper // order. A depTreeDeployer cannot be used after calling LinkAndDeploy other than to retrieve the deployment result. type depTreeDeployer struct { + overrideAddrs map[string]common.Address deployedAddrs map[string]common.Address deployerTxs map[string]*types.Transaction input map[string][]byte // map of the root contract pattern to the constructor input (if there is any) @@ -62,10 +65,9 @@ type depTreeDeployer struct { // The deployment result (deploy addresses/txs or an error) is stored in the depTreeDeployer object. func (d *depTreeDeployer) linkAndDeploy(metadata *MetaData) error { // don't deploy contracts specified as overrides. don't deploy their dependencies. - if _, ok := d.deployedAddrs[metadata.Pattern]; ok { + if _, ok := d.overrideAddrs[metadata.Pattern]; ok { return nil } - // if this contract/library depends on other libraries deploy them (and their dependencies) first for _, dep := range metadata.Deps { if err := d.linkAndDeploy(dep); err != nil { @@ -76,12 +78,19 @@ func (d *depTreeDeployer) linkAndDeploy(metadata *MetaData) error { // a deployer bytecode for this contract. deployerCode := metadata.Bin for _, dep := range metadata.Deps { - linkAddr := d.deployedAddrs[dep.Pattern] + linkAddr, ok := d.deployedAddrs[dep.Pattern] + if !ok { + linkAddr = d.overrideAddrs[dep.Pattern] + } deployerCode = strings.ReplaceAll(deployerCode, "__$"+dep.Pattern+"$__", strings.ToLower(linkAddr.String()[2:])) } // Finally, deploy the contract. - addr, tx, err := d.deploy(d.input[metadata.Pattern], common.Hex2Bytes(deployerCode)) + deployer, err := hex.DecodeString(deployerCode[2:]) + if err != nil { + panic(fmt.Sprintf("error decoding contract deployer hex %s:\n%v", deployerCode[2:], err)) + } + addr, tx, err := d.deploy(d.input[metadata.Pattern], deployer) if err != nil { return err } @@ -99,9 +108,10 @@ func (d *depTreeDeployer) result() *DeploymentResult { } } -func newDepTreeDeployer(deploy DeployFn) *depTreeDeployer { +func newDepTreeDeployer(overrides map[string]common.Address, deploy DeployFn) *depTreeDeployer { return &depTreeDeployer{ deploy: deploy, + overrideAddrs: overrides, deployedAddrs: make(map[string]common.Address), deployerTxs: make(map[string]*types.Transaction)} } @@ -114,7 +124,7 @@ func LinkAndDeploy(deployParams *DeploymentParams, deploy DeployFn) (res *Deploy Txs: make(map[string]*types.Transaction), Addrs: make(map[string]common.Address), } - deployer := newDepTreeDeployer(deploy) + deployer := newDepTreeDeployer(deployParams.overrides, deploy) for _, contract := range deployParams.contracts { if deployParams.inputs != nil { deployer.input = map[string][]byte{contract.Pattern: deployParams.inputs[contract.Pattern]} diff --git a/accounts/abi/bind/dep_tree_test.go b/accounts/abi/bind/dep_tree_test.go index 12f4c87f6a3f..61726239464c 100644 --- a/accounts/abi/bind/dep_tree_test.go +++ b/accounts/abi/bind/dep_tree_test.go @@ -168,7 +168,7 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { return contractAddr, nil, nil } - var contracts map[string]*MetaData + contracts := make(map[string]*MetaData) overrides := make(map[string]common.Address) for pattern, bin := range tc.contractCodes { @@ -205,24 +205,29 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { } func TestContractLinking(t *testing.T) { + // test simple contract without any dependencies or overrides + testLinkCase(t, linkTestCaseInput{ + map[rune][]rune{ + 'a': {}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}}}) + // test deployment of a contract that depends on somes libraries. testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}}, map[rune]struct{}{}, map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, - }, - }) - + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}}}) + // test deployment of a contract that depends on some libraries, + // one of which has its own library dependencies. testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'e': {'f', 'g', 'h', 'i'}}, map[rune]struct{}{}, map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, - }}) - + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}}}) // test single contract only without deps testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ @@ -231,7 +236,6 @@ func TestContractLinking(t *testing.T) { map[rune]struct{}{ 'a': {}, }}) - // test that libraries at different levels of the tree can share deps, // and that these shared deps will only be deployed once. testLinkCase(t, linkTestCaseInput{ @@ -243,7 +247,6 @@ func TestContractLinking(t *testing.T) { map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, 'k': {}, 'l': {}, 'm': {}, }}) - // test two contracts can be deployed which don't share deps testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ @@ -253,7 +256,6 @@ func TestContractLinking(t *testing.T) { map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, }}) - // test two contracts can be deployed which share deps testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ @@ -263,32 +265,26 @@ func TestContractLinking(t *testing.T) { map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, }}) - // test one contract with overrides for all lib deps testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}}, map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}}, map[rune]struct{}{ - 'a': {}, - }}) - + 'a': {}}}) // test one contract with overrides for some lib deps testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c'}}, map[rune]struct{}{'b': {}, 'c': {}}, map[rune]struct{}{ - 'a': {}, - }}) - + 'a': {}}}) // test deployment of a contract with overrides testLinkCase(t, linkTestCaseInput{ map[rune][]rune{ 'a': {}}, map[rune]struct{}{'a': {}}, map[rune]struct{}{}}) - // two contracts ('a' and 'f') share some dependencies. contract 'a' is marked as an override. expect that any of // its depdencies that aren't shared with 'f' are not deployed. testLinkCase(t, linkTestCaseInput{map[rune][]rune{ @@ -296,9 +292,7 @@ func TestContractLinking(t *testing.T) { 'f': {'g', 'c', 'd', 'h'}}, map[rune]struct{}{'a': {}}, map[rune]struct{}{ - 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}, - }}) - + 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}}}) // test nested libraries that share deps at different levels of the tree... with override. // same condition as above test: no sub-dependencies of testLinkCase(t, linkTestCaseInput{ @@ -311,6 +305,5 @@ func TestContractLinking(t *testing.T) { 'i': {}, }, map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}, - }}) + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}}}) } diff --git a/accounts/abi/bind/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index 7b60484189c9..29c53f51a117 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -40,10 +40,14 @@ var ( Pattern: "{{index $.Libraries .Type}}", {{if .InputBin -}} Bin: "0x{{.InputBin}}", - {{end}} - {{if .Libraries -}}{{range $name, $pattern := .Libraries}} + {{end -}} + {{if .Libraries -}} + Deps: []*bind.MetaData{ + {{- range $name, $pattern := .Libraries}} {{$name}}MetaData, - {{end}}{{end}} + {{- end}} + }, + {{end}} } // {{.Type}} is an auto generated Go binding around an Ethereum contract. diff --git a/accounts/abi/bind/v2/internal/db/bindings.go b/accounts/abi/bind/v2/internal/db/bindings.go index a6e1aeed42a3..74f8fbd37472 100644 --- a/accounts/abi/bind/v2/internal/db/bindings.go +++ b/accounts/abi/bind/v2/internal/db/bindings.go @@ -30,8 +30,6 @@ type DBStats struct { Mods *big.Int } -var DBLibraryDeps = []*bind.MetaData{} - // TODO: convert this type to value type after everything works. // DBMetaData contains all meta data concerning the DB contract. var DBMetaData = &bind.MetaData{ diff --git a/accounts/abi/bind/v2/internal/events/bindings.go b/accounts/abi/bind/v2/internal/events/bindings.go index 8331c9864ce1..1bf5d4ce107d 100644 --- a/accounts/abi/bind/v2/internal/events/bindings.go +++ b/accounts/abi/bind/v2/internal/events/bindings.go @@ -29,8 +29,6 @@ type CPoint struct { Y *big.Int } -var CLibraryDeps = []*bind.MetaData{} - // TODO: convert this type to value type after everything works. // CMetaData contains all meta data concerning the C contract. var CMetaData = &bind.MetaData{ diff --git a/accounts/abi/bind/v2/internal/nested_libraries/bindings.go b/accounts/abi/bind/v2/internal/nested_libraries/bindings.go index 212c81bc8b48..d8302994e43a 100644 --- a/accounts/abi/bind/v2/internal/nested_libraries/bindings.go +++ b/accounts/abi/bind/v2/internal/nested_libraries/bindings.go @@ -23,19 +23,16 @@ var ( _ = abi.ConvertType ) -var C1LibraryDeps = []*bind.MetaData{ - L1MetaData, - L2MetaData, - L3MetaData, - L4MetaData, -} - // 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. @@ -76,18 +73,16 @@ func (_C1 *C1) UnpackDo(data []byte) (*big.Int, error) { } -var C2LibraryDeps = []*bind.MetaData{ - L1MetaData, - L2bMetaData, - L4bMetaData, -} - // 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. @@ -128,8 +123,6 @@ func (_C2 *C2) UnpackDo(data []byte) (*big.Int, error) { } -var L1LibraryDeps = []*bind.MetaData{} - // TODO: convert this type to value type after everything works. // L1MetaData contains all meta data concerning the L1 contract. var L1MetaData = &bind.MetaData{ @@ -176,16 +169,15 @@ func (_L1 *L1) UnpackDo(data []byte) (*big.Int, error) { } -var L2LibraryDeps = []*bind.MetaData{ - L1MetaData, -} - // 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. @@ -226,16 +218,15 @@ func (_L2 *L2) UnpackDo(data []byte) (*big.Int, error) { } -var L2bLibraryDeps = []*bind.MetaData{ - L1MetaData, -} - // 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. @@ -276,8 +267,6 @@ func (_L2b *L2b) UnpackDo(data []byte) (*big.Int, error) { } -var L3LibraryDeps = []*bind.MetaData{} - // TODO: convert this type to value type after everything works. // L3MetaData contains all meta data concerning the L3 contract. var L3MetaData = &bind.MetaData{ @@ -324,18 +313,16 @@ func (_L3 *L3) UnpackDo(data []byte) (*big.Int, error) { } -var L4LibraryDeps = []*bind.MetaData{ - L1MetaData, - L2MetaData, - L3MetaData, -} - // 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. @@ -376,17 +363,15 @@ func (_L4 *L4) UnpackDo(data []byte) (*big.Int, error) { } -var L4bLibraryDeps = []*bind.MetaData{ - L1MetaData, - L2bMetaData, -} - // 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. diff --git a/accounts/abi/bind/v2/internal/solc_errors/bindings.go b/accounts/abi/bind/v2/internal/solc_errors/bindings.go index 5b1a0cba5e6f..c2389b22ac1d 100644 --- a/accounts/abi/bind/v2/internal/solc_errors/bindings.go +++ b/accounts/abi/bind/v2/internal/solc_errors/bindings.go @@ -23,8 +23,6 @@ var ( _ = abi.ConvertType ) -var CLibraryDeps = []*bind.MetaData{} - // TODO: convert this type to value type after everything works. // CMetaData contains all meta data concerning the C contract. var CMetaData = &bind.MetaData{ @@ -121,8 +119,6 @@ func (_C *C) UnpackBadThing2Error(raw []byte) (*CBadThing2, error) { return out, nil } -var C2LibraryDeps = []*bind.MetaData{} - // TODO: convert this type to value type after everything works. // C2MetaData contains all meta data concerning the C2 contract. var C2MetaData = &bind.MetaData{ diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index cb1210396024..ba8c210baf32 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -121,7 +121,7 @@ func TestDeploymentLibraries(t *testing.T) { if err != nil { t.Fatalf("failed to pack constructor: %v", err) } - deploymentParams := bind.NewDeploymentParams(append(nested_libraries.C1LibraryDeps, nested_libraries.C1MetaData), map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, nil) + deploymentParams := bind.NewDeploymentParams([]*bind.MetaData{nested_libraries.C1MetaData}, map[string][]byte{nested_libraries.C1MetaData.Pattern: constructorInput}, nil) res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { @@ -166,6 +166,7 @@ func TestDeploymentLibraries(t *testing.T) { } } +/* // Same as TestDeployment. However, stagger the deployments with overrides: // first deploy the library deps and then the contract. func TestDeploymentWithOverrides(t *testing.T) { @@ -253,6 +254,7 @@ func TestDeploymentWithOverrides(t *testing.T) { t.Fatalf("expected internal call count of 6. got %d.", internalCallCount.Uint64()) } } +*/ func TestEvents(t *testing.T) { // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) From 4ad21ba34e1f30c39bbb127095e95cd33592f447 Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Thu, 19 Dec 2024 09:22:12 +0100 Subject: [PATCH 091/104] accounts/abi/bind: simplifications --- accounts/abi/bind/dep_tree.go | 43 +++++++++++------------------- accounts/abi/bind/dep_tree_test.go | 2 +- 2 files changed, 17 insertions(+), 28 deletions(-) diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index 8bcf9aa51305..1ce4ce08f347 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -3,10 +3,11 @@ package bind import ( "encoding/hex" "fmt" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" "maps" "strings" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" ) // DeploymentParams represents parameters needed to deploy a @@ -54,18 +55,24 @@ type DeployFn func(input, deployer []byte) (common.Address, *types.Transaction, // depTreeDeployer is responsible for taking a dependency, deploying-and-linking its components in the proper // order. A depTreeDeployer cannot be used after calling LinkAndDeploy other than to retrieve the deployment result. type depTreeDeployer struct { - overrideAddrs map[string]common.Address deployedAddrs map[string]common.Address deployerTxs map[string]*types.Transaction input map[string][]byte // map of the root contract pattern to the constructor input (if there is any) deploy DeployFn } +func newDepTreeDeployer(overrides map[string]common.Address, deploy DeployFn) *depTreeDeployer { + return &depTreeDeployer{ + deploy: deploy, + deployedAddrs: maps.Clone(overrides), + deployerTxs: make(map[string]*types.Transaction)} +} + // linkAndDeploy recursively deploys a contract and its dependencies: starting by linking/deploying its dependencies. // The deployment result (deploy addresses/txs or an error) is stored in the depTreeDeployer object. func (d *depTreeDeployer) linkAndDeploy(metadata *MetaData) error { - // don't deploy contracts specified as overrides. don't deploy their dependencies. - if _, ok := d.overrideAddrs[metadata.Pattern]; ok { + // Don't deploy already deployed contracts + if _, ok := d.deployedAddrs[metadata.Pattern]; ok { return nil } // if this contract/library depends on other libraries deploy them (and their dependencies) first @@ -78,10 +85,7 @@ func (d *depTreeDeployer) linkAndDeploy(metadata *MetaData) error { // a deployer bytecode for this contract. deployerCode := metadata.Bin for _, dep := range metadata.Deps { - linkAddr, ok := d.deployedAddrs[dep.Pattern] - if !ok { - linkAddr = d.overrideAddrs[dep.Pattern] - } + linkAddr, _ := d.deployedAddrs[dep.Pattern] deployerCode = strings.ReplaceAll(deployerCode, "__$"+dep.Pattern+"$__", strings.ToLower(linkAddr.String()[2:])) } @@ -108,33 +112,18 @@ func (d *depTreeDeployer) result() *DeploymentResult { } } -func newDepTreeDeployer(overrides map[string]common.Address, deploy DeployFn) *depTreeDeployer { - return &depTreeDeployer{ - deploy: deploy, - overrideAddrs: overrides, - deployedAddrs: make(map[string]common.Address), - deployerTxs: make(map[string]*types.Transaction)} -} - // LinkAndDeploy deploys a specified set of contracts and their dependent // libraries. If an error occurs, only contracts which were successfully // deployed are returned in the result. func LinkAndDeploy(deployParams *DeploymentParams, deploy DeployFn) (res *DeploymentResult, err error) { - accumRes := &DeploymentResult{ - Txs: make(map[string]*types.Transaction), - Addrs: make(map[string]common.Address), - } deployer := newDepTreeDeployer(deployParams.overrides, deploy) for _, contract := range deployParams.contracts { if deployParams.inputs != nil { deployer.input = map[string][]byte{contract.Pattern: deployParams.inputs[contract.Pattern]} } - err := deployer.linkAndDeploy(contract) - res := deployer.result() - accumRes.Accumulate(res) - if err != nil { - return accumRes, err + if err := deployer.linkAndDeploy(contract); err != nil { + return deployer.result(), err } } - return accumRes, nil + return deployer.result(), nil } diff --git a/accounts/abi/bind/dep_tree_test.go b/accounts/abi/bind/dep_tree_test.go index 61726239464c..2ade604cb9fb 100644 --- a/accounts/abi/bind/dep_tree_test.go +++ b/accounts/abi/bind/dep_tree_test.go @@ -193,7 +193,7 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { t.Fatalf("got error from LinkAndDeploy: %v\n", err) } - if len(res.Addrs) != len(tcInput.expectDeployed) { + if len(res.Txs) != len(tcInput.expectDeployed) { t.Fatalf("got %d deployed contracts. expected %d.\n", len(res.Addrs), len(tcInput.expectDeployed)) } for contract, _ := range tcInput.expectDeployed { From 62a780626c913364b947afe4afc82ae1845f65f7 Mon Sep 17 00:00:00 2001 From: Martin Holst Swende Date: Thu, 19 Dec 2024 10:04:44 +0100 Subject: [PATCH 092/104] clarifications --- accounts/abi/bind/dep_tree.go | 58 ++++++++++++++--------------------- 1 file changed, 23 insertions(+), 35 deletions(-) diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index 1ce4ce08f347..d7c3bdca7801 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -42,12 +42,6 @@ type DeploymentResult struct { Addrs map[string]common.Address } -// Accumulate merges `other` into `d` -func (d *DeploymentResult) Accumulate(other *DeploymentResult) { - maps.Copy(d.Txs, other.Txs) - maps.Copy(d.Addrs, other.Addrs) -} - // DeployFn deploys a contract given a deployer and optional input. It returns // the address and a pending transaction, or an error if the deployment failed. type DeployFn func(input, deployer []byte) (common.Address, *types.Transaction, error) @@ -57,51 +51,48 @@ type DeployFn func(input, deployer []byte) (common.Address, *types.Transaction, type depTreeDeployer struct { deployedAddrs map[string]common.Address deployerTxs map[string]*types.Transaction - input map[string][]byte // map of the root contract pattern to the constructor input (if there is any) - deploy DeployFn + inputs map[string][]byte // map of the root contract pattern to the constructor input (if there is any) + deployFn DeployFn } -func newDepTreeDeployer(overrides map[string]common.Address, deploy DeployFn) *depTreeDeployer { +func newDepTreeDeployer(deployParams *DeploymentParams, deployFn DeployFn) *depTreeDeployer { return &depTreeDeployer{ - deploy: deploy, - deployedAddrs: maps.Clone(overrides), - deployerTxs: make(map[string]*types.Transaction)} + deployFn: deployFn, + deployedAddrs: maps.Clone(deployParams.overrides), + deployerTxs: make(map[string]*types.Transaction), + inputs: maps.Clone(deployParams.inputs), + } } // linkAndDeploy recursively deploys a contract and its dependencies: starting by linking/deploying its dependencies. // The deployment result (deploy addresses/txs or an error) is stored in the depTreeDeployer object. -func (d *depTreeDeployer) linkAndDeploy(metadata *MetaData) error { +func (d *depTreeDeployer) linkAndDeploy(metadata *MetaData) (common.Address, error) { // Don't deploy already deployed contracts - if _, ok := d.deployedAddrs[metadata.Pattern]; ok { - return nil + if addr, ok := d.deployedAddrs[metadata.Pattern]; ok { + return addr, nil } // if this contract/library depends on other libraries deploy them (and their dependencies) first - for _, dep := range metadata.Deps { - if err := d.linkAndDeploy(dep); err != nil { - return err - } - } - // if we just deployed any prerequisite contracts, link their deployed addresses into the bytecode to produce - // a deployer bytecode for this contract. deployerCode := metadata.Bin for _, dep := range metadata.Deps { - linkAddr, _ := d.deployedAddrs[dep.Pattern] - deployerCode = strings.ReplaceAll(deployerCode, "__$"+dep.Pattern+"$__", strings.ToLower(linkAddr.String()[2:])) + addr, err := d.linkAndDeploy(dep) + if err != nil { + return common.Address{}, err + } + // link their deployed addresses into the bytecode to produce + deployerCode = strings.ReplaceAll(deployerCode, "__$"+dep.Pattern+"$__", strings.ToLower(addr.String()[2:])) } - // Finally, deploy the contract. - deployer, err := hex.DecodeString(deployerCode[2:]) + code, err := hex.DecodeString(deployerCode[2:]) if err != nil { panic(fmt.Sprintf("error decoding contract deployer hex %s:\n%v", deployerCode[2:], err)) } - addr, tx, err := d.deploy(d.input[metadata.Pattern], deployer) + addr, tx, err := d.deployFn(d.inputs[metadata.Pattern], code) if err != nil { - return err + return common.Address{}, err } - d.deployedAddrs[metadata.Pattern] = addr d.deployerTxs[metadata.Pattern] = tx - return nil + return addr, nil } // result returns a result for this deployment, or an error if it failed. @@ -116,12 +107,9 @@ func (d *depTreeDeployer) result() *DeploymentResult { // libraries. If an error occurs, only contracts which were successfully // deployed are returned in the result. func LinkAndDeploy(deployParams *DeploymentParams, deploy DeployFn) (res *DeploymentResult, err error) { - deployer := newDepTreeDeployer(deployParams.overrides, deploy) + deployer := newDepTreeDeployer(deployParams, deploy) for _, contract := range deployParams.contracts { - if deployParams.inputs != nil { - deployer.input = map[string][]byte{contract.Pattern: deployParams.inputs[contract.Pattern]} - } - if err := deployer.linkAndDeploy(contract); err != nil { + if _, err := deployer.linkAndDeploy(contract); err != nil { return deployer.result(), err } } From f0902b3059ec2ee174cbca2d0c3f8e90480ef368 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 19 Dec 2024 17:00:13 +0700 Subject: [PATCH 093/104] accounts/abi/bind: make link test case failure output the index of the subtest that failed. --- accounts/abi/bind/bindv2_test.go | 124 +++++++++++++++++++++++++++++ accounts/abi/bind/dep_tree_test.go | 81 ++++++++++++------- 2 files changed, 175 insertions(+), 30 deletions(-) create mode 100644 accounts/abi/bind/bindv2_test.go diff --git a/accounts/abi/bind/bindv2_test.go b/accounts/abi/bind/bindv2_test.go new file mode 100644 index 000000000000..502c57988a77 --- /dev/null +++ b/accounts/abi/bind/bindv2_test.go @@ -0,0 +1,124 @@ +package bind + +import ( + "fmt" + "testing" + + "github.com/ethereum/go-ethereum/crypto" +) + +type bindV2Test struct { + name string + abis []string + bytecodes []string + types []string + + expectedBindings string +} + +func bind(test *bindV2Test) (bound string, err error) { + var ( + abis []string + bins []string + types []string + ) + libs := make(map[string]string) + for i := 0; i < len(test.types); i++ { + // fully qualified name is of the form : + typeName := test.types[i] + bin := test.bytecodes[i] + abis = append(abis, test.abis[i]) + bins = append(bins, bin) + types = append(types, typeName) + + // Derive the library placeholder which is a 34 character prefix of the + // hex encoding of the keccak256 hash of the fully qualified library name. + // Note that the fully qualified library name is the path of its source + // file and the library name separated by ":". + libPattern := crypto.Keccak256Hash([]byte(typeName)).String()[2:36] // the first 2 chars are 0x + libs[libPattern] = typeName + } + code, err := BindV2(types, abis, bins, "bindv2test", libs, make(map[string]string)) + if err != nil { + return "", fmt.Errorf("error creating bindings: %v", err) + } + + return code, nil +} + +var bindTests2 = []bindV2Test{ + { + "Empty", + []string{`[]`}, + []string{`606060405260068060106000396000f3606060405200`}, + nil, + `// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package bindv2test + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) +`, + }, + { + "Token", + []string{`[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"success","type":"bool"}],"type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"},{"name":"_extraData","type":"bytes"}],"name":"approveAndCall","outputs":[{"name":"success","type":"bool"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"spentAllowance","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"inputs":[{"name":"initialSupply","type":"uint256"},{"name":"tokenName","type":"string"},{"name":"decimalUnits","type":"uint8"},{"name":"tokenSymbol","type":"string"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"}]`}, + []string{`60606040526040516107fd3803806107fd83398101604052805160805160a05160c051929391820192909101600160a060020a0333166000908152600360209081526040822086905581548551838052601f6002600019610100600186161502019093169290920482018390047f290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e56390810193919290918801908390106100e857805160ff19168380011785555b506101189291505b8082111561017157600081556001016100b4565b50506002805460ff19168317905550505050610658806101a56000396000f35b828001600101855582156100ac579182015b828111156100ac5782518260005055916020019190600101906100fa565b50508060016000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061017557805160ff19168380011785555b506100c89291506100b4565b5090565b82800160010185558215610165579182015b8281111561016557825182600050559160200191906001019061018756606060405236156100775760e060020a600035046306fdde03811461007f57806323b872dd146100dc578063313ce5671461010e57806370a082311461011a57806395d89b4114610132578063a9059cbb1461018e578063cae9ca51146101bd578063dc3080f21461031c578063dd62ed3e14610341575b610365610002565b61036760008054602060026001831615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156104eb5780601f106104c0576101008083540402835291602001916104eb565b6103d5600435602435604435600160a060020a038316600090815260036020526040812054829010156104f357610002565b6103e760025460ff1681565b6103d560043560036020526000908152604090205481565b610367600180546020600282841615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156104eb5780601f106104c0576101008083540402835291602001916104eb565b610365600435602435600160a060020a033316600090815260036020526040902054819010156103f157610002565b60806020604435600481810135601f8101849004909302840160405260608381526103d5948235946024803595606494939101919081908382808284375094965050505050505060006000836004600050600033600160a060020a03168152602001908152602001600020600050600087600160a060020a031681526020019081526020016000206000508190555084905080600160a060020a0316638f4ffcb1338630876040518560e060020a0281526004018085600160a060020a0316815260200184815260200183600160a060020a03168152602001806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156102f25780820380516001836020036101000a031916815260200191505b50955050505050506000604051808303816000876161da5a03f11561000257505050509392505050565b6005602090815260043560009081526040808220909252602435815220546103d59081565b60046020818152903560009081526040808220909252602435815220546103d59081565b005b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156103c75780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60408051918252519081900360200190f35b6060908152602090f35b600160a060020a03821660009081526040902054808201101561041357610002565b806003600050600033600160a060020a03168152602001908152602001600020600082828250540392505081905550806003600050600084600160a060020a0316815260200190815260200160002060008282825054019250508190555081600160a060020a031633600160a060020a03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040518082815260200191505060405180910390a35050565b820191906000526020600020905b8154815290600101906020018083116104ce57829003601f168201915b505050505081565b600160a060020a03831681526040812054808301101561051257610002565b600160a060020a0380851680835260046020908152604080852033949094168086529382528085205492855260058252808520938552929052908220548301111561055c57610002565b816003600050600086600160a060020a03168152602001908152602001600020600082828250540392505081905550816003600050600085600160a060020a03168152602001908152602001600020600082828250540192505081905550816005600050600086600160a060020a03168152602001908152602001600020600050600033600160a060020a0316815260200190815260200160002060008282825054019250508190555082600160a060020a031633600160a060020a03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040518082815260200191505060405180910390a3939250505056`}, + nil, + `// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package bindv2test + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) +`, + }, +} + +func TestBindingV2(t *testing.T) { + for _, tc := range bindTests2 { + code, err := bind(&tc) + if err != nil { + t.Fatalf("got error from bind: %v", err) + } + if code != tc.expectedBindings { + t.Fatalf("'%s'\n!=\n'%s'\n", code, tc.expectedBindings) + } + } +} diff --git a/accounts/abi/bind/dep_tree_test.go b/accounts/abi/bind/dep_tree_test.go index 2ade604cb9fb..14aedb6bc081 100644 --- a/accounts/abi/bind/dep_tree_test.go +++ b/accounts/abi/bind/dep_tree_test.go @@ -124,7 +124,7 @@ func __linkDeps(metadata MetaData, depMap map[string]*MetaData, roots *map[strin return linked } -func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { +func testLinkCase(tcInput linkTestCaseInput) error { testAddr := crypto.PubkeyToAddress(testKey.PublicKey) var testAddrNonce uint64 overridesAddrs := make(map[common.Address]struct{}) @@ -159,7 +159,7 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { var dep common.Address dep.SetBytes(deployer[i : i+20]) if _, ok := overridesAddrs[dep]; !ok { - t.Fatalf("reference to dependent contract that has not yet been deployed: %x\n", dep) + return common.Address{}, nil, fmt.Errorf("reference to dependent contract that has not yet been deployed: %x\n", dep) } } } @@ -190,55 +190,60 @@ func testLinkCase(t *testing.T, tcInput linkTestCaseInput) { deployParams := NewDeploymentParams(contractsList, nil, overrides) res, err := LinkAndDeploy(deployParams, mockDeploy) if err != nil { - t.Fatalf("got error from LinkAndDeploy: %v\n", err) + return err } if len(res.Txs) != len(tcInput.expectDeployed) { - t.Fatalf("got %d deployed contracts. expected %d.\n", len(res.Addrs), len(tcInput.expectDeployed)) + return fmt.Errorf("got %d deployed contracts. expected %d.\n", len(res.Addrs), len(tcInput.expectDeployed)) } for contract, _ := range tcInput.expectDeployed { pattern := crypto.Keccak256Hash([]byte(string(contract))).String()[2:36] if _, ok := res.Addrs[pattern]; !ok { - t.Fatalf("expected contract %s was not deployed\n", string(contract)) + return fmt.Errorf("expected contract %s was not deployed\n", string(contract)) } } + return nil } -func TestContractLinking(t *testing.T) { +var linkTestCases = []linkTestCaseInput{ // test simple contract without any dependencies or overrides - testLinkCase(t, linkTestCaseInput{ + { map[rune][]rune{ 'a': {}}, map[rune]struct{}{}, map[rune]struct{}{ - 'a': {}}}) + 'a': {}}, + }, // test deployment of a contract that depends on somes libraries. - testLinkCase(t, linkTestCaseInput{ + { map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}}, map[rune]struct{}{}, map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}}}) + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}}, + }, // test deployment of a contract that depends on some libraries, // one of which has its own library dependencies. - testLinkCase(t, linkTestCaseInput{ + { map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'e': {'f', 'g', 'h', 'i'}}, map[rune]struct{}{}, map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}}}) + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}}, + }, // test single contract only without deps - testLinkCase(t, linkTestCaseInput{ + { map[rune][]rune{ 'a': {}}, map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, - }}) + }, + }, // test that libraries at different levels of the tree can share deps, // and that these shared deps will only be deployed once. - testLinkCase(t, linkTestCaseInput{ + { map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'e': {'f', 'g', 'h', 'i', 'm'}, @@ -246,56 +251,63 @@ func TestContractLinking(t *testing.T) { map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, 'k': {}, 'l': {}, 'm': {}, - }}) + }, + }, // test two contracts can be deployed which don't share deps - testLinkCase(t, linkTestCaseInput{ + linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'h', 'i', 'j'}}, map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, - }}) + }, + }, // test two contracts can be deployed which share deps - testLinkCase(t, linkTestCaseInput{ + linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'c', 'd', 'h'}}, map[rune]struct{}{}, map[rune]struct{}{ 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, - }}) + }, + }, // test one contract with overrides for all lib deps - testLinkCase(t, linkTestCaseInput{ + linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}}, map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}}, map[rune]struct{}{ - 'a': {}}}) + 'a': {}}, + }, // test one contract with overrides for some lib deps - testLinkCase(t, linkTestCaseInput{ + linkTestCaseInput{ map[rune][]rune{ 'a': {'b', 'c'}}, map[rune]struct{}{'b': {}, 'c': {}}, map[rune]struct{}{ - 'a': {}}}) + 'a': {}}, + }, // test deployment of a contract with overrides - testLinkCase(t, linkTestCaseInput{ + linkTestCaseInput{ map[rune][]rune{ 'a': {}}, map[rune]struct{}{'a': {}}, - map[rune]struct{}{}}) + map[rune]struct{}{}, + }, // two contracts ('a' and 'f') share some dependencies. contract 'a' is marked as an override. expect that any of // its depdencies that aren't shared with 'f' are not deployed. - testLinkCase(t, linkTestCaseInput{map[rune][]rune{ + linkTestCaseInput{map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'c', 'd', 'h'}}, map[rune]struct{}{'a': {}}, map[rune]struct{}{ - 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}}}) + 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}}, + }, // test nested libraries that share deps at different levels of the tree... with override. // same condition as above test: no sub-dependencies of - testLinkCase(t, linkTestCaseInput{ + { map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'e': {'f', 'g', 'h', 'i', 'm'}, @@ -305,5 +317,14 @@ func TestContractLinking(t *testing.T) { 'i': {}, }, map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}}}) + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}}, + }, +} + +func TestContractLinking(t *testing.T) { + for i, tc := range linkTestCases { + if err := testLinkCase(tc); err != nil { + t.Fatalf("test case %d failed: %v", i, err) + } + } } From 0d14a79ce0e60d9b6992406960a298dbac5e5cfc Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 19 Dec 2024 17:05:47 +0700 Subject: [PATCH 094/104] accounts/abi/bind: don't define link test case table as a package-private variable --- accounts/abi/bind/dep_tree_test.go | 220 ++++++++++++++--------------- 1 file changed, 109 insertions(+), 111 deletions(-) diff --git a/accounts/abi/bind/dep_tree_test.go b/accounts/abi/bind/dep_tree_test.go index 14aedb6bc081..019336edd93f 100644 --- a/accounts/abi/bind/dep_tree_test.go +++ b/accounts/abi/bind/dep_tree_test.go @@ -205,124 +205,122 @@ func testLinkCase(tcInput linkTestCaseInput) error { return nil } -var linkTestCases = []linkTestCaseInput{ - // test simple contract without any dependencies or overrides - { - map[rune][]rune{ - 'a': {}}, - map[rune]struct{}{}, - map[rune]struct{}{ - 'a': {}}, - }, - // test deployment of a contract that depends on somes libraries. - { - map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}}, - map[rune]struct{}{}, - map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}}, - }, - // test deployment of a contract that depends on some libraries, - // one of which has its own library dependencies. - { - map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'e': {'f', 'g', 'h', 'i'}}, - map[rune]struct{}{}, - map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}}, - }, - // test single contract only without deps - { - map[rune][]rune{ - 'a': {}}, - map[rune]struct{}{}, - map[rune]struct{}{ - 'a': {}, +func TestContractLinking(t *testing.T) { + for i, tc := range []linkTestCaseInput{ + // test simple contract without any dependencies or overrides + { + map[rune][]rune{ + 'a': {}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}}, }, - }, - // test that libraries at different levels of the tree can share deps, - // and that these shared deps will only be deployed once. - { - map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'e': {'f', 'g', 'h', 'i', 'm'}, - 'i': {'j', 'k', 'l', 'm'}}, - map[rune]struct{}{}, - map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, 'k': {}, 'l': {}, 'm': {}, + // test deployment of a contract that depends on somes libraries. + { + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}}, }, - }, - // test two contracts can be deployed which don't share deps - linkTestCaseInput{ - map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'f': {'g', 'h', 'i', 'j'}}, - map[rune]struct{}{}, - map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, + // test deployment of a contract that depends on some libraries, + // one of which has its own library dependencies. + { + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i'}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}}, + }, + // test single contract only without deps + { + map[rune][]rune{ + 'a': {}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, + }, + }, + // test that libraries at different levels of the tree can share deps, + // and that these shared deps will only be deployed once. + { + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i', 'm'}, + 'i': {'j', 'k', 'l', 'm'}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, 'k': {}, 'l': {}, 'm': {}, + }, + }, + // test two contracts can be deployed which don't share deps + linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'f': {'g', 'h', 'i', 'j'}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'i': {}, 'j': {}, + }, + }, + // test two contracts can be deployed which share deps + linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'f': {'g', 'c', 'd', 'h'}}, + map[rune]struct{}{}, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, + }, }, - }, - // test two contracts can be deployed which share deps - linkTestCaseInput{ - map[rune][]rune{ + // test one contract with overrides for all lib deps + linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}}, + map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}}, + map[rune]struct{}{ + 'a': {}}, + }, + // test one contract with overrides for some lib deps + linkTestCaseInput{ + map[rune][]rune{ + 'a': {'b', 'c'}}, + map[rune]struct{}{'b': {}, 'c': {}}, + map[rune]struct{}{ + 'a': {}}, + }, + // test deployment of a contract with overrides + linkTestCaseInput{ + map[rune][]rune{ + 'a': {}}, + map[rune]struct{}{'a': {}}, + map[rune]struct{}{}, + }, + // two contracts ('a' and 'f') share some dependencies. contract 'a' is marked as an override. expect that any of + // its depdencies that aren't shared with 'f' are not deployed. + linkTestCaseInput{map[rune][]rune{ 'a': {'b', 'c', 'd', 'e'}, 'f': {'g', 'c', 'd', 'h'}}, - map[rune]struct{}{}, - map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, + map[rune]struct{}{'a': {}}, + map[rune]struct{}{ + 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}}, }, - }, - // test one contract with overrides for all lib deps - linkTestCaseInput{ - map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}}, - map[rune]struct{}{'b': {}, 'c': {}, 'd': {}, 'e': {}}, - map[rune]struct{}{ - 'a': {}}, - }, - // test one contract with overrides for some lib deps - linkTestCaseInput{ - map[rune][]rune{ - 'a': {'b', 'c'}}, - map[rune]struct{}{'b': {}, 'c': {}}, - map[rune]struct{}{ - 'a': {}}, - }, - // test deployment of a contract with overrides - linkTestCaseInput{ - map[rune][]rune{ - 'a': {}}, - map[rune]struct{}{'a': {}}, - map[rune]struct{}{}, - }, - // two contracts ('a' and 'f') share some dependencies. contract 'a' is marked as an override. expect that any of - // its depdencies that aren't shared with 'f' are not deployed. - linkTestCaseInput{map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'f': {'g', 'c', 'd', 'h'}}, - map[rune]struct{}{'a': {}}, - map[rune]struct{}{ - 'f': {}, 'g': {}, 'c': {}, 'd': {}, 'h': {}}, - }, - // test nested libraries that share deps at different levels of the tree... with override. - // same condition as above test: no sub-dependencies of - { - map[rune][]rune{ - 'a': {'b', 'c', 'd', 'e'}, - 'e': {'f', 'g', 'h', 'i', 'm'}, - 'i': {'j', 'k', 'l', 'm'}, - 'l': {'n', 'o', 'p'}}, - map[rune]struct{}{ - 'i': {}, + // test nested libraries that share deps at different levels of the tree... with override. + // same condition as above test: no sub-dependencies of + { + map[rune][]rune{ + 'a': {'b', 'c', 'd', 'e'}, + 'e': {'f', 'g', 'h', 'i', 'm'}, + 'i': {'j', 'k', 'l', 'm'}, + 'l': {'n', 'o', 'p'}}, + map[rune]struct{}{ + 'i': {}, + }, + map[rune]struct{}{ + 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}}, }, - map[rune]struct{}{ - 'a': {}, 'b': {}, 'c': {}, 'd': {}, 'e': {}, 'f': {}, 'g': {}, 'h': {}, 'm': {}}, - }, -} - -func TestContractLinking(t *testing.T) { - for i, tc := range linkTestCases { + } { if err := testLinkCase(tc); err != nil { t.Fatalf("test case %d failed: %v", i, err) } From 6be0f638e42e904d3547a630ed7539bfe452faf9 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Thu, 19 Dec 2024 19:42:37 +0700 Subject: [PATCH 095/104] accounts/abi/bind: remove unused fields from template structs --- accounts/abi/bind/bind.go | 21 ++++++++++---------- accounts/abi/bind/template.go | 36 +++++++++++++++++------------------ 2 files changed, 27 insertions(+), 30 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index df54c7c643ad..252a763fc0a9 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -228,17 +228,16 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] } contracts[types[i]] = &tmplContract{ - Type: capitalise(types[i]), - InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), - InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), - Constructor: evmABI.Constructor, - Calls: calls, - Transacts: transacts, - Fallback: fallback, - Receive: receive, - Events: events, - Libraries: make(map[string]string), - AllLibraries: make(map[string]string), + Type: capitalise(types[i]), + InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), + InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), + Constructor: evmABI.Constructor, + Calls: calls, + Transacts: transacts, + Fallback: fallback, + Receive: receive, + Events: events, + Libraries: make(map[string]string), } // Function 4-byte signatures are stored in the same sequence diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index 79051a5d66fe..f9a5e9fc466a 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -24,28 +24,26 @@ import ( // tmplData is the data structure required to fill the binding template. type tmplData struct { - Package string // Name of the package to place the generated file in - Contracts map[string]*tmplContract // List of contracts to generate into this file - Libraries map[string]string // Map the bytecode's link pattern to the library name - InvertedLibs map[string]string // map of the contract's name to the link pattern - Structs map[string]*tmplStruct // Contract struct type definitions + Package string // Name of the package to place the generated file in + Contracts map[string]*tmplContract // List of contracts to generate into this file + Libraries map[string]string // Map the bytecode's link pattern to the library name + Structs map[string]*tmplStruct // Contract struct type definitions } // tmplContract contains the data needed to generate an individual contract binding. type tmplContract struct { - Type string // Type name of the main contract binding - InputABI string // JSON ABI used as the input to generate the binding from - InputBin string // Optional EVM bytecode used to generate deploy code from - FuncSigs map[string]string // Optional map: string signature -> 4-byte signature - Constructor abi.Method // Contract constructor for deploy parametrization - Calls map[string]*tmplMethod // Contract calls that only read state data - Transacts map[string]*tmplMethod // Contract calls that write state data - Fallback *tmplMethod // Additional special fallback function - Receive *tmplMethod // Additional special receive function - Events map[string]*tmplEvent // Contract events accessors - Libraries map[string]string // Same as tmplData, but filtered to only keep direct deps that the contract needs - AllLibraries map[string]string // same as Libraries, but all direct/indirect library dependencies - Library bool // Indicator whether the contract is a library + Type string // Type name of the main contract binding + InputABI string // JSON ABI used as the input to generate the binding from + InputBin string // Optional EVM bytecode used to generate deploy code from + FuncSigs map[string]string // Optional map: string signature -> 4-byte signature + Constructor abi.Method // Contract constructor for deploy parametrization + Calls map[string]*tmplMethod // Contract calls that only read state data + Transacts map[string]*tmplMethod // Contract calls that write state data + Fallback *tmplMethod // Additional special fallback function + Receive *tmplMethod // Additional special receive function + Events map[string]*tmplEvent // Contract events accessors + Libraries map[string]string // Same as tmplData, but filtered to only keep direct deps that the contract needs + Library bool // Indicator whether the contract is a library } type tmplContractV2 struct { @@ -55,7 +53,7 @@ type tmplContractV2 struct { Constructor abi.Method // Contract constructor for deploy parametrization Calls map[string]*tmplMethod // All contract methods (excluding fallback, receive) Events map[string]*tmplEvent // Contract events accessors - Libraries map[string]string // all direct/indirect library dependencies + Libraries map[string]string // all direct library dependencies Errors map[string]*tmplError // all errors defined } From b5862dfb7c043919e735add0926a42734744c9ba Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Fri, 20 Dec 2024 17:57:36 +0700 Subject: [PATCH 096/104] wip --- accounts/abi/bind/bindv2.go | 17 +- accounts/abi/bind/bindv2_test.go | 372 +++++++++++++++--- .../internal/{ => contracts}/db/bindings.go | 0 .../{ => contracts}/db/combined-abi.json | 0 .../internal/{ => contracts}/db/contract.sol | 0 .../{ => contracts}/events/bindings.go | 0 .../{ => contracts}/events/combined-abi.json | 0 .../{ => contracts}/events/contract.sol | 0 .../{ => contracts}/nested_libraries/abi.json | 0 .../nested_libraries/bindings.go | 0 .../nested_libraries/combined-abi.json | 0 .../nested_libraries/contract.sol | 0 .../{ => contracts}/solc_errors/bindings.go | 0 .../solc_errors/combined-abi.json | 0 .../{ => contracts}/solc_errors/contract.sol | 0 accounts/abi/bind/v2/lib_test.go | 8 +- 16 files changed, 331 insertions(+), 66 deletions(-) rename accounts/abi/bind/v2/internal/{ => contracts}/db/bindings.go (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/db/combined-abi.json (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/db/contract.sol (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/events/bindings.go (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/events/combined-abi.json (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/events/contract.sol (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/nested_libraries/abi.json (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/nested_libraries/bindings.go (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/nested_libraries/combined-abi.json (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/nested_libraries/contract.sol (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/solc_errors/bindings.go (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/solc_errors/combined-abi.json (100%) rename accounts/abi/bind/v2/internal/{ => contracts}/solc_errors/contract.sol (100%) diff --git a/accounts/abi/bind/bindv2.go b/accounts/abi/bind/bindv2.go index 66f4391f7816..e0693a0741d3 100644 --- a/accounts/abi/bind/bindv2.go +++ b/accounts/abi/bind/bindv2.go @@ -134,11 +134,9 @@ func (cb *contractBinder) bindMethod(original abi.Method) error { return nil } -// normalizeErrorOrEventFields normalizes errors/events for emitting through bindings: -// Any anonymous fields are given generated names. -func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Arguments) abi.Arguments { - normalizedArguments := make([]abi.Argument, len(originalInputs)) - copy(normalizedArguments, originalInputs) +func normalizeArgs(inp abi.Arguments) abi.Arguments { + normalizedArguments := make([]abi.Argument, len(inp)) + copy(normalizedArguments, inp) used := make(map[string]bool) for i, input := range normalizedArguments { @@ -152,6 +150,15 @@ func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Argumen } normalizedArguments[i].Name = fmt.Sprintf("%s%d", normalizedArguments[i].Name, index) } + } + return normalizedArguments +} + +// normalizeErrorOrEventFields normalizes errors/events for emitting through bindings: +// Any anonymous fields are given generated names. +func (cb *contractBinder) normalizeErrorOrEventFields(originalInputs abi.Arguments) abi.Arguments { + normalizedArguments := normalizeArgs(originalInputs) + for _, input := range normalizedArguments { if hasStruct(input.Type) { cb.binder.BindStructType(input.Type) } diff --git a/accounts/abi/bind/bindv2_test.go b/accounts/abi/bind/bindv2_test.go index 502c57988a77..b8867e0ff24e 100644 --- a/accounts/abi/bind/bindv2_test.go +++ b/accounts/abi/bind/bindv2_test.go @@ -1,10 +1,11 @@ package bind import ( + _ "embed" "fmt" - "testing" - + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/crypto" + "testing" ) type bindV2Test struct { @@ -12,6 +13,7 @@ type bindV2Test struct { abis []string bytecodes []string types []string + aliases map[string]string expectedBindings string } @@ -38,7 +40,10 @@ func bind(test *bindV2Test) (bound string, err error) { libPattern := crypto.Keccak256Hash([]byte(typeName)).String()[2:36] // the first 2 chars are 0x libs[libPattern] = typeName } - code, err := BindV2(types, abis, bins, "bindv2test", libs, make(map[string]string)) + if test.aliases == nil { + test.aliases = make(map[string]string) + } + code, err := BindV2(types, abis, bins, "bindv2test", libs, test.aliases) if err != nil { return "", fmt.Errorf("error creating bindings: %v", err) } @@ -46,79 +51,330 @@ func bind(test *bindV2Test) (bound string, err error) { return code, nil } +//go:embed v2/internal/convertedv1bindtests/empty.go +var v1TestBindingEmpty string + +//go:embed v2/internal/convertedv1bindtests/token.go +var v1TestBindingToken string + +//go:embed v2/internal/convertedv1bindtests/crowdsale.go +var v1TestBindingCrowdsale string + +//go:embed v2/internal/convertedv1bindtests/dao.go +var v1TestBindingDAO string + +//go:embed v2/internal/convertedv1bindtests/inputchecker.go +var v1TestBindingInputChecker string + +//go:embed v2/internal/convertedv1bindtests/outputchecker.go +var v1TestBindingOutputChecker string + +//go:embed v2/internal/convertedv1bindtests/eventchecker.go +var v1TestBindingEventChecker string + +//go:embed v2/internal/convertedv1bindtests/interactor.go +var v1TestBindingInteractor string + +//go:embed v2/internal/convertedv1bindtests/getter.go +var v1TestBindingGetter string + +//go:embed v2/internal/convertedv1bindtests/tupler.go +var v1TestBindingTupler string + +//go:embed v2/internal/convertedv1bindtests/slicer.go +var v1TestBindingSlicer string + +//go:embed v2/internal/convertedv1bindtests/structs.go +var v1TestBindingStructs string + +//go:embed v2/internal/convertedv1bindtests/underscorer.go +var v1TestBindingUnderscorer string + +//go:embed v2/internal/convertedv1bindtests/deeplynestedarray.go +var v1TestBindingDeeplyNestedArray string + +//go:embed v2/internal/convertedv1bindtests/callbackparam.go +var v1TestBindingCallbackParam string + +//go:embed v2/internal/convertedv1bindtests/tuple.go +var v1TestBindingTuple string + +//go:embed v2/internal/convertedv1bindtests/overload.go +var v1TestBindingOverload string + +//go:embed v2/internal/convertedv1bindtests/identifiercollision.go +var v1TestBindingIdentifierCollision string + +//go:embed v2/internal/convertedv1bindtests/nameconflict.go +var v1TestBindingNameConflict string + +//go:embed v2/internal/convertedv1bindtests/rangekeyword.go +var v1TestBindingRangeKeyword string + +//go:embed v2/internal/convertedv1bindtests/numericmethodname.go +var v1TestBindingNumericMethodName string + var bindTests2 = []bindV2Test{ { "Empty", []string{`[]`}, []string{`606060405260068060106000396000f3606060405200`}, nil, - `// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package bindv2test - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) -`, + nil, + v1TestBindingEmpty, }, { "Token", []string{`[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"success","type":"bool"}],"type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"},{"name":"_extraData","type":"bytes"}],"name":"approveAndCall","outputs":[{"name":"success","type":"bool"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"spentAllowance","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"inputs":[{"name":"initialSupply","type":"uint256"},{"name":"tokenName","type":"string"},{"name":"decimalUnits","type":"uint8"},{"name":"tokenSymbol","type":"string"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Transfer","type":"event"}]`}, []string{`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`}, nil, - `// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package bindv2test - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) -`, + nil, + v1TestBindingToken, + }, + { + "Crowdsale", + []string{`[{"constant":false,"inputs":[],"name":"checkGoalReached","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"deadline","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"beneficiary","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[],"name":"tokenReward","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[],"name":"fundingGoal","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"amountRaised","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"price","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"funders","outputs":[{"name":"addr","type":"address"},{"name":"amount","type":"uint256"}],"type":"function"},{"inputs":[{"name":"ifSuccessfulSendTo","type":"address"},{"name":"fundingGoalInEthers","type":"uint256"},{"name":"durationInMinutes","type":"uint256"},{"name":"etherCostOfEachToken","type":"uint256"},{"name":"addressOfTokenUsedAsReward","type":"address"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"backer","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"isContribution","type":"bool"}],"name":"FundTransfer","type":"event"}]`}, + []string{`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`}, + nil, + nil, + v1TestBindingCrowdsale, + }, + { + "DAO", + []string{`[{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"proposals","outputs":[{"name":"recipient","type":"address"},{"name":"amount","type":"uint256"},{"name":"description","type":"string"},{"name":"votingDeadline","type":"uint256"},{"name":"executed","type":"bool"},{"name":"proposalPassed","type":"bool"},{"name":"numberOfVotes","type":"uint256"},{"name":"currentResult","type":"int256"},{"name":"proposalHash","type":"bytes32"}],"type":"function"},{"constant":false,"inputs":[{"name":"proposalNumber","type":"uint256"},{"name":"transactionBytecode","type":"bytes"}],"name":"executeProposal","outputs":[{"name":"result","type":"int256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"memberId","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"numProposals","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"members","outputs":[{"name":"member","type":"address"},{"name":"canVote","type":"bool"},{"name":"name","type":"string"},{"name":"memberSince","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"debatingPeriodInMinutes","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"minimumQuorum","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"targetMember","type":"address"},{"name":"canVote","type":"bool"},{"name":"memberName","type":"string"}],"name":"changeMembership","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"majorityMargin","outputs":[{"name":"","type":"int256"}],"type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"},{"name":"etherAmount","type":"uint256"},{"name":"JobDescription","type":"string"},{"name":"transactionBytecode","type":"bytes"}],"name":"newProposal","outputs":[{"name":"proposalID","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[{"name":"minimumQuorumForProposals","type":"uint256"},{"name":"minutesForDebate","type":"uint256"},{"name":"marginOfVotesForMajority","type":"int256"}],"name":"changeVotingRules","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"proposalNumber","type":"uint256"},{"name":"supportsProposal","type":"bool"},{"name":"justificationText","type":"string"}],"name":"vote","outputs":[{"name":"voteID","type":"uint256"}],"type":"function"},{"constant":true,"inputs":[{"name":"proposalNumber","type":"uint256"},{"name":"beneficiary","type":"address"},{"name":"etherAmount","type":"uint256"},{"name":"transactionBytecode","type":"bytes"}],"name":"checkProposalCode","outputs":[{"name":"codeChecksOut","type":"bool"}],"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"type":"function"},{"inputs":[{"name":"minimumQuorumForProposals","type":"uint256"},{"name":"minutesForDebate","type":"uint256"},{"name":"marginOfVotesForMajority","type":"int256"},{"name":"congressLeader","type":"address"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"proposalID","type":"uint256"},{"indexed":false,"name":"recipient","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"description","type":"string"}],"name":"ProposalAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"proposalID","type":"uint256"},{"indexed":false,"name":"position","type":"bool"},{"indexed":false,"name":"voter","type":"address"},{"indexed":false,"name":"justification","type":"string"}],"name":"Voted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"proposalID","type":"uint256"},{"indexed":false,"name":"result","type":"int256"},{"indexed":false,"name":"quorum","type":"uint256"},{"indexed":false,"name":"active","type":"bool"}],"name":"ProposalTallied","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"member","type":"address"},{"indexed":false,"name":"isMember","type":"bool"}],"name":"MembershipChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"minimumQuorum","type":"uint256"},{"indexed":false,"name":"debatingPeriodInMinutes","type":"uint256"},{"indexed":false,"name":"majorityMargin","type":"int256"}],"name":"ChangeOfRules","type":"event"}]`}, + []string{`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`}, + nil, + nil, + v1TestBindingDAO, + }, + { + "InputChecker", + []string{` + [ + {"type":"function","name":"noInput","constant":true,"inputs":[],"outputs":[]}, + {"type":"function","name":"namedInput","constant":true,"inputs":[{"name":"str","type":"string"}],"outputs":[]}, + {"type":"function","name":"anonInput","constant":true,"inputs":[{"name":"","type":"string"}],"outputs":[]}, + {"type":"function","name":"namedInputs","constant":true,"inputs":[{"name":"str1","type":"string"},{"name":"str2","type":"string"}],"outputs":[]}, + {"type":"function","name":"anonInputs","constant":true,"inputs":[{"name":"","type":"string"},{"name":"","type":"string"}],"outputs":[]}, + {"type":"function","name":"mixedInputs","constant":true,"inputs":[{"name":"","type":"string"},{"name":"str","type":"string"}],"outputs":[]} + ] + `}, + []string{``}, + nil, + nil, + v1TestBindingInputChecker, + }, + { + "OutputChecker", + []string{` + [ + {"type":"function","name":"noOutput","constant":true,"inputs":[],"outputs":[]}, + {"type":"function","name":"namedOutput","constant":true,"inputs":[],"outputs":[{"name":"str","type":"string"}]}, + {"type":"function","name":"anonOutput","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"}]}, + {"type":"function","name":"namedOutputs","constant":true,"inputs":[],"outputs":[{"name":"str1","type":"string"},{"name":"str2","type":"string"}]}, + {"type":"function","name":"collidingOutputs","constant":true,"inputs":[],"outputs":[{"name":"str","type":"string"},{"name":"Str","type":"string"}]}, + {"type":"function","name":"anonOutputs","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"},{"name":"","type":"string"}]}, + {"type":"function","name":"mixedOutputs","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"},{"name":"str","type":"string"}]} + ] + `}, + []string{``}, + nil, + nil, + v1TestBindingOutputChecker, + }, + { + "EventChecker", + []string{` + [ + {"type":"event","name":"empty","inputs":[]}, + {"type":"event","name":"indexed","inputs":[{"name":"addr","type":"address","indexed":true},{"name":"num","type":"int256","indexed":true}]}, + {"type":"event","name":"mixed","inputs":[{"name":"addr","type":"address","indexed":true},{"name":"num","type":"int256"}]}, + {"type":"event","name":"anonymous","anonymous":true,"inputs":[]}, + {"type":"event","name":"dynamic","inputs":[{"name":"idxStr","type":"string","indexed":true},{"name":"idxDat","type":"bytes","indexed":true},{"name":"str","type":"string"},{"name":"dat","type":"bytes"}]}, + {"type":"event","name":"unnamed","inputs":[{"name":"","type":"uint256","indexed": true},{"name":"","type":"uint256","indexed":true}]} + ] + `}, + []string{``}, + nil, + nil, + v1TestBindingEventChecker, + }, + { + "Interactor", + []string{`[{"constant":true,"inputs":[],"name":"transactString","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":true,"inputs":[],"name":"deployString","outputs":[{"name":"","type":"string"}],"type":"function"},{"constant":false,"inputs":[{"name":"str","type":"string"}],"name":"transact","outputs":[],"type":"function"},{"inputs":[{"name":"str","type":"string"}],"type":"constructor"}]`}, + []string{`6060604052604051610328380380610328833981016040528051018060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10608d57805160ff19168380011785555b50607c9291505b8082111560ba57838155600101606b565b50505061026a806100be6000396000f35b828001600101855582156064579182015b828111156064578251826000505591602001919060010190609e565b509056606060405260e060020a60003504630d86a0e181146100315780636874e8091461008d578063d736c513146100ea575b005b610190600180546020600282841615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b61019060008054602060026001831615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b60206004803580820135601f81018490049093026080908101604052606084815261002f946024939192918401918190838280828437509496505050505050508060016000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061023157805160ff19168380011785555b506102619291505b808211156102665760008155830161017d565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101f05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b820191906000526020600020905b81548152906001019060200180831161020c57829003601f168201915b505050505081565b82800160010185558215610175579182015b82811115610175578251826000505591602001919060010190610243565b505050565b509056`}, + nil, + nil, + v1TestBindingInteractor, + }, + { + "Getter", + []string{`[{"constant":true,"inputs":[],"name":"getter","outputs":[{"name":"","type":"string"},{"name":"","type":"int256"},{"name":"","type":"bytes32"}],"type":"function"}]`}, + []string{`606060405260dc8060106000396000f3606060405260e060020a6000350463993a04b78114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3`}, + nil, + nil, + v1TestBindingGetter, + }, + { + "Tupler", + []string{`[{"constant":true,"inputs":[],"name":"tuple","outputs":[{"name":"a","type":"string"},{"name":"b","type":"int256"},{"name":"c","type":"bytes32"}],"type":"function"}]`}, + []string{`606060405260dc8060106000396000f3606060405260e060020a60003504633175aae28114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3`}, + nil, + nil, + v1TestBindingTupler, + }, + { + "Slicer", + []string{`[{"constant":true,"inputs":[{"name":"input","type":"address[]"}],"name":"echoAddresses","outputs":[{"name":"output","type":"address[]"}],"type":"function"},{"constant":true,"inputs":[{"name":"input","type":"uint24[23]"}],"name":"echoFancyInts","outputs":[{"name":"output","type":"uint24[23]"}],"type":"function"},{"constant":true,"inputs":[{"name":"input","type":"int256[]"}],"name":"echoInts","outputs":[{"name":"output","type":"int256[]"}],"type":"function"},{"constant":true,"inputs":[{"name":"input","type":"bool[]"}],"name":"echoBools","outputs":[{"name":"output","type":"bool[]"}],"type":"function"}]`}, + []string{`606060405261015c806100126000396000f3606060405260e060020a6000350463be1127a3811461003c578063d88becc014610092578063e15a3db71461003c578063f637e5891461003c575b005b604080516020600480358082013583810285810185019096528085526100ee959294602494909392850192829185019084908082843750949650505050505050604080516020810190915260009052805b919050565b604080516102e0818101909252610138916004916102e491839060179083908390808284375090955050505050506102e0604051908101604052806017905b60008152602001906001900390816100d15790505081905061008d565b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600f02600301f1509050019250505060405180910390f35b60405180826102e0808381846000600461015cf15090500191505060405180910390f3`}, + nil, + nil, + v1TestBindingSlicer, + }, + { + "Structs", + []string{`[{"inputs":[],"name":"F","outputs":[{"components":[{"internalType":"bytes32","name":"B","type":"bytes32"}],"internalType":"structStructs.A[]","name":"a","type":"tuple[]"},{"internalType":"uint256[]","name":"c","type":"uint256[]"},{"internalType":"bool[]","name":"d","type":"bool[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"G","outputs":[{"components":[{"internalType":"bytes32","name":"B","type":"bytes32"}],"internalType":"structStructs.A[]","name":"a","type":"tuple[]"}],"stateMutability":"view","type":"function"}]`}, + []string{`608060405234801561001057600080fd5b50610278806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806328811f591461003b5780636fecb6231461005b575b600080fd5b610043610070565b604051610052939291906101a0565b60405180910390f35b6100636100d6565b6040516100529190610186565b604080516002808252606082810190935282918291829190816020015b610095610131565b81526020019060019003908161008d575050805190915061026960611b9082906000906100be57fe5b60209081029190910101515293606093508392509050565b6040805160028082526060828101909352829190816020015b6100f7610131565b8152602001906001900390816100ef575050805190915061026960611b90829060009061012057fe5b602090810291909101015152905090565b60408051602081019091526000815290565b815260200190565b6000815180845260208085019450808401835b8381101561017b578151518752958201959082019060010161015e565b509495945050505050565b600060208252610199602083018461014b565b9392505050565b6000606082526101b3606083018661014b565b6020838203818501528186516101c98185610239565b91508288019350845b818110156101f3576101e5838651610143565b9484019492506001016101d2565b505084810360408601528551808252908201925081860190845b8181101561022b57825115158552938301939183019160010161020d565b509298975050505050505050565b9081526020019056fea2646970667358221220eb85327e285def14230424c52893aebecec1e387a50bb6b75fc4fdbed647f45f64736f6c63430006050033`}, + nil, + nil, + v1TestBindingStructs, + }, + { + `Underscorer`, + []string{`[{"constant":true,"inputs":[],"name":"LowerUpperCollision","outputs":[{"name":"_res","type":"int256"},{"name":"Res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_under_scored_func","outputs":[{"name":"_int","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UnderscoredOutput","outputs":[{"name":"_int","type":"int256"},{"name":"_string","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"PurelyUnderscoredOutput","outputs":[{"name":"_","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UpperLowerCollision","outputs":[{"name":"_Res","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"AllPurelyUnderscoredOutput","outputs":[{"name":"_","type":"int256"},{"name":"__","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UpperUpperCollision","outputs":[{"name":"_Res","type":"int256"},{"name":"Res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"LowerLowerCollision","outputs":[{"name":"_res","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"}]`}, []string{`6060604052341561000f57600080fd5b6103858061001e6000396000f30060606040526004361061008e576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806303a592131461009357806346546dbe146100c357806367e6633d146100ec5780639df4848514610181578063af7486ab146101b1578063b564b34d146101e1578063e02ab24d14610211578063e409ca4514610241575b600080fd5b341561009e57600080fd5b6100a6610271565b604051808381526020018281526020019250505060405180910390f35b34156100ce57600080fd5b6100d6610286565b6040518082815260200191505060405180910390f35b34156100f757600080fd5b6100ff61028e565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561014557808201518184015260208101905061012a565b50505050905090810190601f1680156101725780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561018c57600080fd5b6101946102dc565b604051808381526020018281526020019250505060405180910390f35b34156101bc57600080fd5b6101c46102f1565b604051808381526020018281526020019250505060405180910390f35b34156101ec57600080fd5b6101f4610306565b604051808381526020018281526020019250505060405180910390f35b341561021c57600080fd5b61022461031b565b604051808381526020018281526020019250505060405180910390f35b341561024c57600080fd5b610254610330565b604051808381526020018281526020019250505060405180910390f35b60008060016002819150809050915091509091565b600080905090565b6000610298610345565b61013a8090506040805190810160405280600281526020017f7069000000000000000000000000000000000000000000000000000000000000815250915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b6020604051908101604052806000815250905600a165627a7a72305820d1a53d9de9d1e3d55cb3dc591900b63c4f1ded79114f7b79b332684840e186a40029`}, + nil, + nil, + v1TestBindingUnderscorer, + }, + { + `DeeplyNestedArray`, + []string{`[{"constant":false,"inputs":[{"name":"arr","type":"uint64[3][4][5]"}],"name":"storeDeepUintArray","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"retrieveDeepArray","outputs":[{"name":"","type":"uint64[3][4][5]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"name":"deepUint64Array","outputs":[{"name":"","type":"uint64"}],"payable":false,"stateMutability":"view","type":"function"}]`}, + []string{`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`}, + nil, + nil, + v1TestBindingDeeplyNestedArray, + }, + { + `CallbackParam`, + []string{`[ + { + "constant": false, + "inputs": [ + { + "name": "callback", + "type": "function" + } + ], + "name": "test", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + } + ]`}, + []string{`608060405234801561001057600080fd5b5061015e806100206000396000f3fe60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063d7a5aba214610040575b600080fd5b34801561004c57600080fd5b506100be6004803603602081101561006357600080fd5b810190808035806c0100000000000000000000000090049068010000000000000000900463ffffffff1677ffffffffffffffffffffffffffffffffffffffffffffffff169091602001919093929190939291905050506100c0565b005b818160016040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15801561011657600080fd5b505af115801561012a573d6000803e3d6000fd5b50505050505056fea165627a7a7230582062f87455ff84be90896dbb0c4e4ddb505c600d23089f8e80a512548440d7e2580029`}, + nil, + nil, + v1TestBindingCallbackParam, + }, + { + `Tuple`, + []string{` +[{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"indexed":false,"internalType":"struct Tuple.S","name":"a","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"indexed":false,"internalType":"struct Tuple.T[2][]","name":"b","type":"tuple[2][]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"indexed":false,"internalType":"struct Tuple.T[][2]","name":"c","type":"tuple[][2]"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"indexed":false,"internalType":"struct Tuple.S[]","name":"d","type":"tuple[]"},{"indexed":false,"internalType":"uint256[]","name":"e","type":"uint256[]"}],"name":"TupleEvent","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint8","name":"x","type":"uint8"},{"internalType":"uint8","name":"y","type":"uint8"}],"indexed":false,"internalType":"struct Tuple.P[]","name":"","type":"tuple[]"}],"name":"TupleEvent2","type":"event"},{"constant":true,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S","name":"a","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[2][]","name":"b","type":"tuple[2][]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[][2]","name":"c","type":"tuple[][2]"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S[]","name":"d","type":"tuple[]"},{"internalType":"uint256[]","name":"e","type":"uint256[]"}],"name":"func1","outputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S","name":"","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[2][]","name":"","type":"tuple[2][]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[][2]","name":"","type":"tuple[][2]"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S[]","name":"","type":"tuple[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":false,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S","name":"a","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[2][]","name":"b","type":"tuple[2][]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[][2]","name":"c","type":"tuple[][2]"},{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256[]","name":"b","type":"uint256[]"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct Tuple.T[]","name":"c","type":"tuple[]"}],"internalType":"struct Tuple.S[]","name":"d","type":"tuple[]"},{"internalType":"uint256[]","name":"e","type":"uint256[]"}],"name":"func2","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"components":[{"internalType":"uint16","name":"x","type":"uint16"},{"internalType":"uint16","name":"y","type":"uint16"}],"internalType":"struct Tuple.Q[]","name":"","type":"tuple[]"}],"name":"func3","outputs":[],"payable":false,"stateMutability":"pure","type":"function"}]`}, + []string{`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`}, + nil, + nil, + v1TestBindingTuple, + }, + { + "Overload", + []string{`[{"constant":false,"inputs":[{"name":"i","type":"uint256"},{"name":"j","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"i","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"}],"name":"bar","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"},{"indexed":false,"name":"j","type":"uint256"}],"name":"bar","type":"event"}]`}, + []string{`608060405234801561001057600080fd5b50610153806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806304bc52f81461003b5780632fbebd3814610073575b600080fd5b6100716004803603604081101561005157600080fd5b8101908080359060200190929190803590602001909291905050506100a1565b005b61009f6004803603602081101561008957600080fd5b81019080803590602001909291905050506100e4565b005b7fae42e9514233792a47a1e4554624e83fe852228e1503f63cd383e8a431f4f46d8282604051808381526020018281526020019250505060405180910390a15050565b7f0423a1321222a0a8716c22b92fac42d85a45a612b696a461784d9fa537c81e5c816040518082815260200191505060405180910390a15056fea265627a7a72305820e22b049858b33291cbe67eeaece0c5f64333e439d27032ea8337d08b1de18fe864736f6c634300050a0032`}, + nil, + nil, + v1TestBindingOverload, + }, + { + "IdentifierCollision", + []string{`[{"constant":true,"inputs":[],"name":"MyVar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_myVar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]`}, + []string{"60806040523480156100115760006000fd5b50610017565b60c3806100256000396000f3fe608060405234801560105760006000fd5b506004361060365760003560e01c806301ad4d8714603c5780634ef1f0ad146058576036565b60006000fd5b60426074565b6040518082815260200191505060405180910390f35b605e607d565b6040518082815260200191505060405180910390f35b60006000505481565b60006000600050549050608b565b9056fea265627a7a7231582067c8d84688b01c4754ba40a2a871cede94ea1f28b5981593ab2a45b46ac43af664736f6c634300050c0032"}, + nil, + map[string]string{"_myVar": "pubVar"}, // alias MyVar to PubVar,\ + v1TestBindingIdentifierCollision, + }, + { + "NameConflict", + []string{`[ { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "int256", "name": "msg", "type": "int256" }, { "indexed": false, "internalType": "int256", "name": "_msg", "type": "int256" } ], "name": "log", "type": "event" }, { "inputs": [ { "components": [ { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "_data", "type": "bytes" } ], "internalType": "struct oracle.request", "name": "req", "type": "tuple" } ], "name": "addRequest", "outputs": [], "stateMutability": "pure", "type": "function" }, { "inputs": [], "name": "getRequest", "outputs": [ { "components": [ { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "_data", "type": "bytes" } ], "internalType": "struct oracle.request", "name": "", "type": "tuple" } ], "stateMutability": "pure", "type": "function" } ]`}, + []string{"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"}, + nil, + nil, + v1TestBindingNameConflict, + }, + { + "RangeKeyword", + []string{`[{"inputs":[{"internalType":"uint256","name":"range","type":"uint256"}],"name":"functionWithKeywordParameter","outputs":[],"stateMutability":"pure","type":"function"}]`}, + []string{"0x608060405234801561001057600080fd5b5060dc8061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063527a119f14602d575b600080fd5b60436004803603810190603f9190605b565b6045565b005b50565b6000813590506055816092565b92915050565b600060208284031215606e57606d608d565b5b6000607a848285016048565b91505092915050565b6000819050919050565b600080fd5b6099816083565b811460a357600080fd5b5056fea2646970667358221220d4f4525e2615516394055d369fb17df41c359e5e962734f27fd683ea81fd9db164736f6c63430008070033"}, + nil, + nil, + v1TestBindingRangeKeyword, + }, + { + "NumericMethodName", + []string{`[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_param","type":"address"}],"name":"_1TestEvent","type":"event"},{"inputs":[],"name":"_1test","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"__1test","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"__2test","outputs":[],"stateMutability":"pure","type":"function"}]`}, + []string{"0x6080604052348015600f57600080fd5b5060958061001e6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80639d993132146041578063d02767c7146049578063ffa02795146051575b600080fd5b60476059565b005b604f605b565b005b6057605d565b005b565b565b56fea26469706673582212200382ca602dff96a7e2ba54657985e2b4ac423a56abe4a1f0667bc635c4d4371f64736f6c63430008110033"}, + nil, + nil, + v1TestBindingNumericMethodName, }, } func TestBindingV2(t *testing.T) { for _, tc := range bindTests2 { - code, err := bind(&tc) - if err != nil { - t.Fatalf("got error from bind: %v", err) + t.Run(tc.name, func(t *testing.T) { + if tc.types == nil { + tc.types = []string{tc.name} + } + + code, err := bind(&tc) + if err != nil { + t.Fatalf("got error from bind: %v", err) + } + /* + if err := os.WriteFile(fmt.Sprintf("expected-output/%s.go", strings.ToLower(tc.name)), []byte(code), 0666); err != nil { + t.Fatalf("err writing expected output to file: %v\n", err) + } + fmt.Printf("//go:embed v2/internal/convertedv1bindtests/%s.go\n", strings.ToLower(tc.name)) + fmt.Printf("var v1TestBinding%s string\n", tc.name) + fmt.Println() + */ + if code != tc.expectedBindings { + t.Fatalf("name mismatch for %s", tc.name) + //t.Fatalf("'%s'\n!=\n'%s'\n", code, tc.expectedBindings) + } + }) + } +} + +func TestNormalizeArgs(t *testing.T) { + type normalizeArgsTc struct { + inp []string + expected []string + } + for _, tc := range []normalizeArgsTc{ + {[]string{"arg1", "Arg1"}, []string{"Arg1", "Arg1"}}} { + var inpArgs abi.Arguments + for _, inpArgName := range tc.inp { + inpArgs = append(inpArgs, abi.Argument{ + Name: inpArgName, + }) } - if code != tc.expectedBindings { - t.Fatalf("'%s'\n!=\n'%s'\n", code, tc.expectedBindings) + res := normalizeArgs(inpArgs) + for i, resArg := range res { + if resArg.Name != tc.expected[i] { + fmt.Println(resArg.Name) + fmt.Println(tc.expected[i]) + t.Fatalf("mismatch!!!") + } } } } diff --git a/accounts/abi/bind/v2/internal/db/bindings.go b/accounts/abi/bind/v2/internal/contracts/db/bindings.go similarity index 100% rename from accounts/abi/bind/v2/internal/db/bindings.go rename to accounts/abi/bind/v2/internal/contracts/db/bindings.go diff --git a/accounts/abi/bind/v2/internal/db/combined-abi.json b/accounts/abi/bind/v2/internal/contracts/db/combined-abi.json similarity index 100% rename from accounts/abi/bind/v2/internal/db/combined-abi.json rename to accounts/abi/bind/v2/internal/contracts/db/combined-abi.json diff --git a/accounts/abi/bind/v2/internal/db/contract.sol b/accounts/abi/bind/v2/internal/contracts/db/contract.sol similarity index 100% rename from accounts/abi/bind/v2/internal/db/contract.sol rename to accounts/abi/bind/v2/internal/contracts/db/contract.sol diff --git a/accounts/abi/bind/v2/internal/events/bindings.go b/accounts/abi/bind/v2/internal/contracts/events/bindings.go similarity index 100% rename from accounts/abi/bind/v2/internal/events/bindings.go rename to accounts/abi/bind/v2/internal/contracts/events/bindings.go diff --git a/accounts/abi/bind/v2/internal/events/combined-abi.json b/accounts/abi/bind/v2/internal/contracts/events/combined-abi.json similarity index 100% rename from accounts/abi/bind/v2/internal/events/combined-abi.json rename to accounts/abi/bind/v2/internal/contracts/events/combined-abi.json diff --git a/accounts/abi/bind/v2/internal/events/contract.sol b/accounts/abi/bind/v2/internal/contracts/events/contract.sol similarity index 100% rename from accounts/abi/bind/v2/internal/events/contract.sol rename to accounts/abi/bind/v2/internal/contracts/events/contract.sol diff --git a/accounts/abi/bind/v2/internal/nested_libraries/abi.json b/accounts/abi/bind/v2/internal/contracts/nested_libraries/abi.json similarity index 100% rename from accounts/abi/bind/v2/internal/nested_libraries/abi.json rename to accounts/abi/bind/v2/internal/contracts/nested_libraries/abi.json diff --git a/accounts/abi/bind/v2/internal/nested_libraries/bindings.go b/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go similarity index 100% rename from accounts/abi/bind/v2/internal/nested_libraries/bindings.go rename to accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go diff --git a/accounts/abi/bind/v2/internal/nested_libraries/combined-abi.json b/accounts/abi/bind/v2/internal/contracts/nested_libraries/combined-abi.json similarity index 100% rename from accounts/abi/bind/v2/internal/nested_libraries/combined-abi.json rename to accounts/abi/bind/v2/internal/contracts/nested_libraries/combined-abi.json diff --git a/accounts/abi/bind/v2/internal/nested_libraries/contract.sol b/accounts/abi/bind/v2/internal/contracts/nested_libraries/contract.sol similarity index 100% rename from accounts/abi/bind/v2/internal/nested_libraries/contract.sol rename to accounts/abi/bind/v2/internal/contracts/nested_libraries/contract.sol diff --git a/accounts/abi/bind/v2/internal/solc_errors/bindings.go b/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go similarity index 100% rename from accounts/abi/bind/v2/internal/solc_errors/bindings.go rename to accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go diff --git a/accounts/abi/bind/v2/internal/solc_errors/combined-abi.json b/accounts/abi/bind/v2/internal/contracts/solc_errors/combined-abi.json similarity index 100% rename from accounts/abi/bind/v2/internal/solc_errors/combined-abi.json rename to accounts/abi/bind/v2/internal/contracts/solc_errors/combined-abi.json diff --git a/accounts/abi/bind/v2/internal/solc_errors/contract.sol b/accounts/abi/bind/v2/internal/contracts/solc_errors/contract.sol similarity index 100% rename from accounts/abi/bind/v2/internal/solc_errors/contract.sol rename to accounts/abi/bind/v2/internal/contracts/solc_errors/contract.sol diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index ba8c210baf32..6c67bc932c62 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -19,6 +19,9 @@ package v2 import ( "context" "encoding/json" + "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/contracts/events" + "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/contracts/nested_libraries" + "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/contracts/solc_errors" "io" "math/big" "os" @@ -30,9 +33,6 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind/backends" - "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/events" - "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/nested_libraries" - "github.com/ethereum/go-ethereum/accounts/abi/bind/v2/internal/solc_errors" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/compiler" @@ -474,3 +474,5 @@ func TestBindingGeneration(t *testing.T) { } } } + +// contract test ideas (from the v1 bind tests): error that takes struct argument. constructor that takes struct arg. From 7a9259e14812df8db220ebf45adcbc09b75b6e6f Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 23 Dec 2024 15:36:42 +0700 Subject: [PATCH 097/104] fix events/error args normalization capitalization. add unit test that fails before the fix, and also also a few more test cases for args normalization. --- accounts/abi/bind/bindv2.go | 5 +++-- accounts/abi/bind/bindv2_test.go | 14 +++++++------- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/accounts/abi/bind/bindv2.go b/accounts/abi/bind/bindv2.go index e0693a0741d3..2b4816694455 100644 --- a/accounts/abi/bind/bindv2.go +++ b/accounts/abi/bind/bindv2.go @@ -143,9 +143,10 @@ func normalizeArgs(inp abi.Arguments) abi.Arguments { if input.Name == "" || isKeyWord(input.Name) { normalizedArguments[i].Name = fmt.Sprintf("arg%d", i) } + normalizedArguments[i].Name = capitalise(normalizedArguments[i].Name) for index := 0; ; index++ { - if !used[capitalise(normalizedArguments[i].Name)] { - used[capitalise(normalizedArguments[i].Name)] = true + if !used[normalizedArguments[i].Name] { + used[normalizedArguments[i].Name] = true break } normalizedArguments[i].Name = fmt.Sprintf("%s%d", normalizedArguments[i].Name, index) diff --git a/accounts/abi/bind/bindv2_test.go b/accounts/abi/bind/bindv2_test.go index b8867e0ff24e..16740d6e6043 100644 --- a/accounts/abi/bind/bindv2_test.go +++ b/accounts/abi/bind/bindv2_test.go @@ -360,8 +360,10 @@ func TestNormalizeArgs(t *testing.T) { inp []string expected []string } - for _, tc := range []normalizeArgsTc{ - {[]string{"arg1", "Arg1"}, []string{"Arg1", "Arg1"}}} { + for i, tc := range []normalizeArgsTc{ + {[]string{"arg1", "Arg1"}, []string{"Arg1", "Arg10"}}, + {[]string{"", ""}, []string{"Arg0", "Arg1"}}, + {[]string{"var", "const"}, []string{"Arg0", "Arg1"}}} { var inpArgs abi.Arguments for _, inpArgName := range tc.inp { inpArgs = append(inpArgs, abi.Argument{ @@ -369,11 +371,9 @@ func TestNormalizeArgs(t *testing.T) { }) } res := normalizeArgs(inpArgs) - for i, resArg := range res { - if resArg.Name != tc.expected[i] { - fmt.Println(resArg.Name) - fmt.Println(tc.expected[i]) - t.Fatalf("mismatch!!!") + for j, resArg := range res { + if resArg.Name != tc.expected[j] { + t.Fatalf("mismatch for test index %d, arg index %d: expected %v. got %v", i, j, resArg.Name, tc.expected[j]) } } } From 230b3f43d651f245b2d0e8accf42f7e75226fe7a Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 23 Dec 2024 15:43:54 +0700 Subject: [PATCH 098/104] simplify vars naming in normalizeArgs --- accounts/abi/bind/bindv2.go | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/accounts/abi/bind/bindv2.go b/accounts/abi/bind/bindv2.go index 2b4816694455..c33f30ddd134 100644 --- a/accounts/abi/bind/bindv2.go +++ b/accounts/abi/bind/bindv2.go @@ -6,6 +6,7 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi" "go/format" "regexp" + "slices" "strings" "text/template" "unicode" @@ -134,25 +135,24 @@ func (cb *contractBinder) bindMethod(original abi.Method) error { return nil } -func normalizeArgs(inp abi.Arguments) abi.Arguments { - normalizedArguments := make([]abi.Argument, len(inp)) - copy(normalizedArguments, inp) +func normalizeArgs(args abi.Arguments) abi.Arguments { + args = slices.Clone(args) used := make(map[string]bool) - for i, input := range normalizedArguments { + for i, input := range args { if input.Name == "" || isKeyWord(input.Name) { - normalizedArguments[i].Name = fmt.Sprintf("arg%d", i) + args[i].Name = fmt.Sprintf("arg%d", i) } - normalizedArguments[i].Name = capitalise(normalizedArguments[i].Name) + args[i].Name = capitalise(args[i].Name) for index := 0; ; index++ { - if !used[normalizedArguments[i].Name] { - used[normalizedArguments[i].Name] = true + if !used[args[i].Name] { + used[args[i].Name] = true break } - normalizedArguments[i].Name = fmt.Sprintf("%s%d", normalizedArguments[i].Name, index) + args[i].Name = fmt.Sprintf("%s%d", args[i].Name, index) } } - return normalizedArguments + return args } // normalizeErrorOrEventFields normalizes errors/events for emitting through bindings: From c802765f3f41333ee3d7ec05f46302c52043cdc1 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 23 Dec 2024 16:02:05 +0700 Subject: [PATCH 099/104] remove capitalize helper method. simplify call/event/error symbol name registration --- accounts/abi/bind/bind.go | 27 ++++++++++----------------- accounts/abi/bind/bindv2.go | 33 +++++++++------------------------ 2 files changed, 19 insertions(+), 41 deletions(-) diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 252a763fc0a9..020fec750ead 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -125,7 +125,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] for _, original := range evmABI.Methods { // Normalize the method for capital cases and non-anonymous inputs/outputs normalized := original - normalizedName := methodNormalizer(alias(aliases, original.Name)) + normalizedName := abi.ToCamelCase(alias(aliases, original.Name)) // Ensure there is no duplicated identifier var identifiers = callIdentifiers if !original.IsConstant() { @@ -159,7 +159,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] copy(normalized.Outputs, original.Outputs) for j, output := range normalized.Outputs { if output.Name != "" { - normalized.Outputs[j].Name = capitalise(output.Name) + normalized.Outputs[j].Name = abi.ToCamelCase(output.Name) } if hasStruct(output.Type) { bindStructType(output.Type, structs) @@ -181,7 +181,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] normalized := original // Ensure there is no duplicated identifier - normalizedName := methodNormalizer(alias(aliases, original.Name)) + normalizedName := abi.ToCamelCase(alias(aliases, original.Name)) // Name shouldn't start with a digit. It will make the generated code invalid. if len(normalizedName) > 0 && unicode.IsDigit(rune(normalizedName[0])) { normalizedName = fmt.Sprintf("E%s", normalizedName) @@ -206,8 +206,8 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] // Event is a bit special, we need to define event struct in binding, // ensure there is no camel-case-style name conflict. for index := 0; ; index++ { - if !used[capitalise(normalized.Inputs[j].Name)] { - used[capitalise(normalized.Inputs[j].Name)] = true + if !used[abi.ToCamelCase(normalized.Inputs[j].Name)] { + used[abi.ToCamelCase(normalized.Inputs[j].Name)] = true break } normalized.Inputs[j].Name = fmt.Sprintf("%s%d", normalized.Inputs[j].Name, index) @@ -228,7 +228,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] } contracts[types[i]] = &tmplContract{ - Type: capitalise(types[i]), + Type: abi.ToCamelCase(types[i]), InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), Constructor: evmABI.Constructor, @@ -278,7 +278,7 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string] funcs := map[string]interface{}{ "bindtype": bindType, "bindtopictype": bindTopicType, - "capitalise": capitalise, + "capitalise": abi.ToCamelCase, "decapitalise": decapitalise, } tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource)) @@ -371,7 +371,7 @@ func bindStructType(kind abi.Type, structs map[string]*tmplStruct) string { fields []*tmplField ) for i, elem := range kind.TupleElems { - name := capitalise(kind.TupleRawNames[i]) + name := abi.ToCamelCase(kind.TupleRawNames[i]) name = abi.ResolveNameConflict(name, func(s string) bool { return names[s] }) names[name] = true fields = append(fields, &tmplField{Type: bindStructType(*elem, structs), Name: name, SolKind: *elem}) @@ -380,7 +380,7 @@ func bindStructType(kind abi.Type, structs map[string]*tmplStruct) string { if name == "" { name = fmt.Sprintf("Struct%d", len(structs)) } - name = capitalise(name) + name = abi.ToCamelCase(name) structs[id] = &tmplStruct{ Name: name, @@ -405,13 +405,6 @@ func alias(aliases map[string]string, n string) string { return n } -// methodNormalizer is a name transformer that modifies Solidity method names to -// conform to Go naming conventions. -var methodNormalizer = abi.ToCamelCase - -// capitalise makes a camel-case string which starts with an upper case character. -var capitalise = abi.ToCamelCase - // decapitalise makes a camel-case string which starts with a lower case character. func decapitalise(input string) string { if len(input) == 0 { @@ -436,7 +429,7 @@ func structured(args abi.Arguments) bool { } // If the field name is empty when normalized or collides (var, Var, _var, _Var), // we can't organize into a struct - field := capitalise(out.Name) + field := abi.ToCamelCase(out.Name) if field == "" || exists[field] { return false } diff --git a/accounts/abi/bind/bindv2.go b/accounts/abi/bind/bindv2.go index c33f30ddd134..bc458750de87 100644 --- a/accounts/abi/bind/bindv2.go +++ b/accounts/abi/bind/bindv2.go @@ -26,7 +26,7 @@ type binder struct { // registerIdentifier applies alias renaming, name normalization (conversion to camel case), and registers the normalized // name in the specified identifier map. It returns an error if the normalized name already exists in the map. func (b *contractBinder) registerIdentifier(identifiers map[string]bool, original string) (normalized string, err error) { - normalized = methodNormalizer(alias(b.binder.aliases, original)) + normalized = abi.ToCamelCase(alias(b.binder.aliases, original)) // Name shouldn't start with a digit. It will make the generated code invalid. if len(normalized) > 0 && unicode.IsDigit(rune(normalized[0])) { normalized = fmt.Sprintf("E%s", normalized) @@ -43,21 +43,6 @@ func (b *contractBinder) registerIdentifier(identifiers map[string]bool, origina return normalized, nil } -// RegisterCallIdentifier applies registerIdentifier for contract methods. -func (b *contractBinder) RegisterCallIdentifier(id string) (string, error) { - return b.registerIdentifier(b.callIdentifiers, id) -} - -// RegisterEventIdentifier applies registerIdentifier for contract events. -func (b *contractBinder) RegisterEventIdentifier(id string) (string, error) { - return b.registerIdentifier(b.eventIdentifiers, id) -} - -// RegisterErrorIdentifier applies registerIdentifier for contract errors. -func (b *contractBinder) RegisterErrorIdentifier(id string) (string, error) { - return b.registerIdentifier(b.errorIdentifiers, id) -} - // BindStructType register the type to be emitted as a struct in the // bindings. func (b *binder) BindStructType(typ abi.Type) { @@ -83,7 +68,7 @@ type contractBinder struct { // into a struct. func (cb *contractBinder) bindMethod(original abi.Method) error { normalized := original - normalizedName, err := cb.RegisterCallIdentifier(original.Name) + normalizedName, err := cb.registerIdentifier(cb.callIdentifiers, original.Name) if err != nil { return err } @@ -103,7 +88,7 @@ func (cb *contractBinder) bindMethod(original abi.Method) error { copy(normalized.Outputs, original.Outputs) for j, output := range normalized.Outputs { if output.Name != "" { - normalized.Outputs[j].Name = capitalise(output.Name) + normalized.Outputs[j].Name = abi.ToCamelCase(output.Name) } if hasStruct(output.Type) { cb.binder.BindStructType(output.Type) @@ -124,7 +109,7 @@ func (cb *contractBinder) bindMethod(original abi.Method) error { if o.Name != "" { continue } - o.Name = capitalise(abi.ResolveNameConflict("arg", func(name string) bool { _, ok := keys[name]; return ok })) + o.Name = abi.ToCamelCase(abi.ResolveNameConflict("arg", func(name string) bool { _, ok := keys[name]; return ok })) normalized.Outputs[i] = o keys[strings.ToLower(o.Name)] = struct{}{} } @@ -143,7 +128,7 @@ func normalizeArgs(args abi.Arguments) abi.Arguments { if input.Name == "" || isKeyWord(input.Name) { args[i].Name = fmt.Sprintf("arg%d", i) } - args[i].Name = capitalise(args[i].Name) + args[i].Name = abi.ToCamelCase(args[i].Name) for index := 0; ; index++ { if !used[args[i].Name] { used[args[i].Name] = true @@ -173,7 +158,7 @@ func (cb *contractBinder) bindEvent(original abi.Event) error { if original.Anonymous { return nil } - normalizedName, err := cb.RegisterEventIdentifier(original.Name) + normalizedName, err := cb.registerIdentifier(cb.eventIdentifiers, original.Name) if err != nil { return err } @@ -187,7 +172,7 @@ func (cb *contractBinder) bindEvent(original abi.Event) error { // bindError normalizes an error and registers it to be emitted in the bindings. func (cb *contractBinder) bindError(original abi.Error) error { - normalizedName, err := cb.RegisterErrorIdentifier(original.Name) + normalizedName, err := cb.registerIdentifier(cb.errorIdentifiers, original.Name) if err != nil { return err } @@ -268,7 +253,7 @@ func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs }, abis[i]) // replace this with a method call to cb (name it BoundContract()?) b.contracts[types[i]] = &tmplContractV2{ - Type: capitalise(types[i]), + Type: abi.ToCamelCase(types[i]), InputABI: strings.ReplaceAll(strippedABI, "\"", "\\\""), InputBin: strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"), Constructor: evmABI.Constructor, @@ -300,7 +285,7 @@ func BindV2(types []string, abis []string, bytecodes []string, pkg string, libs funcs := map[string]interface{}{ "bindtype": bindType, "bindtopictype": bindTopicType, - "capitalise": capitalise, + "capitalise": abi.ToCamelCase, "decapitalise": decapitalise, "add": func(val1, val2 int) int { return val1 + val2 From 1e8be7972afaeff2d8d5e0ae0729a63ec499149e Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 23 Dec 2024 17:23:25 +0700 Subject: [PATCH 100/104] copy DeploymentParams overrides before creating tree deployer (prevent the backing-array provided by the API user from being mutated). re-enable deployment-with-overrides test --- accounts/abi/bind/dep_tree.go | 20 ++++++++++++++++++-- accounts/abi/bind/v2/lib_test.go | 11 +++++------ 2 files changed, 23 insertions(+), 8 deletions(-) diff --git a/accounts/abi/bind/dep_tree.go b/accounts/abi/bind/dep_tree.go index d7c3bdca7801..c7b813d0be1e 100644 --- a/accounts/abi/bind/dep_tree.go +++ b/accounts/abi/bind/dep_tree.go @@ -56,11 +56,20 @@ type depTreeDeployer struct { } func newDepTreeDeployer(deployParams *DeploymentParams, deployFn DeployFn) *depTreeDeployer { + deployedAddrs := maps.Clone(deployParams.overrides) + if deployedAddrs == nil { + deployedAddrs = make(map[string]common.Address) + } + inputs := deployParams.inputs + if inputs == nil { + inputs = make(map[string][]byte) + } + return &depTreeDeployer{ deployFn: deployFn, - deployedAddrs: maps.Clone(deployParams.overrides), + deployedAddrs: deployedAddrs, deployerTxs: make(map[string]*types.Transaction), - inputs: maps.Clone(deployParams.inputs), + inputs: inputs, } } @@ -97,6 +106,12 @@ func (d *depTreeDeployer) linkAndDeploy(metadata *MetaData) (common.Address, err // result returns a result for this deployment, or an error if it failed. func (d *depTreeDeployer) result() *DeploymentResult { + // remove the override addresses from the resulting deployedAddrs + for pattern, _ := range d.deployedAddrs { + if _, ok := d.deployerTxs[pattern]; !ok { + delete(d.deployedAddrs, pattern) + } + } return &DeploymentResult{ Txs: d.deployerTxs, Addrs: d.deployedAddrs, @@ -108,6 +123,7 @@ func (d *depTreeDeployer) result() *DeploymentResult { // deployed are returned in the result. func LinkAndDeploy(deployParams *DeploymentParams, deploy DeployFn) (res *DeploymentResult, err error) { deployer := newDepTreeDeployer(deployParams, deploy) + deployParams.inputs = make(map[string][]byte) for _, contract := range deployParams.contracts { if _, err := deployer.linkAndDeploy(contract); err != nil { return deployer.result(), err diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 6c67bc932c62..1bd8104b144b 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -166,7 +166,6 @@ func TestDeploymentLibraries(t *testing.T) { } } -/* // Same as TestDeployment. However, stagger the deployments with overrides: // first deploy the library deps and then the contract. func TestDeploymentWithOverrides(t *testing.T) { @@ -176,8 +175,8 @@ func TestDeploymentWithOverrides(t *testing.T) { } defer bindBackend.Backend.Close() - // deploy some library deps - deploymentParams := bind.NewDeploymentParams(nested_libraries.C1LibraryDeps, nil, nil) + // deploy all the library dependencies of our target contract, but not the target contract itself. + deploymentParams := bind.NewDeploymentParams(nested_libraries.C1MetaData.Deps, nil, nil) res, err := bind.LinkAndDeploy(deploymentParams, makeTestDeployer(opts, bindBackend)) if err != nil { @@ -195,6 +194,7 @@ func TestDeploymentWithOverrides(t *testing.T) { } } + // TODO: constructor input packing should not return an error. ctrct, err := nested_libraries.NewC1() if err != nil { panic(err) @@ -254,7 +254,6 @@ func TestDeploymentWithOverrides(t *testing.T) { t.Fatalf("expected internal call count of 6. got %d.", internalCallCount.Uint64()) } } -*/ func TestEvents(t *testing.T) { // test watch/filter logs method on a contract that emits various kinds of events (struct-containing, etc.) @@ -412,7 +411,7 @@ func TestErrors(t *testing.T) { // TestBindingGeneration tests that re-running generation of bindings does not result in mutations to the binding code func TestBindingGeneration(t *testing.T) { - matches, _ := filepath.Glob("internal/*") + matches, _ := filepath.Glob("internal/contracts/*") var dirs []string for _, match := range matches { f, _ := os.Stat(match) @@ -429,7 +428,7 @@ func TestBindingGeneration(t *testing.T) { sigs []map[string]string libs = make(map[string]string) ) - basePath := filepath.Join("internal", dir) + basePath := filepath.Join("internal/contracts", dir) combinedJsonPath := filepath.Join(basePath, "combined-abi.json") abiBytes, err := os.ReadFile(combinedJsonPath) if err != nil { From 4fc03b196acb14cc6bffc244da8aa7898c826072 Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 23 Dec 2024 20:44:36 +0700 Subject: [PATCH 101/104] remove error return from generated pack method for constructors. add the results of feeding v1 binding test ABIs through the v2 generator. --- accounts/abi/bind/bindv2_test.go | 22 +- .../convertedv1bindtests/callbackparam.go | 58 ++ .../bind/convertedv1bindtests/crowdsale.go | 239 ++++++++ accounts/abi/bind/convertedv1bindtests/dao.go | 516 ++++++++++++++++++ .../convertedv1bindtests/deeplynestedarray.go | 98 ++++ .../abi/bind/convertedv1bindtests/empty.go | 51 ++ .../bind/convertedv1bindtests/eventchecker.go | 215 ++++++++ .../abi/bind/convertedv1bindtests/getter.go | 80 +++ .../identifiercollision.go | 91 +++ .../bind/convertedv1bindtests/inputchecker.go | 92 ++++ .../bind/convertedv1bindtests/interactor.go | 98 ++++ .../bind/convertedv1bindtests/nameconflict.go | 117 ++++ .../convertedv1bindtests/numericmethodname.go | 104 ++++ .../convertedv1bindtests/outputchecker.go | 205 +++++++ .../abi/bind/convertedv1bindtests/overload.go | 130 +++++ .../bind/convertedv1bindtests/rangekeyword.go | 58 ++ .../abi/bind/convertedv1bindtests/slicer.go | 131 +++++ .../abi/bind/convertedv1bindtests/structs.go | 105 ++++ .../abi/bind/convertedv1bindtests/token.go | 252 +++++++++ .../abi/bind/convertedv1bindtests/tuple.go | 191 +++++++ .../abi/bind/convertedv1bindtests/tupler.go | 80 +++ .../bind/convertedv1bindtests/underscorer.go | 260 +++++++++ accounts/abi/bind/source2.go.tpl | 5 +- .../bind/v2/internal/contracts/db/bindings.go | 218 -------- .../v2/internal/contracts/events/bindings.go | 163 ------ .../contracts/nested_libraries/bindings.go | 389 ------------- .../contracts/solc_errors/bindings.go | 160 ------ .../convertedv1bindtests/callbackparam.go | 58 ++ .../convertedv1bindtests/crowdsale.go | 239 ++++++++ .../v2/internal/convertedv1bindtests/dao.go | 516 ++++++++++++++++++ .../convertedv1bindtests/deeplynestedarray.go | 98 ++++ .../v2/internal/convertedv1bindtests/empty.go | 51 ++ .../convertedv1bindtests/eventchecker.go | 215 ++++++++ .../internal/convertedv1bindtests/getter.go | 80 +++ .../identifiercollision.go | 91 +++ .../convertedv1bindtests/inputchecker.go | 92 ++++ .../convertedv1bindtests/interactor.go | 98 ++++ .../convertedv1bindtests/nameconflict.go | 117 ++++ .../convertedv1bindtests/numericmethodname.go | 104 ++++ .../convertedv1bindtests/outputchecker.go | 205 +++++++ .../internal/convertedv1bindtests/overload.go | 130 +++++ .../convertedv1bindtests/rangekeyword.go | 58 ++ .../internal/convertedv1bindtests/slicer.go | 131 +++++ .../internal/convertedv1bindtests/structs.go | 105 ++++ .../v2/internal/convertedv1bindtests/token.go | 252 +++++++++ .../v2/internal/convertedv1bindtests/tuple.go | 191 +++++++ .../internal/convertedv1bindtests/tupler.go | 80 +++ .../convertedv1bindtests/underscorer.go | 260 +++++++++ 48 files changed, 6359 insertions(+), 940 deletions(-) create mode 100644 accounts/abi/bind/convertedv1bindtests/callbackparam.go create mode 100644 accounts/abi/bind/convertedv1bindtests/crowdsale.go create mode 100644 accounts/abi/bind/convertedv1bindtests/dao.go create mode 100644 accounts/abi/bind/convertedv1bindtests/deeplynestedarray.go create mode 100644 accounts/abi/bind/convertedv1bindtests/empty.go create mode 100644 accounts/abi/bind/convertedv1bindtests/eventchecker.go create mode 100644 accounts/abi/bind/convertedv1bindtests/getter.go create mode 100644 accounts/abi/bind/convertedv1bindtests/identifiercollision.go create mode 100644 accounts/abi/bind/convertedv1bindtests/inputchecker.go create mode 100644 accounts/abi/bind/convertedv1bindtests/interactor.go create mode 100644 accounts/abi/bind/convertedv1bindtests/nameconflict.go create mode 100644 accounts/abi/bind/convertedv1bindtests/numericmethodname.go create mode 100644 accounts/abi/bind/convertedv1bindtests/outputchecker.go create mode 100644 accounts/abi/bind/convertedv1bindtests/overload.go create mode 100644 accounts/abi/bind/convertedv1bindtests/rangekeyword.go create mode 100644 accounts/abi/bind/convertedv1bindtests/slicer.go create mode 100644 accounts/abi/bind/convertedv1bindtests/structs.go create mode 100644 accounts/abi/bind/convertedv1bindtests/token.go create mode 100644 accounts/abi/bind/convertedv1bindtests/tuple.go create mode 100644 accounts/abi/bind/convertedv1bindtests/tupler.go create mode 100644 accounts/abi/bind/convertedv1bindtests/underscorer.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/callbackparam.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/crowdsale.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/dao.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/deeplynestedarray.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/empty.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/eventchecker.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/getter.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/identifiercollision.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/inputchecker.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/interactor.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/nameconflict.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/numericmethodname.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/outputchecker.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/overload.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/rangekeyword.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/slicer.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/structs.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/token.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/tuple.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/tupler.go create mode 100644 accounts/abi/bind/v2/internal/convertedv1bindtests/underscorer.go diff --git a/accounts/abi/bind/bindv2_test.go b/accounts/abi/bind/bindv2_test.go index 16740d6e6043..f743d669c7e8 100644 --- a/accounts/abi/bind/bindv2_test.go +++ b/accounts/abi/bind/bindv2_test.go @@ -5,6 +5,8 @@ import ( "fmt" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/crypto" + "os" + "strings" "testing" ) @@ -43,7 +45,7 @@ func bind(test *bindV2Test) (bound string, err error) { if test.aliases == nil { test.aliases = make(map[string]string) } - code, err := BindV2(types, abis, bins, "bindv2test", libs, test.aliases) + code, err := BindV2(types, abis, bins, "convertedv1bindtests", libs, test.aliases) if err != nil { return "", fmt.Errorf("error creating bindings: %v", err) } @@ -329,6 +331,7 @@ var bindTests2 = []bindV2Test{ } func TestBindingV2(t *testing.T) { + os.Mkdir("convertedv1bindtests", 0777) for _, tc := range bindTests2 { t.Run(tc.name, func(t *testing.T) { if tc.types == nil { @@ -339,18 +342,21 @@ func TestBindingV2(t *testing.T) { if err != nil { t.Fatalf("got error from bind: %v", err) } + + if err := os.WriteFile(fmt.Sprintf("convertedv1bindtests/%s.go", strings.ToLower(tc.name)), []byte(code), 0666); err != nil { + t.Fatalf("err writing expected output to file: %v\n", err) + } /* - if err := os.WriteFile(fmt.Sprintf("expected-output/%s.go", strings.ToLower(tc.name)), []byte(code), 0666); err != nil { - t.Fatalf("err writing expected output to file: %v\n", err) - } fmt.Printf("//go:embed v2/internal/convertedv1bindtests/%s.go\n", strings.ToLower(tc.name)) fmt.Printf("var v1TestBinding%s string\n", tc.name) fmt.Println() */ - if code != tc.expectedBindings { - t.Fatalf("name mismatch for %s", tc.name) - //t.Fatalf("'%s'\n!=\n'%s'\n", code, tc.expectedBindings) - } + /* + if code != tc.expectedBindings { + //t.Fatalf("name mismatch for %s", tc.name) + t.Fatalf("'%s'\n!=\n'%s'\n", code, tc.expectedBindings) + } + */ }) } } diff --git a/accounts/abi/bind/convertedv1bindtests/callbackparam.go b/accounts/abi/bind/convertedv1bindtests/callbackparam.go new file mode 100644 index 000000000000..6e951829b68f --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/callbackparam.go @@ -0,0 +1,58 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// CallbackParamMetaData contains all meta data concerning the CallbackParam contract. +var CallbackParamMetaData = &bind.MetaData{ + ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"callback\",\"type\":\"function\"}],\"name\":\"test\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Pattern: "949f96f86d3c2e1bcc15563ad898beaaca", + Bin: "0x608060405234801561001057600080fd5b5061015e806100206000396000f3fe60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063d7a5aba214610040575b600080fd5b34801561004c57600080fd5b506100be6004803603602081101561006357600080fd5b810190808035806c0100000000000000000000000090049068010000000000000000900463ffffffff1677ffffffffffffffffffffffffffffffffffffffffffffffff169091602001919093929190939291905050506100c0565b005b818160016040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15801561011657600080fd5b505af115801561012a573d6000803e3d6000fd5b50505050505056fea165627a7a7230582062f87455ff84be90896dbb0c4e4ddb505c600d23089f8e80a512548440d7e2580029", +} + +// CallbackParam is an auto generated Go binding around an Ethereum contract. +type CallbackParam struct { + abi abi.ABI +} + +// NewCallbackParam creates a new instance of CallbackParam. +func NewCallbackParam() (*CallbackParam, error) { + parsed, err := CallbackParamMetaData.GetAbi() + if err != nil { + return nil, err + } + return &CallbackParam{abi: *parsed}, nil +} + +func (_CallbackParam *CallbackParam) PackConstructor() []byte { + res, _ := _CallbackParam.abi.Pack("") + return res +} + +// Test is a free data retrieval call binding the contract method 0xd7a5aba2. +// +// Solidity: function test(function callback) returns() +func (_CallbackParam *CallbackParam) PackTest(callback [24]byte) ([]byte, error) { + return _CallbackParam.abi.Pack("test", callback) +} diff --git a/accounts/abi/bind/convertedv1bindtests/crowdsale.go b/accounts/abi/bind/convertedv1bindtests/crowdsale.go new file mode 100644 index 000000000000..66c17fff0132 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/crowdsale.go @@ -0,0 +1,239 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// CrowdsaleMetaData contains all meta data concerning the Crowdsale contract. +var CrowdsaleMetaData = &bind.MetaData{ + ABI: "[{\"constant\":false,\"inputs\":[],\"name\":\"checkGoalReached\",\"outputs\":[],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"deadline\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"beneficiary\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tokenReward\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"fundingGoal\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"amountRaised\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"price\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"funders\",\"outputs\":[{\"name\":\"addr\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"inputs\":[{\"name\":\"ifSuccessfulSendTo\",\"type\":\"address\"},{\"name\":\"fundingGoalInEthers\",\"type\":\"uint256\"},{\"name\":\"durationInMinutes\",\"type\":\"uint256\"},{\"name\":\"etherCostOfEachToken\",\"type\":\"uint256\"},{\"name\":\"addressOfTokenUsedAsReward\",\"type\":\"address\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"backer\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"isContribution\",\"type\":\"bool\"}],\"name\":\"FundTransfer\",\"type\":\"event\"}]", + Pattern: "84d7e935785c5c648282d326307bb8fa0d", + Bin: "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", +} + +// Crowdsale is an auto generated Go binding around an Ethereum contract. +type Crowdsale struct { + abi abi.ABI +} + +// NewCrowdsale creates a new instance of Crowdsale. +func NewCrowdsale() (*Crowdsale, error) { + parsed, err := CrowdsaleMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Crowdsale{abi: *parsed}, nil +} + +func (_Crowdsale *Crowdsale) PackConstructor(ifSuccessfulSendTo common.Address, fundingGoalInEthers *big.Int, durationInMinutes *big.Int, etherCostOfEachToken *big.Int, addressOfTokenUsedAsReward common.Address) []byte { + res, _ := _Crowdsale.abi.Pack("", ifSuccessfulSendTo, fundingGoalInEthers, durationInMinutes, etherCostOfEachToken, addressOfTokenUsedAsReward) + return res +} + +// AmountRaised is a free data retrieval call binding the contract method 0x7b3e5e7b. +// +// Solidity: function amountRaised() returns(uint256) +func (_Crowdsale *Crowdsale) PackAmountRaised() ([]byte, error) { + return _Crowdsale.abi.Pack("amountRaised") +} + +func (_Crowdsale *Crowdsale) UnpackAmountRaised(data []byte) (*big.Int, error) { + out, err := _Crowdsale.abi.Unpack("amountRaised", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Beneficiary is a free data retrieval call binding the contract method 0x38af3eed. +// +// Solidity: function beneficiary() returns(address) +func (_Crowdsale *Crowdsale) PackBeneficiary() ([]byte, error) { + return _Crowdsale.abi.Pack("beneficiary") +} + +func (_Crowdsale *Crowdsale) UnpackBeneficiary(data []byte) (common.Address, error) { + out, err := _Crowdsale.abi.Unpack("beneficiary", data) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// CheckGoalReached is a free data retrieval call binding the contract method 0x01cb3b20. +// +// Solidity: function checkGoalReached() returns() +func (_Crowdsale *Crowdsale) PackCheckGoalReached() ([]byte, error) { + return _Crowdsale.abi.Pack("checkGoalReached") +} + +// Deadline is a free data retrieval call binding the contract method 0x29dcb0cf. +// +// Solidity: function deadline() returns(uint256) +func (_Crowdsale *Crowdsale) PackDeadline() ([]byte, error) { + return _Crowdsale.abi.Pack("deadline") +} + +func (_Crowdsale *Crowdsale) UnpackDeadline(data []byte) (*big.Int, error) { + out, err := _Crowdsale.abi.Unpack("deadline", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Funders is a free data retrieval call binding the contract method 0xdc0d3dff. +// +// Solidity: function funders(uint256 ) returns(address addr, uint256 amount) +func (_Crowdsale *Crowdsale) PackFunders(arg0 *big.Int) ([]byte, error) { + return _Crowdsale.abi.Pack("funders", arg0) +} + +type FundersOutput struct { + Addr common.Address + Amount *big.Int +} + +func (_Crowdsale *Crowdsale) UnpackFunders(data []byte) (FundersOutput, error) { + out, err := _Crowdsale.abi.Unpack("funders", data) + + outstruct := new(FundersOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Addr = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.Amount = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// FundingGoal is a free data retrieval call binding the contract method 0x7a3a0e84. +// +// Solidity: function fundingGoal() returns(uint256) +func (_Crowdsale *Crowdsale) PackFundingGoal() ([]byte, error) { + return _Crowdsale.abi.Pack("fundingGoal") +} + +func (_Crowdsale *Crowdsale) UnpackFundingGoal(data []byte) (*big.Int, error) { + out, err := _Crowdsale.abi.Unpack("fundingGoal", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Price is a free data retrieval call binding the contract method 0xa035b1fe. +// +// Solidity: function price() returns(uint256) +func (_Crowdsale *Crowdsale) PackPrice() ([]byte, error) { + return _Crowdsale.abi.Pack("price") +} + +func (_Crowdsale *Crowdsale) UnpackPrice(data []byte) (*big.Int, error) { + out, err := _Crowdsale.abi.Unpack("price", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TokenReward is a free data retrieval call binding the contract method 0x6e66f6e9. +// +// Solidity: function tokenReward() returns(address) +func (_Crowdsale *Crowdsale) PackTokenReward() ([]byte, error) { + return _Crowdsale.abi.Pack("tokenReward") +} + +func (_Crowdsale *Crowdsale) UnpackTokenReward(data []byte) (common.Address, error) { + out, err := _Crowdsale.abi.Unpack("tokenReward", data) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// CrowdsaleFundTransfer represents a FundTransfer event raised by the Crowdsale contract. +type CrowdsaleFundTransfer struct { + Backer common.Address + Amount *big.Int + IsContribution bool + Raw *types.Log // Blockchain specific contextual infos +} + +const CrowdsaleFundTransferEventName = "FundTransfer" + +func (_Crowdsale *Crowdsale) UnpackFundTransferEvent(log *types.Log) (*CrowdsaleFundTransfer, error) { + event := "FundTransfer" + if log.Topics[0] != _Crowdsale.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(CrowdsaleFundTransfer) + if len(log.Data) > 0 { + if err := _Crowdsale.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Crowdsale.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/convertedv1bindtests/dao.go b/accounts/abi/bind/convertedv1bindtests/dao.go new file mode 100644 index 000000000000..0d6b6e2f3b1d --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/dao.go @@ -0,0 +1,516 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// DAOMetaData contains all meta data concerning the DAO contract. +var DAOMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"proposals\",\"outputs\":[{\"name\":\"recipient\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"},{\"name\":\"description\",\"type\":\"string\"},{\"name\":\"votingDeadline\",\"type\":\"uint256\"},{\"name\":\"executed\",\"type\":\"bool\"},{\"name\":\"proposalPassed\",\"type\":\"bool\"},{\"name\":\"numberOfVotes\",\"type\":\"uint256\"},{\"name\":\"currentResult\",\"type\":\"int256\"},{\"name\":\"proposalHash\",\"type\":\"bytes32\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"proposalNumber\",\"type\":\"uint256\"},{\"name\":\"transactionBytecode\",\"type\":\"bytes\"}],\"name\":\"executeProposal\",\"outputs\":[{\"name\":\"result\",\"type\":\"int256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"memberId\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"numProposals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"members\",\"outputs\":[{\"name\":\"member\",\"type\":\"address\"},{\"name\":\"canVote\",\"type\":\"bool\"},{\"name\":\"name\",\"type\":\"string\"},{\"name\":\"memberSince\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"debatingPeriodInMinutes\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"minimumQuorum\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"targetMember\",\"type\":\"address\"},{\"name\":\"canVote\",\"type\":\"bool\"},{\"name\":\"memberName\",\"type\":\"string\"}],\"name\":\"changeMembership\",\"outputs\":[],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"majorityMargin\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"beneficiary\",\"type\":\"address\"},{\"name\":\"etherAmount\",\"type\":\"uint256\"},{\"name\":\"JobDescription\",\"type\":\"string\"},{\"name\":\"transactionBytecode\",\"type\":\"bytes\"}],\"name\":\"newProposal\",\"outputs\":[{\"name\":\"proposalID\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"minimumQuorumForProposals\",\"type\":\"uint256\"},{\"name\":\"minutesForDebate\",\"type\":\"uint256\"},{\"name\":\"marginOfVotesForMajority\",\"type\":\"int256\"}],\"name\":\"changeVotingRules\",\"outputs\":[],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"proposalNumber\",\"type\":\"uint256\"},{\"name\":\"supportsProposal\",\"type\":\"bool\"},{\"name\":\"justificationText\",\"type\":\"string\"}],\"name\":\"vote\",\"outputs\":[{\"name\":\"voteID\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"proposalNumber\",\"type\":\"uint256\"},{\"name\":\"beneficiary\",\"type\":\"address\"},{\"name\":\"etherAmount\",\"type\":\"uint256\"},{\"name\":\"transactionBytecode\",\"type\":\"bytes\"}],\"name\":\"checkProposalCode\",\"outputs\":[{\"name\":\"codeChecksOut\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"type\":\"function\"},{\"inputs\":[{\"name\":\"minimumQuorumForProposals\",\"type\":\"uint256\"},{\"name\":\"minutesForDebate\",\"type\":\"uint256\"},{\"name\":\"marginOfVotesForMajority\",\"type\":\"int256\"},{\"name\":\"congressLeader\",\"type\":\"address\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"proposalID\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"description\",\"type\":\"string\"}],\"name\":\"ProposalAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"proposalID\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"position\",\"type\":\"bool\"},{\"indexed\":false,\"name\":\"voter\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"justification\",\"type\":\"string\"}],\"name\":\"Voted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"proposalID\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"result\",\"type\":\"int256\"},{\"indexed\":false,\"name\":\"quorum\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"active\",\"type\":\"bool\"}],\"name\":\"ProposalTallied\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"member\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"isMember\",\"type\":\"bool\"}],\"name\":\"MembershipChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"minimumQuorum\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"debatingPeriodInMinutes\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"majorityMargin\",\"type\":\"int256\"}],\"name\":\"ChangeOfRules\",\"type\":\"event\"}]", + Pattern: "d0a4ad96d49edb1c33461cebc6fb260919", + Bin: "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", +} + +// DAO is an auto generated Go binding around an Ethereum contract. +type DAO struct { + abi abi.ABI +} + +// NewDAO creates a new instance of DAO. +func NewDAO() (*DAO, error) { + parsed, err := DAOMetaData.GetAbi() + if err != nil { + return nil, err + } + return &DAO{abi: *parsed}, nil +} + +func (_DAO *DAO) PackConstructor(minimumQuorumForProposals *big.Int, minutesForDebate *big.Int, marginOfVotesForMajority *big.Int, congressLeader common.Address) []byte { + res, _ := _DAO.abi.Pack("", minimumQuorumForProposals, minutesForDebate, marginOfVotesForMajority, congressLeader) + return res +} + +// ChangeMembership is a free data retrieval call binding the contract method 0x9644fcbd. +// +// Solidity: function changeMembership(address targetMember, bool canVote, string memberName) returns() +func (_DAO *DAO) PackChangeMembership(targetMember common.Address, canVote bool, memberName string) ([]byte, error) { + return _DAO.abi.Pack("changeMembership", targetMember, canVote, memberName) +} + +// ChangeVotingRules is a free data retrieval call binding the contract method 0xbcca1fd3. +// +// Solidity: function changeVotingRules(uint256 minimumQuorumForProposals, uint256 minutesForDebate, int256 marginOfVotesForMajority) returns() +func (_DAO *DAO) PackChangeVotingRules(minimumQuorumForProposals *big.Int, minutesForDebate *big.Int, marginOfVotesForMajority *big.Int) ([]byte, error) { + return _DAO.abi.Pack("changeVotingRules", minimumQuorumForProposals, minutesForDebate, marginOfVotesForMajority) +} + +// CheckProposalCode is a free data retrieval call binding the contract method 0xeceb2945. +// +// Solidity: function checkProposalCode(uint256 proposalNumber, address beneficiary, uint256 etherAmount, bytes transactionBytecode) returns(bool codeChecksOut) +func (_DAO *DAO) PackCheckProposalCode(proposalNumber *big.Int, beneficiary common.Address, etherAmount *big.Int, transactionBytecode []byte) ([]byte, error) { + return _DAO.abi.Pack("checkProposalCode", proposalNumber, beneficiary, etherAmount, transactionBytecode) +} + +func (_DAO *DAO) UnpackCheckProposalCode(data []byte) (bool, error) { + out, err := _DAO.abi.Unpack("checkProposalCode", data) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// DebatingPeriodInMinutes is a free data retrieval call binding the contract method 0x69bd3436. +// +// Solidity: function debatingPeriodInMinutes() returns(uint256) +func (_DAO *DAO) PackDebatingPeriodInMinutes() ([]byte, error) { + return _DAO.abi.Pack("debatingPeriodInMinutes") +} + +func (_DAO *DAO) UnpackDebatingPeriodInMinutes(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("debatingPeriodInMinutes", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ExecuteProposal is a free data retrieval call binding the contract method 0x237e9492. +// +// Solidity: function executeProposal(uint256 proposalNumber, bytes transactionBytecode) returns(int256 result) +func (_DAO *DAO) PackExecuteProposal(proposalNumber *big.Int, transactionBytecode []byte) ([]byte, error) { + return _DAO.abi.Pack("executeProposal", proposalNumber, transactionBytecode) +} + +func (_DAO *DAO) UnpackExecuteProposal(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("executeProposal", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MajorityMargin is a free data retrieval call binding the contract method 0xaa02a90f. +// +// Solidity: function majorityMargin() returns(int256) +func (_DAO *DAO) PackMajorityMargin() ([]byte, error) { + return _DAO.abi.Pack("majorityMargin") +} + +func (_DAO *DAO) UnpackMajorityMargin(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("majorityMargin", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MemberId is a free data retrieval call binding the contract method 0x39106821. +// +// Solidity: function memberId(address ) returns(uint256) +func (_DAO *DAO) PackMemberId(arg0 common.Address) ([]byte, error) { + return _DAO.abi.Pack("memberId", arg0) +} + +func (_DAO *DAO) UnpackMemberId(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("memberId", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Members is a free data retrieval call binding the contract method 0x5daf08ca. +// +// Solidity: function members(uint256 ) returns(address member, bool canVote, string name, uint256 memberSince) +func (_DAO *DAO) PackMembers(arg0 *big.Int) ([]byte, error) { + return _DAO.abi.Pack("members", arg0) +} + +type MembersOutput struct { + Member common.Address + CanVote bool + Name string + MemberSince *big.Int +} + +func (_DAO *DAO) UnpackMembers(data []byte) (MembersOutput, error) { + out, err := _DAO.abi.Unpack("members", data) + + outstruct := new(MembersOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Member = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.CanVote = *abi.ConvertType(out[1], new(bool)).(*bool) + outstruct.Name = *abi.ConvertType(out[2], new(string)).(*string) + outstruct.MemberSince = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// MinimumQuorum is a free data retrieval call binding the contract method 0x8160f0b5. +// +// Solidity: function minimumQuorum() returns(uint256) +func (_DAO *DAO) PackMinimumQuorum() ([]byte, error) { + return _DAO.abi.Pack("minimumQuorum") +} + +func (_DAO *DAO) UnpackMinimumQuorum(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("minimumQuorum", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// NewProposal is a free data retrieval call binding the contract method 0xb1050da5. +// +// Solidity: function newProposal(address beneficiary, uint256 etherAmount, string JobDescription, bytes transactionBytecode) returns(uint256 proposalID) +func (_DAO *DAO) PackNewProposal(beneficiary common.Address, etherAmount *big.Int, JobDescription string, transactionBytecode []byte) ([]byte, error) { + return _DAO.abi.Pack("newProposal", beneficiary, etherAmount, JobDescription, transactionBytecode) +} + +func (_DAO *DAO) UnpackNewProposal(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("newProposal", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// NumProposals is a free data retrieval call binding the contract method 0x400e3949. +// +// Solidity: function numProposals() returns(uint256) +func (_DAO *DAO) PackNumProposals() ([]byte, error) { + return _DAO.abi.Pack("numProposals") +} + +func (_DAO *DAO) UnpackNumProposals(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("numProposals", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() returns(address) +func (_DAO *DAO) PackOwner() ([]byte, error) { + return _DAO.abi.Pack("owner") +} + +func (_DAO *DAO) UnpackOwner(data []byte) (common.Address, error) { + out, err := _DAO.abi.Unpack("owner", data) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Proposals is a free data retrieval call binding the contract method 0x013cf08b. +// +// Solidity: function proposals(uint256 ) returns(address recipient, uint256 amount, string description, uint256 votingDeadline, bool executed, bool proposalPassed, uint256 numberOfVotes, int256 currentResult, bytes32 proposalHash) +func (_DAO *DAO) PackProposals(arg0 *big.Int) ([]byte, error) { + return _DAO.abi.Pack("proposals", arg0) +} + +type ProposalsOutput struct { + Recipient common.Address + Amount *big.Int + Description string + VotingDeadline *big.Int + Executed bool + ProposalPassed bool + NumberOfVotes *big.Int + CurrentResult *big.Int + ProposalHash [32]byte +} + +func (_DAO *DAO) UnpackProposals(data []byte) (ProposalsOutput, error) { + out, err := _DAO.abi.Unpack("proposals", data) + + outstruct := new(ProposalsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Recipient = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.Amount = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.Description = *abi.ConvertType(out[2], new(string)).(*string) + outstruct.VotingDeadline = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) + outstruct.Executed = *abi.ConvertType(out[4], new(bool)).(*bool) + outstruct.ProposalPassed = *abi.ConvertType(out[5], new(bool)).(*bool) + outstruct.NumberOfVotes = *abi.ConvertType(out[6], new(*big.Int)).(**big.Int) + outstruct.CurrentResult = *abi.ConvertType(out[7], new(*big.Int)).(**big.Int) + outstruct.ProposalHash = *abi.ConvertType(out[8], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// TransferOwnership is a free data retrieval call binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_DAO *DAO) PackTransferOwnership(newOwner common.Address) ([]byte, error) { + return _DAO.abi.Pack("transferOwnership", newOwner) +} + +// Vote is a free data retrieval call binding the contract method 0xd3c0715b. +// +// Solidity: function vote(uint256 proposalNumber, bool supportsProposal, string justificationText) returns(uint256 voteID) +func (_DAO *DAO) PackVote(proposalNumber *big.Int, supportsProposal bool, justificationText string) ([]byte, error) { + return _DAO.abi.Pack("vote", proposalNumber, supportsProposal, justificationText) +} + +func (_DAO *DAO) UnpackVote(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("vote", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DAOChangeOfRules represents a ChangeOfRules event raised by the DAO contract. +type DAOChangeOfRules struct { + MinimumQuorum *big.Int + DebatingPeriodInMinutes *big.Int + MajorityMargin *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOChangeOfRulesEventName = "ChangeOfRules" + +func (_DAO *DAO) UnpackChangeOfRulesEvent(log *types.Log) (*DAOChangeOfRules, error) { + event := "ChangeOfRules" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOChangeOfRules) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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 +} + +// DAOMembershipChanged represents a MembershipChanged event raised by the DAO contract. +type DAOMembershipChanged struct { + Member common.Address + IsMember bool + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOMembershipChangedEventName = "MembershipChanged" + +func (_DAO *DAO) UnpackMembershipChangedEvent(log *types.Log) (*DAOMembershipChanged, error) { + event := "MembershipChanged" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOMembershipChanged) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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 +} + +// DAOProposalAdded represents a ProposalAdded event raised by the DAO contract. +type DAOProposalAdded struct { + ProposalID *big.Int + Recipient common.Address + Amount *big.Int + Description string + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOProposalAddedEventName = "ProposalAdded" + +func (_DAO *DAO) UnpackProposalAddedEvent(log *types.Log) (*DAOProposalAdded, error) { + event := "ProposalAdded" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOProposalAdded) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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 +} + +// DAOProposalTallied represents a ProposalTallied event raised by the DAO contract. +type DAOProposalTallied struct { + ProposalID *big.Int + Result *big.Int + Quorum *big.Int + Active bool + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOProposalTalliedEventName = "ProposalTallied" + +func (_DAO *DAO) UnpackProposalTalliedEvent(log *types.Log) (*DAOProposalTallied, error) { + event := "ProposalTallied" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOProposalTallied) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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 +} + +// DAOVoted represents a Voted event raised by the DAO contract. +type DAOVoted struct { + ProposalID *big.Int + Position bool + Voter common.Address + Justification string + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOVotedEventName = "Voted" + +func (_DAO *DAO) UnpackVotedEvent(log *types.Log) (*DAOVoted, error) { + event := "Voted" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOVoted) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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/convertedv1bindtests/deeplynestedarray.go b/accounts/abi/bind/convertedv1bindtests/deeplynestedarray.go new file mode 100644 index 000000000000..ab2cd5574a5c --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/deeplynestedarray.go @@ -0,0 +1,98 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// DeeplyNestedArrayMetaData contains all meta data concerning the DeeplyNestedArray contract. +var DeeplyNestedArrayMetaData = &bind.MetaData{ + ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"arr\",\"type\":\"uint64[3][4][5]\"}],\"name\":\"storeDeepUintArray\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"retrieveDeepArray\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64[3][4][5]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"deepUint64Array\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", + Pattern: "3a44c26b21f02743d5dbeb02d24a67bf41", + Bin: "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", +} + +// DeeplyNestedArray is an auto generated Go binding around an Ethereum contract. +type DeeplyNestedArray struct { + abi abi.ABI +} + +// NewDeeplyNestedArray creates a new instance of DeeplyNestedArray. +func NewDeeplyNestedArray() (*DeeplyNestedArray, error) { + parsed, err := DeeplyNestedArrayMetaData.GetAbi() + if err != nil { + return nil, err + } + return &DeeplyNestedArray{abi: *parsed}, nil +} + +func (_DeeplyNestedArray *DeeplyNestedArray) PackConstructor() []byte { + res, _ := _DeeplyNestedArray.abi.Pack("") + return res +} + +// DeepUint64Array is a free data retrieval call binding the contract method 0x98ed1856. +// +// Solidity: function deepUint64Array(uint256 , uint256 , uint256 ) view returns(uint64) +func (_DeeplyNestedArray *DeeplyNestedArray) PackDeepUint64Array(arg0 *big.Int, arg1 *big.Int, arg2 *big.Int) ([]byte, error) { + return _DeeplyNestedArray.abi.Pack("deepUint64Array", arg0, arg1, arg2) +} + +func (_DeeplyNestedArray *DeeplyNestedArray) UnpackDeepUint64Array(data []byte) (uint64, error) { + out, err := _DeeplyNestedArray.abi.Unpack("deepUint64Array", data) + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// RetrieveDeepArray is a free data retrieval call binding the contract method 0x8ed4573a. +// +// Solidity: function retrieveDeepArray() view returns(uint64[3][4][5]) +func (_DeeplyNestedArray *DeeplyNestedArray) PackRetrieveDeepArray() ([]byte, error) { + return _DeeplyNestedArray.abi.Pack("retrieveDeepArray") +} + +func (_DeeplyNestedArray *DeeplyNestedArray) UnpackRetrieveDeepArray(data []byte) ([5][4][3]uint64, error) { + out, err := _DeeplyNestedArray.abi.Unpack("retrieveDeepArray", data) + + if err != nil { + return *new([5][4][3]uint64), err + } + + out0 := *abi.ConvertType(out[0], new([5][4][3]uint64)).(*[5][4][3]uint64) + + return out0, err + +} + +// StoreDeepUintArray is a free data retrieval call binding the contract method 0x34424855. +// +// Solidity: function storeDeepUintArray(uint64[3][4][5] arr) returns() +func (_DeeplyNestedArray *DeeplyNestedArray) PackStoreDeepUintArray(arr [5][4][3]uint64) ([]byte, error) { + return _DeeplyNestedArray.abi.Pack("storeDeepUintArray", arr) +} diff --git a/accounts/abi/bind/convertedv1bindtests/empty.go b/accounts/abi/bind/convertedv1bindtests/empty.go new file mode 100644 index 000000000000..e6c7efd7ae65 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/empty.go @@ -0,0 +1,51 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// EmptyMetaData contains all meta data concerning the Empty contract. +var EmptyMetaData = &bind.MetaData{ + ABI: "[]", + Pattern: "c4ce3210982aa6fc94dabe46dc1dbf454d", + Bin: "0x606060405260068060106000396000f3606060405200", +} + +// Empty is an auto generated Go binding around an Ethereum contract. +type Empty struct { + abi abi.ABI +} + +// NewEmpty creates a new instance of Empty. +func NewEmpty() (*Empty, error) { + parsed, err := EmptyMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Empty{abi: *parsed}, nil +} + +func (_Empty *Empty) PackConstructor() []byte { + res, _ := _Empty.abi.Pack("") + return res +} diff --git a/accounts/abi/bind/convertedv1bindtests/eventchecker.go b/accounts/abi/bind/convertedv1bindtests/eventchecker.go new file mode 100644 index 000000000000..742d9876b098 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/eventchecker.go @@ -0,0 +1,215 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// EventCheckerMetaData contains all meta data concerning the EventChecker contract. +var EventCheckerMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"event\",\"name\":\"empty\",\"inputs\":[]},{\"type\":\"event\",\"name\":\"indexed\",\"inputs\":[{\"name\":\"addr\",\"type\":\"address\",\"indexed\":true},{\"name\":\"num\",\"type\":\"int256\",\"indexed\":true}]},{\"type\":\"event\",\"name\":\"mixed\",\"inputs\":[{\"name\":\"addr\",\"type\":\"address\",\"indexed\":true},{\"name\":\"num\",\"type\":\"int256\"}]},{\"type\":\"event\",\"name\":\"anonymous\",\"anonymous\":true,\"inputs\":[]},{\"type\":\"event\",\"name\":\"dynamic\",\"inputs\":[{\"name\":\"idxStr\",\"type\":\"string\",\"indexed\":true},{\"name\":\"idxDat\",\"type\":\"bytes\",\"indexed\":true},{\"name\":\"str\",\"type\":\"string\"},{\"name\":\"dat\",\"type\":\"bytes\"}]},{\"type\":\"event\",\"name\":\"unnamed\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"\",\"type\":\"uint256\",\"indexed\":true}]}]", + Pattern: "253d421f98e29b25315bde79c1251ab27c", +} + +// EventChecker is an auto generated Go binding around an Ethereum contract. +type EventChecker struct { + abi abi.ABI +} + +// NewEventChecker creates a new instance of EventChecker. +func NewEventChecker() (*EventChecker, error) { + parsed, err := EventCheckerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &EventChecker{abi: *parsed}, nil +} + +func (_EventChecker *EventChecker) PackConstructor() []byte { + res, _ := _EventChecker.abi.Pack("") + return res +} + +// EventCheckerDynamic represents a Dynamic event raised by the EventChecker contract. +type EventCheckerDynamic struct { + IdxStr common.Hash + IdxDat common.Hash + Str string + Dat []byte + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerDynamicEventName = "dynamic" + +func (_EventChecker *EventChecker) UnpackDynamicEvent(log *types.Log) (*EventCheckerDynamic, error) { + event := "dynamic" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerDynamic) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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 +} + +// EventCheckerEmpty represents a Empty event raised by the EventChecker contract. +type EventCheckerEmpty struct { + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerEmptyEventName = "empty" + +func (_EventChecker *EventChecker) UnpackEmptyEvent(log *types.Log) (*EventCheckerEmpty, error) { + event := "empty" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerEmpty) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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 +} + +// EventCheckerIndexed represents a Indexed event raised by the EventChecker contract. +type EventCheckerIndexed struct { + Addr common.Address + Num *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerIndexedEventName = "indexed" + +func (_EventChecker *EventChecker) UnpackIndexedEvent(log *types.Log) (*EventCheckerIndexed, error) { + event := "indexed" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerIndexed) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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 +} + +// EventCheckerMixed represents a Mixed event raised by the EventChecker contract. +type EventCheckerMixed struct { + Addr common.Address + Num *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerMixedEventName = "mixed" + +func (_EventChecker *EventChecker) UnpackMixedEvent(log *types.Log) (*EventCheckerMixed, error) { + event := "mixed" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerMixed) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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 +} + +// EventCheckerUnnamed represents a Unnamed event raised by the EventChecker contract. +type EventCheckerUnnamed struct { + Arg0 *big.Int + Arg1 *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerUnnamedEventName = "unnamed" + +func (_EventChecker *EventChecker) UnpackUnnamedEvent(log *types.Log) (*EventCheckerUnnamed, error) { + event := "unnamed" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerUnnamed) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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/convertedv1bindtests/getter.go b/accounts/abi/bind/convertedv1bindtests/getter.go new file mode 100644 index 000000000000..067dc21af80b --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/getter.go @@ -0,0 +1,80 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// GetterMetaData contains all meta data concerning the Getter contract. +var GetterMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"getter\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"int256\"},{\"name\":\"\",\"type\":\"bytes32\"}],\"type\":\"function\"}]", + Pattern: "e23a74c8979fe93c9fff15e4f51535ad54", + Bin: "0x606060405260dc8060106000396000f3606060405260e060020a6000350463993a04b78114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3", +} + +// Getter is an auto generated Go binding around an Ethereum contract. +type Getter struct { + abi abi.ABI +} + +// NewGetter creates a new instance of Getter. +func NewGetter() (*Getter, error) { + parsed, err := GetterMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Getter{abi: *parsed}, nil +} + +func (_Getter *Getter) PackConstructor() []byte { + res, _ := _Getter.abi.Pack("") + return res +} + +// Getter is a free data retrieval call binding the contract method 0x993a04b7. +// +// Solidity: function getter() returns(string, int256, bytes32) +func (_Getter *Getter) PackGetter() ([]byte, error) { + return _Getter.abi.Pack("getter") +} + +type GetterOutput struct { + Arg string + Arg0 *big.Int + Arg1 [32]byte +} + +func (_Getter *Getter) UnpackGetter(data []byte) (GetterOutput, error) { + out, err := _Getter.abi.Unpack("getter", data) + + outstruct := new(GetterOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Arg0 = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.Arg1 = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} diff --git a/accounts/abi/bind/convertedv1bindtests/identifiercollision.go b/accounts/abi/bind/convertedv1bindtests/identifiercollision.go new file mode 100644 index 000000000000..150a1ad16391 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/identifiercollision.go @@ -0,0 +1,91 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// IdentifierCollisionMetaData contains all meta data concerning the IdentifierCollision contract. +var IdentifierCollisionMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"MyVar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_myVar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", + Pattern: "1863c5622f8ac2c09c42f063ca883fe438", + Bin: "0x60806040523480156100115760006000fd5b50610017565b60c3806100256000396000f3fe608060405234801560105760006000fd5b506004361060365760003560e01c806301ad4d8714603c5780634ef1f0ad146058576036565b60006000fd5b60426074565b6040518082815260200191505060405180910390f35b605e607d565b6040518082815260200191505060405180910390f35b60006000505481565b60006000600050549050608b565b9056fea265627a7a7231582067c8d84688b01c4754ba40a2a871cede94ea1f28b5981593ab2a45b46ac43af664736f6c634300050c0032", +} + +// IdentifierCollision is an auto generated Go binding around an Ethereum contract. +type IdentifierCollision struct { + abi abi.ABI +} + +// NewIdentifierCollision creates a new instance of IdentifierCollision. +func NewIdentifierCollision() (*IdentifierCollision, error) { + parsed, err := IdentifierCollisionMetaData.GetAbi() + if err != nil { + return nil, err + } + return &IdentifierCollision{abi: *parsed}, nil +} + +func (_IdentifierCollision *IdentifierCollision) PackConstructor() []byte { + res, _ := _IdentifierCollision.abi.Pack("") + return res +} + +// MyVar is a free data retrieval call binding the contract method 0x4ef1f0ad. +// +// Solidity: function MyVar() view returns(uint256) +func (_IdentifierCollision *IdentifierCollision) PackMyVar() ([]byte, error) { + return _IdentifierCollision.abi.Pack("MyVar") +} + +func (_IdentifierCollision *IdentifierCollision) UnpackMyVar(data []byte) (*big.Int, error) { + out, err := _IdentifierCollision.abi.Unpack("MyVar", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PubVar is a free data retrieval call binding the contract method 0x01ad4d87. +// +// Solidity: function _myVar() view returns(uint256) +func (_IdentifierCollision *IdentifierCollision) PackPubVar() ([]byte, error) { + return _IdentifierCollision.abi.Pack("_myVar") +} + +func (_IdentifierCollision *IdentifierCollision) UnpackPubVar(data []byte) (*big.Int, error) { + out, err := _IdentifierCollision.abi.Unpack("_myVar", 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/convertedv1bindtests/inputchecker.go b/accounts/abi/bind/convertedv1bindtests/inputchecker.go new file mode 100644 index 000000000000..59664669361b --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/inputchecker.go @@ -0,0 +1,92 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// InputCheckerMetaData contains all meta data concerning the InputChecker contract. +var InputCheckerMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"noInput\",\"constant\":true,\"inputs\":[],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedInput\",\"constant\":true,\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"anonInput\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedInputs\",\"constant\":true,\"inputs\":[{\"name\":\"str1\",\"type\":\"string\"},{\"name\":\"str2\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"anonInputs\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"mixedInputs\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"str\",\"type\":\"string\"}],\"outputs\":[]}]", + Pattern: "e551ce092312e54f54f45ffdf06caa4cdc", +} + +// InputChecker is an auto generated Go binding around an Ethereum contract. +type InputChecker struct { + abi abi.ABI +} + +// NewInputChecker creates a new instance of InputChecker. +func NewInputChecker() (*InputChecker, error) { + parsed, err := InputCheckerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &InputChecker{abi: *parsed}, nil +} + +func (_InputChecker *InputChecker) PackConstructor() []byte { + res, _ := _InputChecker.abi.Pack("") + return res +} + +// AnonInput is a free data retrieval call binding the contract method 0x3e708e82. +// +// Solidity: function anonInput(string ) returns() +func (_InputChecker *InputChecker) PackAnonInput(arg0 string) ([]byte, error) { + return _InputChecker.abi.Pack("anonInput", arg0) +} + +// AnonInputs is a free data retrieval call binding the contract method 0x28160527. +// +// Solidity: function anonInputs(string , string ) returns() +func (_InputChecker *InputChecker) PackAnonInputs(arg0 string, arg1 string) ([]byte, error) { + return _InputChecker.abi.Pack("anonInputs", arg0, arg1) +} + +// MixedInputs is a free data retrieval call binding the contract method 0xc689ebdc. +// +// Solidity: function mixedInputs(string , string str) returns() +func (_InputChecker *InputChecker) PackMixedInputs(arg0 string, str string) ([]byte, error) { + return _InputChecker.abi.Pack("mixedInputs", arg0, str) +} + +// NamedInput is a free data retrieval call binding the contract method 0x0d402005. +// +// Solidity: function namedInput(string str) returns() +func (_InputChecker *InputChecker) PackNamedInput(str string) ([]byte, error) { + return _InputChecker.abi.Pack("namedInput", str) +} + +// NamedInputs is a free data retrieval call binding the contract method 0x63c796ed. +// +// Solidity: function namedInputs(string str1, string str2) returns() +func (_InputChecker *InputChecker) PackNamedInputs(str1 string, str2 string) ([]byte, error) { + return _InputChecker.abi.Pack("namedInputs", str1, str2) +} + +// NoInput is a free data retrieval call binding the contract method 0x53539029. +// +// Solidity: function noInput() returns() +func (_InputChecker *InputChecker) PackNoInput() ([]byte, error) { + return _InputChecker.abi.Pack("noInput") +} diff --git a/accounts/abi/bind/convertedv1bindtests/interactor.go b/accounts/abi/bind/convertedv1bindtests/interactor.go new file mode 100644 index 000000000000..d921c9031bf9 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/interactor.go @@ -0,0 +1,98 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// InteractorMetaData contains all meta data concerning the Interactor contract. +var InteractorMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"transactString\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"deployString\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"name\":\"transact\",\"outputs\":[],\"type\":\"function\"},{\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"type\":\"constructor\"}]", + Pattern: "f63980878028f3242c9033fdc30fd21a81", + Bin: "0x6060604052604051610328380380610328833981016040528051018060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10608d57805160ff19168380011785555b50607c9291505b8082111560ba57838155600101606b565b50505061026a806100be6000396000f35b828001600101855582156064579182015b828111156064578251826000505591602001919060010190609e565b509056606060405260e060020a60003504630d86a0e181146100315780636874e8091461008d578063d736c513146100ea575b005b610190600180546020600282841615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b61019060008054602060026001831615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b60206004803580820135601f81018490049093026080908101604052606084815261002f946024939192918401918190838280828437509496505050505050508060016000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061023157805160ff19168380011785555b506102619291505b808211156102665760008155830161017d565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101f05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b820191906000526020600020905b81548152906001019060200180831161020c57829003601f168201915b505050505081565b82800160010185558215610175579182015b82811115610175578251826000505591602001919060010190610243565b505050565b509056", +} + +// Interactor is an auto generated Go binding around an Ethereum contract. +type Interactor struct { + abi abi.ABI +} + +// NewInteractor creates a new instance of Interactor. +func NewInteractor() (*Interactor, error) { + parsed, err := InteractorMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Interactor{abi: *parsed}, nil +} + +func (_Interactor *Interactor) PackConstructor(str string) []byte { + res, _ := _Interactor.abi.Pack("", str) + return res +} + +// DeployString is a free data retrieval call binding the contract method 0x6874e809. +// +// Solidity: function deployString() returns(string) +func (_Interactor *Interactor) PackDeployString() ([]byte, error) { + return _Interactor.abi.Pack("deployString") +} + +func (_Interactor *Interactor) UnpackDeployString(data []byte) (string, error) { + out, err := _Interactor.abi.Unpack("deployString", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Transact is a free data retrieval call binding the contract method 0xd736c513. +// +// Solidity: function transact(string str) returns() +func (_Interactor *Interactor) PackTransact(str string) ([]byte, error) { + return _Interactor.abi.Pack("transact", str) +} + +// TransactString is a free data retrieval call binding the contract method 0x0d86a0e1. +// +// Solidity: function transactString() returns(string) +func (_Interactor *Interactor) PackTransactString() ([]byte, error) { + return _Interactor.abi.Pack("transactString") +} + +func (_Interactor *Interactor) UnpackTransactString(data []byte) (string, error) { + out, err := _Interactor.abi.Unpack("transactString", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} diff --git a/accounts/abi/bind/convertedv1bindtests/nameconflict.go b/accounts/abi/bind/convertedv1bindtests/nameconflict.go new file mode 100644 index 000000000000..8046fd67ccb8 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/nameconflict.go @@ -0,0 +1,117 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// Oraclerequest is an auto generated low-level Go binding around an user-defined struct. +type Oraclerequest struct { + Data []byte + Data0 []byte +} + +// TODO: convert this type to value type after everything works. +// NameConflictMetaData contains all meta data concerning the NameConflict contract. +var NameConflictMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"msg\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"_msg\",\"type\":\"int256\"}],\"name\":\"log\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"internalType\":\"structoracle.request\",\"name\":\"req\",\"type\":\"tuple\"}],\"name\":\"addRequest\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRequest\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"internalType\":\"structoracle.request\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "8f6e2703b307244ae6bd61ed94ce959cf9", + Bin: "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", +} + +// NameConflict is an auto generated Go binding around an Ethereum contract. +type NameConflict struct { + abi abi.ABI +} + +// NewNameConflict creates a new instance of NameConflict. +func NewNameConflict() (*NameConflict, error) { + parsed, err := NameConflictMetaData.GetAbi() + if err != nil { + return nil, err + } + return &NameConflict{abi: *parsed}, nil +} + +func (_NameConflict *NameConflict) PackConstructor() []byte { + res, _ := _NameConflict.abi.Pack("") + return res +} + +// AddRequest is a free data retrieval call binding the contract method 0xcce7b048. +// +// Solidity: function addRequest((bytes,bytes) req) pure returns() +func (_NameConflict *NameConflict) PackAddRequest(req Oraclerequest) ([]byte, error) { + return _NameConflict.abi.Pack("addRequest", req) +} + +// GetRequest is a free data retrieval call binding the contract method 0xc2bb515f. +// +// Solidity: function getRequest() pure returns((bytes,bytes)) +func (_NameConflict *NameConflict) PackGetRequest() ([]byte, error) { + return _NameConflict.abi.Pack("getRequest") +} + +func (_NameConflict *NameConflict) UnpackGetRequest(data []byte) (Oraclerequest, error) { + out, err := _NameConflict.abi.Unpack("getRequest", data) + + if err != nil { + return *new(Oraclerequest), err + } + + out0 := *abi.ConvertType(out[0], new(Oraclerequest)).(*Oraclerequest) + + return out0, err + +} + +// NameConflictLog represents a Log event raised by the NameConflict contract. +type NameConflictLog struct { + Msg *big.Int + Msg0 *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const NameConflictLogEventName = "log" + +func (_NameConflict *NameConflict) UnpackLogEvent(log *types.Log) (*NameConflictLog, error) { + event := "log" + if log.Topics[0] != _NameConflict.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(NameConflictLog) + if len(log.Data) > 0 { + if err := _NameConflict.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _NameConflict.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/convertedv1bindtests/numericmethodname.go b/accounts/abi/bind/convertedv1bindtests/numericmethodname.go new file mode 100644 index 000000000000..21e075cd2254 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/numericmethodname.go @@ -0,0 +1,104 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// NumericMethodNameMetaData contains all meta data concerning the NumericMethodName contract. +var NumericMethodNameMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_param\",\"type\":\"address\"}],\"name\":\"_1TestEvent\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"_1test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__1test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__2test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "a691b347afbc44b90dd9a1dfbc65661904", + Bin: "0x6080604052348015600f57600080fd5b5060958061001e6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80639d993132146041578063d02767c7146049578063ffa02795146051575b600080fd5b60476059565b005b604f605b565b005b6057605d565b005b565b565b56fea26469706673582212200382ca602dff96a7e2ba54657985e2b4ac423a56abe4a1f0667bc635c4d4371f64736f6c63430008110033", +} + +// NumericMethodName is an auto generated Go binding around an Ethereum contract. +type NumericMethodName struct { + abi abi.ABI +} + +// NewNumericMethodName creates a new instance of NumericMethodName. +func NewNumericMethodName() (*NumericMethodName, error) { + parsed, err := NumericMethodNameMetaData.GetAbi() + if err != nil { + return nil, err + } + return &NumericMethodName{abi: *parsed}, nil +} + +func (_NumericMethodName *NumericMethodName) PackConstructor() []byte { + res, _ := _NumericMethodName.abi.Pack("") + return res +} + +// E1test is a free data retrieval call binding the contract method 0xffa02795. +// +// Solidity: function _1test() pure returns() +func (_NumericMethodName *NumericMethodName) PackE1test() ([]byte, error) { + return _NumericMethodName.abi.Pack("_1test") +} + +// E1test0 is a free data retrieval call binding the contract method 0xd02767c7. +// +// Solidity: function __1test() pure returns() +func (_NumericMethodName *NumericMethodName) PackE1test0() ([]byte, error) { + return _NumericMethodName.abi.Pack("__1test") +} + +// E2test is a free data retrieval call binding the contract method 0x9d993132. +// +// Solidity: function __2test() pure returns() +func (_NumericMethodName *NumericMethodName) PackE2test() ([]byte, error) { + return _NumericMethodName.abi.Pack("__2test") +} + +// NumericMethodNameE1TestEvent represents a E1TestEvent event raised by the NumericMethodName contract. +type NumericMethodNameE1TestEvent struct { + Param common.Address + Raw *types.Log // Blockchain specific contextual infos +} + +const NumericMethodNameE1TestEventEventName = "_1TestEvent" + +func (_NumericMethodName *NumericMethodName) UnpackE1TestEventEvent(log *types.Log) (*NumericMethodNameE1TestEvent, error) { + event := "_1TestEvent" + if log.Topics[0] != _NumericMethodName.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(NumericMethodNameE1TestEvent) + if len(log.Data) > 0 { + if err := _NumericMethodName.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _NumericMethodName.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/convertedv1bindtests/outputchecker.go b/accounts/abi/bind/convertedv1bindtests/outputchecker.go new file mode 100644 index 000000000000..b1487461add2 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/outputchecker.go @@ -0,0 +1,205 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// OutputCheckerMetaData contains all meta data concerning the OutputChecker contract. +var OutputCheckerMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"noOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"anonOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"namedOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str1\",\"type\":\"string\"},{\"name\":\"str2\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"collidingOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str\",\"type\":\"string\"},{\"name\":\"Str\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"anonOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"mixedOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"str\",\"type\":\"string\"}]}]", + Pattern: "cc1d4e235801a590b506d5130b0cca90a1", +} + +// OutputChecker is an auto generated Go binding around an Ethereum contract. +type OutputChecker struct { + abi abi.ABI +} + +// NewOutputChecker creates a new instance of OutputChecker. +func NewOutputChecker() (*OutputChecker, error) { + parsed, err := OutputCheckerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &OutputChecker{abi: *parsed}, nil +} + +func (_OutputChecker *OutputChecker) PackConstructor() []byte { + res, _ := _OutputChecker.abi.Pack("") + return res +} + +// AnonOutput is a free data retrieval call binding the contract method 0x008bda05. +// +// Solidity: function anonOutput() returns(string) +func (_OutputChecker *OutputChecker) PackAnonOutput() ([]byte, error) { + return _OutputChecker.abi.Pack("anonOutput") +} + +func (_OutputChecker *OutputChecker) UnpackAnonOutput(data []byte) (string, error) { + out, err := _OutputChecker.abi.Unpack("anonOutput", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// AnonOutputs is a free data retrieval call binding the contract method 0x3c401115. +// +// Solidity: function anonOutputs() returns(string, string) +func (_OutputChecker *OutputChecker) PackAnonOutputs() ([]byte, error) { + return _OutputChecker.abi.Pack("anonOutputs") +} + +type AnonOutputsOutput struct { + Arg string + Arg0 string +} + +func (_OutputChecker *OutputChecker) UnpackAnonOutputs(data []byte) (AnonOutputsOutput, error) { + out, err := _OutputChecker.abi.Unpack("anonOutputs", data) + + outstruct := new(AnonOutputsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Arg0 = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// CollidingOutputs is a free data retrieval call binding the contract method 0xeccbc1ee. +// +// Solidity: function collidingOutputs() returns(string str, string Str) +func (_OutputChecker *OutputChecker) PackCollidingOutputs() ([]byte, error) { + return _OutputChecker.abi.Pack("collidingOutputs") +} + +type CollidingOutputsOutput struct { + Str string + Str string +} + +func (_OutputChecker *OutputChecker) UnpackCollidingOutputs(data []byte) (CollidingOutputsOutput, error) { + out, err := _OutputChecker.abi.Unpack("collidingOutputs", data) + + outstruct := new(CollidingOutputsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Str = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Str = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// MixedOutputs is a free data retrieval call binding the contract method 0x21b77b44. +// +// Solidity: function mixedOutputs() returns(string, string str) +func (_OutputChecker *OutputChecker) PackMixedOutputs() ([]byte, error) { + return _OutputChecker.abi.Pack("mixedOutputs") +} + +type MixedOutputsOutput struct { + Arg string + Str string +} + +func (_OutputChecker *OutputChecker) UnpackMixedOutputs(data []byte) (MixedOutputsOutput, error) { + out, err := _OutputChecker.abi.Unpack("mixedOutputs", data) + + outstruct := new(MixedOutputsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Str = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// NamedOutput is a free data retrieval call binding the contract method 0x5e632bd5. +// +// Solidity: function namedOutput() returns(string str) +func (_OutputChecker *OutputChecker) PackNamedOutput() ([]byte, error) { + return _OutputChecker.abi.Pack("namedOutput") +} + +func (_OutputChecker *OutputChecker) UnpackNamedOutput(data []byte) (string, error) { + out, err := _OutputChecker.abi.Unpack("namedOutput", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// NamedOutputs is a free data retrieval call binding the contract method 0x7970a189. +// +// Solidity: function namedOutputs() returns(string str1, string str2) +func (_OutputChecker *OutputChecker) PackNamedOutputs() ([]byte, error) { + return _OutputChecker.abi.Pack("namedOutputs") +} + +type NamedOutputsOutput struct { + Str1 string + Str2 string +} + +func (_OutputChecker *OutputChecker) UnpackNamedOutputs(data []byte) (NamedOutputsOutput, error) { + out, err := _OutputChecker.abi.Unpack("namedOutputs", data) + + outstruct := new(NamedOutputsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Str1 = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Str2 = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// NoOutput is a free data retrieval call binding the contract method 0x625f0306. +// +// Solidity: function noOutput() returns() +func (_OutputChecker *OutputChecker) PackNoOutput() ([]byte, error) { + return _OutputChecker.abi.Pack("noOutput") +} diff --git a/accounts/abi/bind/convertedv1bindtests/overload.go b/accounts/abi/bind/convertedv1bindtests/overload.go new file mode 100644 index 000000000000..93894f34010d --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/overload.go @@ -0,0 +1,130 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// OverloadMetaData contains all meta data concerning the Overload contract. +var OverloadMetaData = &bind.MetaData{ + ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"},{\"name\":\"j\",\"type\":\"uint256\"}],\"name\":\"foo\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"}],\"name\":\"foo\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"i\",\"type\":\"uint256\"}],\"name\":\"bar\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"i\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"j\",\"type\":\"uint256\"}],\"name\":\"bar\",\"type\":\"event\"}]", + Pattern: "f49f0ff7ed407de5c37214f49309072aec", + Bin: "0x608060405234801561001057600080fd5b50610153806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806304bc52f81461003b5780632fbebd3814610073575b600080fd5b6100716004803603604081101561005157600080fd5b8101908080359060200190929190803590602001909291905050506100a1565b005b61009f6004803603602081101561008957600080fd5b81019080803590602001909291905050506100e4565b005b7fae42e9514233792a47a1e4554624e83fe852228e1503f63cd383e8a431f4f46d8282604051808381526020018281526020019250505060405180910390a15050565b7f0423a1321222a0a8716c22b92fac42d85a45a612b696a461784d9fa537c81e5c816040518082815260200191505060405180910390a15056fea265627a7a72305820e22b049858b33291cbe67eeaece0c5f64333e439d27032ea8337d08b1de18fe864736f6c634300050a0032", +} + +// Overload is an auto generated Go binding around an Ethereum contract. +type Overload struct { + abi abi.ABI +} + +// NewOverload creates a new instance of Overload. +func NewOverload() (*Overload, error) { + parsed, err := OverloadMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Overload{abi: *parsed}, nil +} + +func (_Overload *Overload) PackConstructor() []byte { + res, _ := _Overload.abi.Pack("") + return res +} + +// Foo is a free data retrieval call binding the contract method 0x04bc52f8. +// +// Solidity: function foo(uint256 i, uint256 j) returns() +func (_Overload *Overload) PackFoo(i *big.Int, j *big.Int) ([]byte, error) { + return _Overload.abi.Pack("foo", i, j) +} + +// Foo0 is a free data retrieval call binding the contract method 0x2fbebd38. +// +// Solidity: function foo(uint256 i) returns() +func (_Overload *Overload) PackFoo0(i *big.Int) ([]byte, error) { + return _Overload.abi.Pack("foo0", i) +} + +// OverloadBar represents a Bar event raised by the Overload contract. +type OverloadBar struct { + I *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const OverloadBarEventName = "bar" + +func (_Overload *Overload) UnpackBarEvent(log *types.Log) (*OverloadBar, error) { + event := "bar" + if log.Topics[0] != _Overload.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(OverloadBar) + if len(log.Data) > 0 { + if err := _Overload.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Overload.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 +} + +// OverloadBar0 represents a Bar0 event raised by the Overload contract. +type OverloadBar0 struct { + I *big.Int + J *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const OverloadBar0EventName = "bar0" + +func (_Overload *Overload) UnpackBar0Event(log *types.Log) (*OverloadBar0, error) { + event := "bar0" + if log.Topics[0] != _Overload.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(OverloadBar0) + if len(log.Data) > 0 { + if err := _Overload.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Overload.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/convertedv1bindtests/rangekeyword.go b/accounts/abi/bind/convertedv1bindtests/rangekeyword.go new file mode 100644 index 000000000000..e9a957d66c24 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/rangekeyword.go @@ -0,0 +1,58 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// RangeKeywordMetaData contains all meta data concerning the RangeKeyword contract. +var RangeKeywordMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"range\",\"type\":\"uint256\"}],\"name\":\"functionWithKeywordParameter\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "cec8c872ba06feb1b8f0a00e7b237eb226", + Bin: "0x608060405234801561001057600080fd5b5060dc8061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063527a119f14602d575b600080fd5b60436004803603810190603f9190605b565b6045565b005b50565b6000813590506055816092565b92915050565b600060208284031215606e57606d608d565b5b6000607a848285016048565b91505092915050565b6000819050919050565b600080fd5b6099816083565b811460a357600080fd5b5056fea2646970667358221220d4f4525e2615516394055d369fb17df41c359e5e962734f27fd683ea81fd9db164736f6c63430008070033", +} + +// RangeKeyword is an auto generated Go binding around an Ethereum contract. +type RangeKeyword struct { + abi abi.ABI +} + +// NewRangeKeyword creates a new instance of RangeKeyword. +func NewRangeKeyword() (*RangeKeyword, error) { + parsed, err := RangeKeywordMetaData.GetAbi() + if err != nil { + return nil, err + } + return &RangeKeyword{abi: *parsed}, nil +} + +func (_RangeKeyword *RangeKeyword) PackConstructor() []byte { + res, _ := _RangeKeyword.abi.Pack("") + return res +} + +// FunctionWithKeywordParameter is a free data retrieval call binding the contract method 0x527a119f. +// +// Solidity: function functionWithKeywordParameter(uint256 range) pure returns() +func (_RangeKeyword *RangeKeyword) PackFunctionWithKeywordParameter(arg0 *big.Int) ([]byte, error) { + return _RangeKeyword.abi.Pack("functionWithKeywordParameter", arg0) +} diff --git a/accounts/abi/bind/convertedv1bindtests/slicer.go b/accounts/abi/bind/convertedv1bindtests/slicer.go new file mode 100644 index 000000000000..8deb68d012c2 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/slicer.go @@ -0,0 +1,131 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// SlicerMetaData contains all meta data concerning the Slicer contract. +var SlicerMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"address[]\"}],\"name\":\"echoAddresses\",\"outputs\":[{\"name\":\"output\",\"type\":\"address[]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"uint24[23]\"}],\"name\":\"echoFancyInts\",\"outputs\":[{\"name\":\"output\",\"type\":\"uint24[23]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"int256[]\"}],\"name\":\"echoInts\",\"outputs\":[{\"name\":\"output\",\"type\":\"int256[]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"bool[]\"}],\"name\":\"echoBools\",\"outputs\":[{\"name\":\"output\",\"type\":\"bool[]\"}],\"type\":\"function\"}]", + Pattern: "082c0740ab6537c7169cb573d097c52112", + Bin: "0x606060405261015c806100126000396000f3606060405260e060020a6000350463be1127a3811461003c578063d88becc014610092578063e15a3db71461003c578063f637e5891461003c575b005b604080516020600480358082013583810285810185019096528085526100ee959294602494909392850192829185019084908082843750949650505050505050604080516020810190915260009052805b919050565b604080516102e0818101909252610138916004916102e491839060179083908390808284375090955050505050506102e0604051908101604052806017905b60008152602001906001900390816100d15790505081905061008d565b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600f02600301f1509050019250505060405180910390f35b60405180826102e0808381846000600461015cf15090500191505060405180910390f3", +} + +// Slicer is an auto generated Go binding around an Ethereum contract. +type Slicer struct { + abi abi.ABI +} + +// NewSlicer creates a new instance of Slicer. +func NewSlicer() (*Slicer, error) { + parsed, err := SlicerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Slicer{abi: *parsed}, nil +} + +func (_Slicer *Slicer) PackConstructor() []byte { + res, _ := _Slicer.abi.Pack("") + return res +} + +// EchoAddresses is a free data retrieval call binding the contract method 0xbe1127a3. +// +// Solidity: function echoAddresses(address[] input) returns(address[] output) +func (_Slicer *Slicer) PackEchoAddresses(input []common.Address) ([]byte, error) { + return _Slicer.abi.Pack("echoAddresses", input) +} + +func (_Slicer *Slicer) UnpackEchoAddresses(data []byte) ([]common.Address, error) { + out, err := _Slicer.abi.Unpack("echoAddresses", data) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// EchoBools is a free data retrieval call binding the contract method 0xf637e589. +// +// Solidity: function echoBools(bool[] input) returns(bool[] output) +func (_Slicer *Slicer) PackEchoBools(input []bool) ([]byte, error) { + return _Slicer.abi.Pack("echoBools", input) +} + +func (_Slicer *Slicer) UnpackEchoBools(data []byte) ([]bool, error) { + out, err := _Slicer.abi.Unpack("echoBools", data) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// EchoFancyInts is a free data retrieval call binding the contract method 0xd88becc0. +// +// Solidity: function echoFancyInts(uint24[23] input) returns(uint24[23] output) +func (_Slicer *Slicer) PackEchoFancyInts(input [23]*big.Int) ([]byte, error) { + return _Slicer.abi.Pack("echoFancyInts", input) +} + +func (_Slicer *Slicer) UnpackEchoFancyInts(data []byte) ([23]*big.Int, error) { + out, err := _Slicer.abi.Unpack("echoFancyInts", data) + + if err != nil { + return *new([23]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([23]*big.Int)).(*[23]*big.Int) + + return out0, err + +} + +// EchoInts is a free data retrieval call binding the contract method 0xe15a3db7. +// +// Solidity: function echoInts(int256[] input) returns(int256[] output) +func (_Slicer *Slicer) PackEchoInts(input []*big.Int) ([]byte, error) { + return _Slicer.abi.Pack("echoInts", input) +} + +func (_Slicer *Slicer) UnpackEchoInts(data []byte) ([]*big.Int, error) { + out, err := _Slicer.abi.Unpack("echoInts", 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/convertedv1bindtests/structs.go b/accounts/abi/bind/convertedv1bindtests/structs.go new file mode 100644 index 000000000000..0e0d116fa6bb --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/structs.go @@ -0,0 +1,105 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// Struct0 is an auto generated low-level Go binding around an user-defined struct. +type Struct0 struct { + B [32]byte +} + +// TODO: convert this type to value type after everything works. +// StructsMetaData contains all meta data concerning the Structs contract. +var StructsMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"F\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"c\",\"type\":\"uint256[]\"},{\"internalType\":\"bool[]\",\"name\":\"d\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"G\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Pattern: "920a35318e7581766aec7a17218628a91d", + Bin: "0x608060405234801561001057600080fd5b50610278806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806328811f591461003b5780636fecb6231461005b575b600080fd5b610043610070565b604051610052939291906101a0565b60405180910390f35b6100636100d6565b6040516100529190610186565b604080516002808252606082810190935282918291829190816020015b610095610131565b81526020019060019003908161008d575050805190915061026960611b9082906000906100be57fe5b60209081029190910101515293606093508392509050565b6040805160028082526060828101909352829190816020015b6100f7610131565b8152602001906001900390816100ef575050805190915061026960611b90829060009061012057fe5b602090810291909101015152905090565b60408051602081019091526000815290565b815260200190565b6000815180845260208085019450808401835b8381101561017b578151518752958201959082019060010161015e565b509495945050505050565b600060208252610199602083018461014b565b9392505050565b6000606082526101b3606083018661014b565b6020838203818501528186516101c98185610239565b91508288019350845b818110156101f3576101e5838651610143565b9484019492506001016101d2565b505084810360408601528551808252908201925081860190845b8181101561022b57825115158552938301939183019160010161020d565b509298975050505050505050565b9081526020019056fea2646970667358221220eb85327e285def14230424c52893aebecec1e387a50bb6b75fc4fdbed647f45f64736f6c63430006050033", +} + +// Structs is an auto generated Go binding around an Ethereum contract. +type Structs struct { + abi abi.ABI +} + +// NewStructs creates a new instance of Structs. +func NewStructs() (*Structs, error) { + parsed, err := StructsMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Structs{abi: *parsed}, nil +} + +func (_Structs *Structs) PackConstructor() []byte { + res, _ := _Structs.abi.Pack("") + return res +} + +// F is a free data retrieval call binding the contract method 0x28811f59. +// +// Solidity: function F() view returns((bytes32)[] a, uint256[] c, bool[] d) +func (_Structs *Structs) PackF() ([]byte, error) { + return _Structs.abi.Pack("F") +} + +type FOutput struct { + A []Struct0 + C []*big.Int + D []bool +} + +func (_Structs *Structs) UnpackF(data []byte) (FOutput, error) { + out, err := _Structs.abi.Unpack("F", data) + + outstruct := new(FOutput) + if err != nil { + return *outstruct, err + } + + outstruct.A = *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0) + outstruct.C = *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int) + outstruct.D = *abi.ConvertType(out[2], new([]bool)).(*[]bool) + + return *outstruct, err + +} + +// G is a free data retrieval call binding the contract method 0x6fecb623. +// +// Solidity: function G() view returns((bytes32)[] a) +func (_Structs *Structs) PackG() ([]byte, error) { + return _Structs.abi.Pack("G") +} + +func (_Structs *Structs) UnpackG(data []byte) ([]Struct0, error) { + out, err := _Structs.abi.Unpack("G", data) + + if err != nil { + return *new([]Struct0), err + } + + out0 := *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0) + + return out0, err + +} diff --git a/accounts/abi/bind/convertedv1bindtests/token.go b/accounts/abi/bind/convertedv1bindtests/token.go new file mode 100644 index 000000000000..27452999bd71 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/token.go @@ -0,0 +1,252 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// TokenMetaData contains all meta data concerning the Token contract. +var TokenMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"},{\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"spentAllowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"inputs\":[{\"name\":\"initialSupply\",\"type\":\"uint256\"},{\"name\":\"tokenName\",\"type\":\"string\"},{\"name\":\"decimalUnits\",\"type\":\"uint8\"},{\"name\":\"tokenSymbol\",\"type\":\"string\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]", + Pattern: "1317f51c845ce3bfb7c268e5337a825f12", + Bin: "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", +} + +// Token is an auto generated Go binding around an Ethereum contract. +type Token struct { + abi abi.ABI +} + +// NewToken creates a new instance of Token. +func NewToken() (*Token, error) { + parsed, err := TokenMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Token{abi: *parsed}, nil +} + +func (_Token *Token) PackConstructor(initialSupply *big.Int, tokenName string, decimalUnits uint8, tokenSymbol string) []byte { + res, _ := _Token.abi.Pack("", initialSupply, tokenName, decimalUnits, tokenSymbol) + return res +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address , address ) returns(uint256) +func (_Token *Token) PackAllowance(arg0 common.Address, arg1 common.Address) ([]byte, error) { + return _Token.abi.Pack("allowance", arg0, arg1) +} + +func (_Token *Token) UnpackAllowance(data []byte) (*big.Int, error) { + out, err := _Token.abi.Unpack("allowance", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ApproveAndCall is a free data retrieval call binding the contract method 0xcae9ca51. +// +// Solidity: function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns(bool success) +func (_Token *Token) PackApproveAndCall(_spender common.Address, _value *big.Int, _extraData []byte) ([]byte, error) { + return _Token.abi.Pack("approveAndCall", _spender, _value, _extraData) +} + +func (_Token *Token) UnpackApproveAndCall(data []byte) (bool, error) { + out, err := _Token.abi.Unpack("approveAndCall", data) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address ) returns(uint256) +func (_Token *Token) PackBalanceOf(arg0 common.Address) ([]byte, error) { + return _Token.abi.Pack("balanceOf", arg0) +} + +func (_Token *Token) UnpackBalanceOf(data []byte) (*big.Int, error) { + out, err := _Token.abi.Unpack("balanceOf", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() returns(uint8) +func (_Token *Token) PackDecimals() ([]byte, error) { + return _Token.abi.Pack("decimals") +} + +func (_Token *Token) UnpackDecimals(data []byte) (uint8, error) { + out, err := _Token.abi.Unpack("decimals", data) + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() returns(string) +func (_Token *Token) PackName() ([]byte, error) { + return _Token.abi.Pack("name") +} + +func (_Token *Token) UnpackName(data []byte) (string, error) { + out, err := _Token.abi.Unpack("name", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// SpentAllowance is a free data retrieval call binding the contract method 0xdc3080f2. +// +// Solidity: function spentAllowance(address , address ) returns(uint256) +func (_Token *Token) PackSpentAllowance(arg0 common.Address, arg1 common.Address) ([]byte, error) { + return _Token.abi.Pack("spentAllowance", arg0, arg1) +} + +func (_Token *Token) UnpackSpentAllowance(data []byte) (*big.Int, error) { + out, err := _Token.abi.Unpack("spentAllowance", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() returns(string) +func (_Token *Token) PackSymbol() ([]byte, error) { + return _Token.abi.Pack("symbol") +} + +func (_Token *Token) UnpackSymbol(data []byte) (string, error) { + out, err := _Token.abi.Unpack("symbol", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Transfer is a free data retrieval call binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_Token *Token) PackTransfer(_to common.Address, _value *big.Int) ([]byte, error) { + return _Token.abi.Pack("transfer", _to, _value) +} + +// TransferFrom is a free data retrieval call binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success) +func (_Token *Token) PackTransferFrom(_from common.Address, _to common.Address, _value *big.Int) ([]byte, error) { + return _Token.abi.Pack("transferFrom", _from, _to, _value) +} + +func (_Token *Token) UnpackTransferFrom(data []byte) (bool, error) { + out, err := _Token.abi.Unpack("transferFrom", data) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// TokenTransfer represents a Transfer event raised by the Token contract. +type TokenTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const TokenTransferEventName = "Transfer" + +func (_Token *Token) UnpackTransferEvent(log *types.Log) (*TokenTransfer, error) { + event := "Transfer" + if log.Topics[0] != _Token.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(TokenTransfer) + if len(log.Data) > 0 { + if err := _Token.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Token.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/convertedv1bindtests/tuple.go b/accounts/abi/bind/convertedv1bindtests/tuple.go new file mode 100644 index 000000000000..602a3d8887c7 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/tuple.go @@ -0,0 +1,191 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TupleP is an auto generated low-level Go binding around an user-defined struct. +type TupleP struct { + X uint8 + Y uint8 +} + +// TupleQ is an auto generated low-level Go binding around an user-defined struct. +type TupleQ struct { + X uint16 + Y uint16 +} + +// TupleS is an auto generated low-level Go binding around an user-defined struct. +type TupleS struct { + A *big.Int + B []*big.Int + C []TupleT +} + +// TupleT is an auto generated low-level Go binding around an user-defined struct. +type TupleT struct { + X *big.Int + Y *big.Int +} + +// TODO: convert this type to value type after everything works. +// TupleMetaData contains all meta data concerning the Tuple contract. +var TupleMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"indexed\":false,\"internalType\":\"structTuple.S\",\"name\":\"a\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"structTuple.T[2][]\",\"name\":\"b\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"structTuple.T[][2]\",\"name\":\"c\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"indexed\":false,\"internalType\":\"structTuple.S[]\",\"name\":\"d\",\"type\":\"tuple[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"e\",\"type\":\"uint256[]\"}],\"name\":\"TupleEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"x\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"y\",\"type\":\"uint8\"}],\"indexed\":false,\"internalType\":\"structTuple.P[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"name\":\"TupleEvent2\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S\",\"name\":\"a\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[2][]\",\"name\":\"b\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[][2]\",\"name\":\"c\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S[]\",\"name\":\"d\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"e\",\"type\":\"uint256[]\"}],\"name\":\"func1\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S\",\"name\":\"\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[2][]\",\"name\":\"\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[][2]\",\"name\":\"\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S[]\",\"name\":\"\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S\",\"name\":\"a\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[2][]\",\"name\":\"b\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[][2]\",\"name\":\"c\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S[]\",\"name\":\"d\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"e\",\"type\":\"uint256[]\"}],\"name\":\"func2\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"y\",\"type\":\"uint16\"}],\"internalType\":\"structTuple.Q[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"name\":\"func3\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "96ee1e2b1b89f8c495f200e4956278a4d4", + Bin: "0x60806040523480156100115760006000fd5b50610017565b6110b2806100266000396000f3fe60806040523480156100115760006000fd5b50600436106100465760003560e01c8063443c79b41461004c578063d0062cdd14610080578063e4d9a43b1461009c57610046565b60006000fd5b610066600480360361006191908101906107b8565b6100b8565b604051610077959493929190610ccb565b60405180910390f35b61009a600480360361009591908101906107b8565b6100ef565b005b6100b660048036036100b19190810190610775565b610136565b005b6100c061013a565b60606100ca61015e565b606060608989898989945094509450945094506100e2565b9550955095509550959050565b7f18d6e66efa53739ca6d13626f35ebc700b31cced3eddb50c70bbe9c082c6cd008585858585604051610126959493929190610ccb565b60405180910390a15b5050505050565b5b50565b60405180606001604052806000815260200160608152602001606081526020015090565b60405180604001604052806002905b606081526020019060019003908161016d57905050905661106e565b600082601f830112151561019d5760006000fd5b81356101b06101ab82610d6f565b610d41565b915081818352602084019350602081019050838560808402820111156101d65760006000fd5b60005b8381101561020757816101ec888261037a565b8452602084019350608083019250505b6001810190506101d9565b5050505092915050565b600082601f83011215156102255760006000fd5b600261023861023382610d98565b610d41565b9150818360005b83811015610270578135860161025588826103f3565b8452602084019350602083019250505b60018101905061023f565b5050505092915050565b600082601f830112151561028e5760006000fd5b81356102a161029c82610dbb565b610d41565b915081818352602084019350602081019050838560408402820111156102c75760006000fd5b60005b838110156102f857816102dd888261058b565b8452602084019350604083019250505b6001810190506102ca565b5050505092915050565b600082601f83011215156103165760006000fd5b813561032961032482610de4565b610d41565b9150818183526020840193506020810190508360005b83811015610370578135860161035588826105d8565b8452602084019350602083019250505b60018101905061033f565b5050505092915050565b600082601f830112151561038e5760006000fd5b60026103a161039c82610e0d565b610d41565b915081838560408402820111156103b85760006000fd5b60005b838110156103e957816103ce88826106fe565b8452602084019350604083019250505b6001810190506103bb565b5050505092915050565b600082601f83011215156104075760006000fd5b813561041a61041582610e30565b610d41565b915081818352602084019350602081019050838560408402820111156104405760006000fd5b60005b83811015610471578161045688826106fe565b8452602084019350604083019250505b600181019050610443565b5050505092915050565b600082601f830112151561048f5760006000fd5b81356104a261049d82610e59565b610d41565b915081818352602084019350602081019050838560208402820111156104c85760006000fd5b60005b838110156104f957816104de8882610760565b8452602084019350602083019250505b6001810190506104cb565b5050505092915050565b600082601f83011215156105175760006000fd5b813561052a61052582610e82565b610d41565b915081818352602084019350602081019050838560208402820111156105505760006000fd5b60005b8381101561058157816105668882610760565b8452602084019350602083019250505b600181019050610553565b5050505092915050565b60006040828403121561059e5760006000fd5b6105a86040610d41565b905060006105b88482850161074b565b60008301525060206105cc8482850161074b565b60208301525092915050565b6000606082840312156105eb5760006000fd5b6105f56060610d41565b9050600061060584828501610760565b600083015250602082013567ffffffffffffffff8111156106265760006000fd5b6106328482850161047b565b602083015250604082013567ffffffffffffffff8111156106535760006000fd5b61065f848285016103f3565b60408301525092915050565b60006060828403121561067e5760006000fd5b6106886060610d41565b9050600061069884828501610760565b600083015250602082013567ffffffffffffffff8111156106b95760006000fd5b6106c58482850161047b565b602083015250604082013567ffffffffffffffff8111156106e65760006000fd5b6106f2848285016103f3565b60408301525092915050565b6000604082840312156107115760006000fd5b61071b6040610d41565b9050600061072b84828501610760565b600083015250602061073f84828501610760565b60208301525092915050565b60008135905061075a8161103a565b92915050565b60008135905061076f81611054565b92915050565b6000602082840312156107885760006000fd5b600082013567ffffffffffffffff8111156107a35760006000fd5b6107af8482850161027a565b91505092915050565b6000600060006000600060a086880312156107d35760006000fd5b600086013567ffffffffffffffff8111156107ee5760006000fd5b6107fa8882890161066b565b955050602086013567ffffffffffffffff8111156108185760006000fd5b61082488828901610189565b945050604086013567ffffffffffffffff8111156108425760006000fd5b61084e88828901610211565b935050606086013567ffffffffffffffff81111561086c5760006000fd5b61087888828901610302565b925050608086013567ffffffffffffffff8111156108965760006000fd5b6108a288828901610503565b9150509295509295909350565b60006108bb8383610a6a565b60808301905092915050565b60006108d38383610ac2565b905092915050565b60006108e78383610c36565b905092915050565b60006108fb8383610c8d565b60408301905092915050565b60006109138383610cbc565b60208301905092915050565b600061092a82610f0f565b6109348185610fb7565b935061093f83610eab565b8060005b8381101561097157815161095788826108af565b975061096283610f5c565b9250505b600181019050610943565b5085935050505092915050565b600061098982610f1a565b6109938185610fc8565b9350836020820285016109a585610ebb565b8060005b858110156109e257848403895281516109c285826108c7565b94506109cd83610f69565b925060208a019950505b6001810190506109a9565b50829750879550505050505092915050565b60006109ff82610f25565b610a098185610fd3565b935083602082028501610a1b85610ec5565b8060005b85811015610a585784840389528151610a3885826108db565b9450610a4383610f76565b925060208a019950505b600181019050610a1f565b50829750879550505050505092915050565b610a7381610f30565b610a7d8184610fe4565b9250610a8882610ed5565b8060005b83811015610aba578151610aa087826108ef565b9650610aab83610f83565b9250505b600181019050610a8c565b505050505050565b6000610acd82610f3b565b610ad78185610fef565b9350610ae283610edf565b8060005b83811015610b14578151610afa88826108ef565b9750610b0583610f90565b9250505b600181019050610ae6565b5085935050505092915050565b6000610b2c82610f51565b610b368185611011565b9350610b4183610eff565b8060005b83811015610b73578151610b598882610907565b9750610b6483610faa565b9250505b600181019050610b45565b5085935050505092915050565b6000610b8b82610f46565b610b958185611000565b9350610ba083610eef565b8060005b83811015610bd2578151610bb88882610907565b9750610bc383610f9d565b9250505b600181019050610ba4565b5085935050505092915050565b6000606083016000830151610bf76000860182610cbc565b5060208301518482036020860152610c0f8282610b80565b91505060408301518482036040860152610c298282610ac2565b9150508091505092915050565b6000606083016000830151610c4e6000860182610cbc565b5060208301518482036020860152610c668282610b80565b91505060408301518482036040860152610c808282610ac2565b9150508091505092915050565b604082016000820151610ca36000850182610cbc565b506020820151610cb66020850182610cbc565b50505050565b610cc581611030565b82525050565b600060a0820190508181036000830152610ce58188610bdf565b90508181036020830152610cf9818761091f565b90508181036040830152610d0d818661097e565b90508181036060830152610d2181856109f4565b90508181036080830152610d358184610b21565b90509695505050505050565b6000604051905081810181811067ffffffffffffffff82111715610d655760006000fd5b8060405250919050565b600067ffffffffffffffff821115610d875760006000fd5b602082029050602081019050919050565b600067ffffffffffffffff821115610db05760006000fd5b602082029050919050565b600067ffffffffffffffff821115610dd35760006000fd5b602082029050602081019050919050565b600067ffffffffffffffff821115610dfc5760006000fd5b602082029050602081019050919050565b600067ffffffffffffffff821115610e255760006000fd5b602082029050919050565b600067ffffffffffffffff821115610e485760006000fd5b602082029050602081019050919050565b600067ffffffffffffffff821115610e715760006000fd5b602082029050602081019050919050565b600067ffffffffffffffff821115610e9a5760006000fd5b602082029050602081019050919050565b6000819050602082019050919050565b6000819050919050565b6000819050602082019050919050565b6000819050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600060029050919050565b600081519050919050565b600060029050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600061ffff82169050919050565b6000819050919050565b61104381611022565b811415156110515760006000fd5b50565b61105d81611030565b8114151561106b5760006000fd5b50565bfea365627a7a72315820d78c6ba7ee332581e6c4d9daa5fc07941841230f7ce49edf6e05b1b63853e8746c6578706572696d656e74616cf564736f6c634300050c0040", +} + +// Tuple is an auto generated Go binding around an Ethereum contract. +type Tuple struct { + abi abi.ABI +} + +// NewTuple creates a new instance of Tuple. +func NewTuple() (*Tuple, error) { + parsed, err := TupleMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Tuple{abi: *parsed}, nil +} + +func (_Tuple *Tuple) PackConstructor() []byte { + res, _ := _Tuple.abi.Pack("") + return res +} + +// Func1 is a free data retrieval call binding the contract method 0x443c79b4. +// +// Solidity: function func1((uint256,uint256[],(uint256,uint256)[]) a, (uint256,uint256)[2][] b, (uint256,uint256)[][2] c, (uint256,uint256[],(uint256,uint256)[])[] d, uint256[] e) pure returns((uint256,uint256[],(uint256,uint256)[]), (uint256,uint256)[2][], (uint256,uint256)[][2], (uint256,uint256[],(uint256,uint256)[])[], uint256[]) +func (_Tuple *Tuple) PackFunc1(a TupleS, b [][2]TupleT, c [2][]TupleT, d []TupleS, e []*big.Int) ([]byte, error) { + return _Tuple.abi.Pack("func1", a, b, c, d, e) +} + +type Func1Output struct { + Arg TupleS + Arg0 [][2]TupleT + Arg1 [2][]TupleT + Arg2 []TupleS + Arg3 []*big.Int +} + +func (_Tuple *Tuple) UnpackFunc1(data []byte) (Func1Output, error) { + out, err := _Tuple.abi.Unpack("func1", data) + + outstruct := new(Func1Output) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(TupleS)).(*TupleS) + outstruct.Arg0 = *abi.ConvertType(out[1], new([][2]TupleT)).(*[][2]TupleT) + outstruct.Arg1 = *abi.ConvertType(out[2], new([2][]TupleT)).(*[2][]TupleT) + outstruct.Arg2 = *abi.ConvertType(out[3], new([]TupleS)).(*[]TupleS) + outstruct.Arg3 = *abi.ConvertType(out[4], new([]*big.Int)).(*[]*big.Int) + + return *outstruct, err + +} + +// Func2 is a free data retrieval call binding the contract method 0xd0062cdd. +// +// Solidity: function func2((uint256,uint256[],(uint256,uint256)[]) a, (uint256,uint256)[2][] b, (uint256,uint256)[][2] c, (uint256,uint256[],(uint256,uint256)[])[] d, uint256[] e) returns() +func (_Tuple *Tuple) PackFunc2(a TupleS, b [][2]TupleT, c [2][]TupleT, d []TupleS, e []*big.Int) ([]byte, error) { + return _Tuple.abi.Pack("func2", a, b, c, d, e) +} + +// Func3 is a free data retrieval call binding the contract method 0xe4d9a43b. +// +// Solidity: function func3((uint16,uint16)[] ) pure returns() +func (_Tuple *Tuple) PackFunc3(arg0 []TupleQ) ([]byte, error) { + return _Tuple.abi.Pack("func3", arg0) +} + +// TupleTupleEvent represents a TupleEvent event raised by the Tuple contract. +type TupleTupleEvent struct { + A TupleS + B [][2]TupleT + C [2][]TupleT + D []TupleS + E []*big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const TupleTupleEventEventName = "TupleEvent" + +func (_Tuple *Tuple) UnpackTupleEventEvent(log *types.Log) (*TupleTupleEvent, error) { + event := "TupleEvent" + if log.Topics[0] != _Tuple.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(TupleTupleEvent) + if len(log.Data) > 0 { + if err := _Tuple.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Tuple.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 +} + +// TupleTupleEvent2 represents a TupleEvent2 event raised by the Tuple contract. +type TupleTupleEvent2 struct { + Arg0 []TupleP + Raw *types.Log // Blockchain specific contextual infos +} + +const TupleTupleEvent2EventName = "TupleEvent2" + +func (_Tuple *Tuple) UnpackTupleEvent2Event(log *types.Log) (*TupleTupleEvent2, error) { + event := "TupleEvent2" + if log.Topics[0] != _Tuple.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(TupleTupleEvent2) + if len(log.Data) > 0 { + if err := _Tuple.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Tuple.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/convertedv1bindtests/tupler.go b/accounts/abi/bind/convertedv1bindtests/tupler.go new file mode 100644 index 000000000000..d315611b3f16 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/tupler.go @@ -0,0 +1,80 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// TuplerMetaData contains all meta data concerning the Tupler contract. +var TuplerMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"tuple\",\"outputs\":[{\"name\":\"a\",\"type\":\"string\"},{\"name\":\"b\",\"type\":\"int256\"},{\"name\":\"c\",\"type\":\"bytes32\"}],\"type\":\"function\"}]", + Pattern: "a8f4d2061f55c712cfae266c426a1cd568", + Bin: "0x606060405260dc8060106000396000f3606060405260e060020a60003504633175aae28114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3", +} + +// Tupler is an auto generated Go binding around an Ethereum contract. +type Tupler struct { + abi abi.ABI +} + +// NewTupler creates a new instance of Tupler. +func NewTupler() (*Tupler, error) { + parsed, err := TuplerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Tupler{abi: *parsed}, nil +} + +func (_Tupler *Tupler) PackConstructor() []byte { + res, _ := _Tupler.abi.Pack("") + return res +} + +// Tuple is a free data retrieval call binding the contract method 0x3175aae2. +// +// Solidity: function tuple() returns(string a, int256 b, bytes32 c) +func (_Tupler *Tupler) PackTuple() ([]byte, error) { + return _Tupler.abi.Pack("tuple") +} + +type TupleOutput struct { + A string + B *big.Int + C [32]byte +} + +func (_Tupler *Tupler) UnpackTuple(data []byte) (TupleOutput, error) { + out, err := _Tupler.abi.Unpack("tuple", data) + + outstruct := new(TupleOutput) + if err != nil { + return *outstruct, err + } + + outstruct.A = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.B = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.C = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} diff --git a/accounts/abi/bind/convertedv1bindtests/underscorer.go b/accounts/abi/bind/convertedv1bindtests/underscorer.go new file mode 100644 index 000000000000..0ad5c5e3e951 --- /dev/null +++ b/accounts/abi/bind/convertedv1bindtests/underscorer.go @@ -0,0 +1,260 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// UnderscorerMetaData contains all meta data concerning the Underscorer contract. +var UnderscorerMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"LowerUpperCollision\",\"outputs\":[{\"name\":\"_res\",\"type\":\"int256\"},{\"name\":\"Res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_under_scored_func\",\"outputs\":[{\"name\":\"_int\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UnderscoredOutput\",\"outputs\":[{\"name\":\"_int\",\"type\":\"int256\"},{\"name\":\"_string\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"PurelyUnderscoredOutput\",\"outputs\":[{\"name\":\"_\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UpperLowerCollision\",\"outputs\":[{\"name\":\"_Res\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"AllPurelyUnderscoredOutput\",\"outputs\":[{\"name\":\"_\",\"type\":\"int256\"},{\"name\":\"__\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UpperUpperCollision\",\"outputs\":[{\"name\":\"_Res\",\"type\":\"int256\"},{\"name\":\"Res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"LowerLowerCollision\",\"outputs\":[{\"name\":\"_res\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", + Pattern: "5873a90ab43c925dfced86ad53f871f01d", + Bin: "0x6060604052341561000f57600080fd5b6103858061001e6000396000f30060606040526004361061008e576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806303a592131461009357806346546dbe146100c357806367e6633d146100ec5780639df4848514610181578063af7486ab146101b1578063b564b34d146101e1578063e02ab24d14610211578063e409ca4514610241575b600080fd5b341561009e57600080fd5b6100a6610271565b604051808381526020018281526020019250505060405180910390f35b34156100ce57600080fd5b6100d6610286565b6040518082815260200191505060405180910390f35b34156100f757600080fd5b6100ff61028e565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561014557808201518184015260208101905061012a565b50505050905090810190601f1680156101725780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561018c57600080fd5b6101946102dc565b604051808381526020018281526020019250505060405180910390f35b34156101bc57600080fd5b6101c46102f1565b604051808381526020018281526020019250505060405180910390f35b34156101ec57600080fd5b6101f4610306565b604051808381526020018281526020019250505060405180910390f35b341561021c57600080fd5b61022461031b565b604051808381526020018281526020019250505060405180910390f35b341561024c57600080fd5b610254610330565b604051808381526020018281526020019250505060405180910390f35b60008060016002819150809050915091509091565b600080905090565b6000610298610345565b61013a8090506040805190810160405280600281526020017f7069000000000000000000000000000000000000000000000000000000000000815250915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b6020604051908101604052806000815250905600a165627a7a72305820d1a53d9de9d1e3d55cb3dc591900b63c4f1ded79114f7b79b332684840e186a40029", +} + +// Underscorer is an auto generated Go binding around an Ethereum contract. +type Underscorer struct { + abi abi.ABI +} + +// NewUnderscorer creates a new instance of Underscorer. +func NewUnderscorer() (*Underscorer, error) { + parsed, err := UnderscorerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Underscorer{abi: *parsed}, nil +} + +func (_Underscorer *Underscorer) PackConstructor() []byte { + res, _ := _Underscorer.abi.Pack("") + return res +} + +// AllPurelyUnderscoredOutput is a free data retrieval call binding the contract method 0xb564b34d. +// +// Solidity: function AllPurelyUnderscoredOutput() view returns(int256 _, int256 __) +func (_Underscorer *Underscorer) PackAllPurelyUnderscoredOutput() ([]byte, error) { + return _Underscorer.abi.Pack("AllPurelyUnderscoredOutput") +} + +type AllPurelyUnderscoredOutputOutput struct { + Arg *big.Int + Arg0 *big.Int +} + +func (_Underscorer *Underscorer) UnpackAllPurelyUnderscoredOutput(data []byte) (AllPurelyUnderscoredOutputOutput, error) { + out, err := _Underscorer.abi.Unpack("AllPurelyUnderscoredOutput", data) + + outstruct := new(AllPurelyUnderscoredOutputOutput) + 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) + + return *outstruct, err + +} + +// LowerLowerCollision is a free data retrieval call binding the contract method 0xe409ca45. +// +// Solidity: function LowerLowerCollision() view returns(int256 _res, int256 res) +func (_Underscorer *Underscorer) PackLowerLowerCollision() ([]byte, error) { + return _Underscorer.abi.Pack("LowerLowerCollision") +} + +type LowerLowerCollisionOutput struct { + Res *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackLowerLowerCollision(data []byte) (LowerLowerCollisionOutput, error) { + out, err := _Underscorer.abi.Unpack("LowerLowerCollision", data) + + outstruct := new(LowerLowerCollisionOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// LowerUpperCollision is a free data retrieval call binding the contract method 0x03a59213. +// +// Solidity: function LowerUpperCollision() view returns(int256 _res, int256 Res) +func (_Underscorer *Underscorer) PackLowerUpperCollision() ([]byte, error) { + return _Underscorer.abi.Pack("LowerUpperCollision") +} + +type LowerUpperCollisionOutput struct { + Res *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackLowerUpperCollision(data []byte) (LowerUpperCollisionOutput, error) { + out, err := _Underscorer.abi.Unpack("LowerUpperCollision", data) + + outstruct := new(LowerUpperCollisionOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// PurelyUnderscoredOutput is a free data retrieval call binding the contract method 0x9df48485. +// +// Solidity: function PurelyUnderscoredOutput() view returns(int256 _, int256 res) +func (_Underscorer *Underscorer) PackPurelyUnderscoredOutput() ([]byte, error) { + return _Underscorer.abi.Pack("PurelyUnderscoredOutput") +} + +type PurelyUnderscoredOutputOutput struct { + Arg *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackPurelyUnderscoredOutput(data []byte) (PurelyUnderscoredOutputOutput, error) { + out, err := _Underscorer.abi.Unpack("PurelyUnderscoredOutput", data) + + outstruct := new(PurelyUnderscoredOutputOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// UnderscoredOutput is a free data retrieval call binding the contract method 0x67e6633d. +// +// Solidity: function UnderscoredOutput() view returns(int256 _int, string _string) +func (_Underscorer *Underscorer) PackUnderscoredOutput() ([]byte, error) { + return _Underscorer.abi.Pack("UnderscoredOutput") +} + +type UnderscoredOutputOutput struct { + Int *big.Int + String string +} + +func (_Underscorer *Underscorer) UnpackUnderscoredOutput(data []byte) (UnderscoredOutputOutput, error) { + out, err := _Underscorer.abi.Unpack("UnderscoredOutput", data) + + outstruct := new(UnderscoredOutputOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Int = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.String = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// UpperLowerCollision is a free data retrieval call binding the contract method 0xaf7486ab. +// +// Solidity: function UpperLowerCollision() view returns(int256 _Res, int256 res) +func (_Underscorer *Underscorer) PackUpperLowerCollision() ([]byte, error) { + return _Underscorer.abi.Pack("UpperLowerCollision") +} + +type UpperLowerCollisionOutput struct { + Res *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackUpperLowerCollision(data []byte) (UpperLowerCollisionOutput, error) { + out, err := _Underscorer.abi.Unpack("UpperLowerCollision", data) + + outstruct := new(UpperLowerCollisionOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// UpperUpperCollision is a free data retrieval call binding the contract method 0xe02ab24d. +// +// Solidity: function UpperUpperCollision() view returns(int256 _Res, int256 Res) +func (_Underscorer *Underscorer) PackUpperUpperCollision() ([]byte, error) { + return _Underscorer.abi.Pack("UpperUpperCollision") +} + +type UpperUpperCollisionOutput struct { + Res *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackUpperUpperCollision(data []byte) (UpperUpperCollisionOutput, error) { + out, err := _Underscorer.abi.Unpack("UpperUpperCollision", data) + + outstruct := new(UpperUpperCollisionOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// UnderScoredFunc is a free data retrieval call binding the contract method 0x46546dbe. +// +// Solidity: function _under_scored_func() view returns(int256 _int) +func (_Underscorer *Underscorer) PackUnderScoredFunc() ([]byte, error) { + return _Underscorer.abi.Pack("_under_scored_func") +} + +func (_Underscorer *Underscorer) UnpackUnderScoredFunc(data []byte) (*big.Int, error) { + out, err := _Underscorer.abi.Unpack("_under_scored_func", 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/source2.go.tpl b/accounts/abi/bind/source2.go.tpl index 29c53f51a117..c51a8a6d0f6b 100644 --- a/accounts/abi/bind/source2.go.tpl +++ b/accounts/abi/bind/source2.go.tpl @@ -64,8 +64,9 @@ var ( return &{{.Type}}{abi: *parsed}, nil } - func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}} {{.Name}} {{bindtype .Type $structs}}, {{end}}) ([]byte, error) { - return _{{$contract.Type}}.abi.Pack("" {{range .Constructor.Inputs}}, {{.Name}}{{end}}) + func (_{{$contract.Type}} *{{$contract.Type}}) PackConstructor({{range .Constructor.Inputs}} {{.Name}} {{bindtype .Type $structs}}, {{end}}) []byte { + res, _ := _{{$contract.Type}}.abi.Pack("" {{range .Constructor.Inputs}}, {{.Name}}{{end}}) + return res } {{range .Calls}} diff --git a/accounts/abi/bind/v2/internal/contracts/db/bindings.go b/accounts/abi/bind/v2/internal/contracts/db/bindings.go index 74f8fbd37472..b6fdd5555a45 100644 --- a/accounts/abi/bind/v2/internal/contracts/db/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/db/bindings.go @@ -22,221 +22,3 @@ 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: "0x60806040525f80553480156011575f80fd5b5060405180606001604052805f81526020015f81526020015f81525060035f820151815f015560208201518160010155604082015181600201559050506105f78061005b5f395ff3fe60806040526004361061004d575f3560e01c80631d834a1b146100cb5780636fcb9c70146101075780639507d39a14610133578063e369ba3b1461016f578063ee8161e01461019b5761006a565b3661006a57345f8082825461006291906103eb565b925050819055005b348015610075575f80fd5b505f36606082828080601f0160208091040260200160405190810160405280939291908181526020018383808284375f81840152601f19601f820116905080830192505050505050509050915050805190602001f35b3480156100d6575f80fd5b506100f160048036038101906100ec919061044c565b6101c5565b6040516100fe9190610499565b60405180910390f35b348015610112575f80fd5b5061011b6102ef565b60405161012a939291906104b2565b60405180910390f35b34801561013e575f80fd5b50610159600480360381019061015491906104e7565b61030e565b6040516101669190610499565b60405180910390f35b34801561017a575f80fd5b50610183610341565b604051610192939291906104b2565b60405180910390f35b3480156101a6575f80fd5b506101af610360565b6040516101bc9190610561565b60405180910390f35b5f8082036101da5760028054905090506102e9565b5f60015f8581526020019081526020015f20540361023757600283908060018154018082558091505060019003905f5260205f20015f909190919091505560036001015f81548092919061022d9061057a565b9190505550610252565b60036002015f81548092919061024c9061057a565b91905055505b8160015f8581526020019081526020015f20819055507f8b39ff47dca36ab5b8b80845238af53aa579625ac7fb173dc09376adada4176983836002805490506040516102a0939291906104b2565b60405180910390a1827f40bed843c6c5f72002f9b469cf4c1ee9f7fb1eb48f091c1267970f98522ac02d836040516102d89190610499565b60405180910390a260028054905090505b92915050565b5f805f60035f0154600360010154600360020154925092509250909192565b5f60035f015f8154809291906103239061057a565b919050555060015f8381526020019081526020015f20549050919050565b5f805f60035f0154600360010154600360020154925092509250909192565b610368610397565b60036040518060600160405290815f820154815260200160018201548152602001600282015481525050905090565b60405180606001604052805f81526020015f81526020015f81525090565b5f819050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6103f5826103b5565b9150610400836103b5565b9250828201905080821115610418576104176103be565b5b92915050565b5f80fd5b61042b816103b5565b8114610435575f80fd5b50565b5f8135905061044681610422565b92915050565b5f80604083850312156104625761046161041e565b5b5f61046f85828601610438565b925050602061048085828601610438565b9150509250929050565b610493816103b5565b82525050565b5f6020820190506104ac5f83018461048a565b92915050565b5f6060820190506104c55f83018661048a565b6104d2602083018561048a565b6104df604083018461048a565b949350505050565b5f602082840312156104fc576104fb61041e565b5b5f61050984828501610438565b91505092915050565b61051b816103b5565b82525050565b606082015f8201516105355f850182610512565b5060208201516105486020850182610512565b50604082015161055b6040850182610512565b50505050565b5f6060820190506105745f830184610521565b92915050565b5f610584826103b5565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036105b6576105b56103be565b5b60018201905091905056fea2646970667358221220c1e40f27ea44e1ea5f025a197ffe75449cb7972fe55d5c7a5b87cbd8fa49cfa864736f6c634300081a0033", -} - -// 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, error) { - return _DB.abi.Pack("") -} - -// 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 1bf5d4ce107d..c9a027a0f980 100644 --- a/accounts/abi/bind/v2/internal/contracts/events/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/events/bindings.go @@ -22,166 +22,3 @@ 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, error) { - return _C.abi.Pack("") -} - -// 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 d8302994e43a..4a2415dbcccf 100644 --- a/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go @@ -22,392 +22,3 @@ 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, error) { - return _C1.abi.Pack("", v1, v2) -} - -// 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, error) { - return _C2.abi.Pack("", v1, v2) -} - -// 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, error) { - return _L1.abi.Pack("") -} - -// 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, error) { - return _L2.abi.Pack("") -} - -// 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, error) { - return _L2b.abi.Pack("") -} - -// 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, error) { - return _L3.abi.Pack("") -} - -// 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, error) { - return _L4.abi.Pack("") -} - -// 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, error) { - return _L4b.abi.Pack("") -} - -// 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 c2389b22ac1d..652a48be4ff9 100644 --- a/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go @@ -22,163 +22,3 @@ 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, error) { - return _C.abi.Pack("") -} - -// 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, error) { - return _C2.abi.Pack("") -} - -// 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 -} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/callbackparam.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/callbackparam.go new file mode 100644 index 000000000000..6e951829b68f --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/callbackparam.go @@ -0,0 +1,58 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// CallbackParamMetaData contains all meta data concerning the CallbackParam contract. +var CallbackParamMetaData = &bind.MetaData{ + ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"callback\",\"type\":\"function\"}],\"name\":\"test\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Pattern: "949f96f86d3c2e1bcc15563ad898beaaca", + Bin: "0x608060405234801561001057600080fd5b5061015e806100206000396000f3fe60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063d7a5aba214610040575b600080fd5b34801561004c57600080fd5b506100be6004803603602081101561006357600080fd5b810190808035806c0100000000000000000000000090049068010000000000000000900463ffffffff1677ffffffffffffffffffffffffffffffffffffffffffffffff169091602001919093929190939291905050506100c0565b005b818160016040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15801561011657600080fd5b505af115801561012a573d6000803e3d6000fd5b50505050505056fea165627a7a7230582062f87455ff84be90896dbb0c4e4ddb505c600d23089f8e80a512548440d7e2580029", +} + +// CallbackParam is an auto generated Go binding around an Ethereum contract. +type CallbackParam struct { + abi abi.ABI +} + +// NewCallbackParam creates a new instance of CallbackParam. +func NewCallbackParam() (*CallbackParam, error) { + parsed, err := CallbackParamMetaData.GetAbi() + if err != nil { + return nil, err + } + return &CallbackParam{abi: *parsed}, nil +} + +func (_CallbackParam *CallbackParam) PackConstructor() []byte { + res, _ := _CallbackParam.abi.Pack("") + return res +} + +// Test is a free data retrieval call binding the contract method 0xd7a5aba2. +// +// Solidity: function test(function callback) returns() +func (_CallbackParam *CallbackParam) PackTest(callback [24]byte) ([]byte, error) { + return _CallbackParam.abi.Pack("test", callback) +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/crowdsale.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/crowdsale.go new file mode 100644 index 000000000000..66c17fff0132 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/crowdsale.go @@ -0,0 +1,239 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// CrowdsaleMetaData contains all meta data concerning the Crowdsale contract. +var CrowdsaleMetaData = &bind.MetaData{ + ABI: "[{\"constant\":false,\"inputs\":[],\"name\":\"checkGoalReached\",\"outputs\":[],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"deadline\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"beneficiary\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tokenReward\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"fundingGoal\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"amountRaised\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"price\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"funders\",\"outputs\":[{\"name\":\"addr\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"inputs\":[{\"name\":\"ifSuccessfulSendTo\",\"type\":\"address\"},{\"name\":\"fundingGoalInEthers\",\"type\":\"uint256\"},{\"name\":\"durationInMinutes\",\"type\":\"uint256\"},{\"name\":\"etherCostOfEachToken\",\"type\":\"uint256\"},{\"name\":\"addressOfTokenUsedAsReward\",\"type\":\"address\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"backer\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"isContribution\",\"type\":\"bool\"}],\"name\":\"FundTransfer\",\"type\":\"event\"}]", + Pattern: "84d7e935785c5c648282d326307bb8fa0d", + Bin: "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", +} + +// Crowdsale is an auto generated Go binding around an Ethereum contract. +type Crowdsale struct { + abi abi.ABI +} + +// NewCrowdsale creates a new instance of Crowdsale. +func NewCrowdsale() (*Crowdsale, error) { + parsed, err := CrowdsaleMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Crowdsale{abi: *parsed}, nil +} + +func (_Crowdsale *Crowdsale) PackConstructor(ifSuccessfulSendTo common.Address, fundingGoalInEthers *big.Int, durationInMinutes *big.Int, etherCostOfEachToken *big.Int, addressOfTokenUsedAsReward common.Address) []byte { + res, _ := _Crowdsale.abi.Pack("", ifSuccessfulSendTo, fundingGoalInEthers, durationInMinutes, etherCostOfEachToken, addressOfTokenUsedAsReward) + return res +} + +// AmountRaised is a free data retrieval call binding the contract method 0x7b3e5e7b. +// +// Solidity: function amountRaised() returns(uint256) +func (_Crowdsale *Crowdsale) PackAmountRaised() ([]byte, error) { + return _Crowdsale.abi.Pack("amountRaised") +} + +func (_Crowdsale *Crowdsale) UnpackAmountRaised(data []byte) (*big.Int, error) { + out, err := _Crowdsale.abi.Unpack("amountRaised", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Beneficiary is a free data retrieval call binding the contract method 0x38af3eed. +// +// Solidity: function beneficiary() returns(address) +func (_Crowdsale *Crowdsale) PackBeneficiary() ([]byte, error) { + return _Crowdsale.abi.Pack("beneficiary") +} + +func (_Crowdsale *Crowdsale) UnpackBeneficiary(data []byte) (common.Address, error) { + out, err := _Crowdsale.abi.Unpack("beneficiary", data) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// CheckGoalReached is a free data retrieval call binding the contract method 0x01cb3b20. +// +// Solidity: function checkGoalReached() returns() +func (_Crowdsale *Crowdsale) PackCheckGoalReached() ([]byte, error) { + return _Crowdsale.abi.Pack("checkGoalReached") +} + +// Deadline is a free data retrieval call binding the contract method 0x29dcb0cf. +// +// Solidity: function deadline() returns(uint256) +func (_Crowdsale *Crowdsale) PackDeadline() ([]byte, error) { + return _Crowdsale.abi.Pack("deadline") +} + +func (_Crowdsale *Crowdsale) UnpackDeadline(data []byte) (*big.Int, error) { + out, err := _Crowdsale.abi.Unpack("deadline", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Funders is a free data retrieval call binding the contract method 0xdc0d3dff. +// +// Solidity: function funders(uint256 ) returns(address addr, uint256 amount) +func (_Crowdsale *Crowdsale) PackFunders(arg0 *big.Int) ([]byte, error) { + return _Crowdsale.abi.Pack("funders", arg0) +} + +type FundersOutput struct { + Addr common.Address + Amount *big.Int +} + +func (_Crowdsale *Crowdsale) UnpackFunders(data []byte) (FundersOutput, error) { + out, err := _Crowdsale.abi.Unpack("funders", data) + + outstruct := new(FundersOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Addr = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.Amount = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// FundingGoal is a free data retrieval call binding the contract method 0x7a3a0e84. +// +// Solidity: function fundingGoal() returns(uint256) +func (_Crowdsale *Crowdsale) PackFundingGoal() ([]byte, error) { + return _Crowdsale.abi.Pack("fundingGoal") +} + +func (_Crowdsale *Crowdsale) UnpackFundingGoal(data []byte) (*big.Int, error) { + out, err := _Crowdsale.abi.Unpack("fundingGoal", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Price is a free data retrieval call binding the contract method 0xa035b1fe. +// +// Solidity: function price() returns(uint256) +func (_Crowdsale *Crowdsale) PackPrice() ([]byte, error) { + return _Crowdsale.abi.Pack("price") +} + +func (_Crowdsale *Crowdsale) UnpackPrice(data []byte) (*big.Int, error) { + out, err := _Crowdsale.abi.Unpack("price", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TokenReward is a free data retrieval call binding the contract method 0x6e66f6e9. +// +// Solidity: function tokenReward() returns(address) +func (_Crowdsale *Crowdsale) PackTokenReward() ([]byte, error) { + return _Crowdsale.abi.Pack("tokenReward") +} + +func (_Crowdsale *Crowdsale) UnpackTokenReward(data []byte) (common.Address, error) { + out, err := _Crowdsale.abi.Unpack("tokenReward", data) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// CrowdsaleFundTransfer represents a FundTransfer event raised by the Crowdsale contract. +type CrowdsaleFundTransfer struct { + Backer common.Address + Amount *big.Int + IsContribution bool + Raw *types.Log // Blockchain specific contextual infos +} + +const CrowdsaleFundTransferEventName = "FundTransfer" + +func (_Crowdsale *Crowdsale) UnpackFundTransferEvent(log *types.Log) (*CrowdsaleFundTransfer, error) { + event := "FundTransfer" + if log.Topics[0] != _Crowdsale.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(CrowdsaleFundTransfer) + if len(log.Data) > 0 { + if err := _Crowdsale.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Crowdsale.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/convertedv1bindtests/dao.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/dao.go new file mode 100644 index 000000000000..0d6b6e2f3b1d --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/dao.go @@ -0,0 +1,516 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// DAOMetaData contains all meta data concerning the DAO contract. +var DAOMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"proposals\",\"outputs\":[{\"name\":\"recipient\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"},{\"name\":\"description\",\"type\":\"string\"},{\"name\":\"votingDeadline\",\"type\":\"uint256\"},{\"name\":\"executed\",\"type\":\"bool\"},{\"name\":\"proposalPassed\",\"type\":\"bool\"},{\"name\":\"numberOfVotes\",\"type\":\"uint256\"},{\"name\":\"currentResult\",\"type\":\"int256\"},{\"name\":\"proposalHash\",\"type\":\"bytes32\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"proposalNumber\",\"type\":\"uint256\"},{\"name\":\"transactionBytecode\",\"type\":\"bytes\"}],\"name\":\"executeProposal\",\"outputs\":[{\"name\":\"result\",\"type\":\"int256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"memberId\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"numProposals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"members\",\"outputs\":[{\"name\":\"member\",\"type\":\"address\"},{\"name\":\"canVote\",\"type\":\"bool\"},{\"name\":\"name\",\"type\":\"string\"},{\"name\":\"memberSince\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"debatingPeriodInMinutes\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"minimumQuorum\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"targetMember\",\"type\":\"address\"},{\"name\":\"canVote\",\"type\":\"bool\"},{\"name\":\"memberName\",\"type\":\"string\"}],\"name\":\"changeMembership\",\"outputs\":[],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"majorityMargin\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"beneficiary\",\"type\":\"address\"},{\"name\":\"etherAmount\",\"type\":\"uint256\"},{\"name\":\"JobDescription\",\"type\":\"string\"},{\"name\":\"transactionBytecode\",\"type\":\"bytes\"}],\"name\":\"newProposal\",\"outputs\":[{\"name\":\"proposalID\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"minimumQuorumForProposals\",\"type\":\"uint256\"},{\"name\":\"minutesForDebate\",\"type\":\"uint256\"},{\"name\":\"marginOfVotesForMajority\",\"type\":\"int256\"}],\"name\":\"changeVotingRules\",\"outputs\":[],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"proposalNumber\",\"type\":\"uint256\"},{\"name\":\"supportsProposal\",\"type\":\"bool\"},{\"name\":\"justificationText\",\"type\":\"string\"}],\"name\":\"vote\",\"outputs\":[{\"name\":\"voteID\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"proposalNumber\",\"type\":\"uint256\"},{\"name\":\"beneficiary\",\"type\":\"address\"},{\"name\":\"etherAmount\",\"type\":\"uint256\"},{\"name\":\"transactionBytecode\",\"type\":\"bytes\"}],\"name\":\"checkProposalCode\",\"outputs\":[{\"name\":\"codeChecksOut\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"type\":\"function\"},{\"inputs\":[{\"name\":\"minimumQuorumForProposals\",\"type\":\"uint256\"},{\"name\":\"minutesForDebate\",\"type\":\"uint256\"},{\"name\":\"marginOfVotesForMajority\",\"type\":\"int256\"},{\"name\":\"congressLeader\",\"type\":\"address\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"proposalID\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"description\",\"type\":\"string\"}],\"name\":\"ProposalAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"proposalID\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"position\",\"type\":\"bool\"},{\"indexed\":false,\"name\":\"voter\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"justification\",\"type\":\"string\"}],\"name\":\"Voted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"proposalID\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"result\",\"type\":\"int256\"},{\"indexed\":false,\"name\":\"quorum\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"active\",\"type\":\"bool\"}],\"name\":\"ProposalTallied\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"member\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"isMember\",\"type\":\"bool\"}],\"name\":\"MembershipChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"minimumQuorum\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"debatingPeriodInMinutes\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"majorityMargin\",\"type\":\"int256\"}],\"name\":\"ChangeOfRules\",\"type\":\"event\"}]", + Pattern: "d0a4ad96d49edb1c33461cebc6fb260919", + Bin: "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", +} + +// DAO is an auto generated Go binding around an Ethereum contract. +type DAO struct { + abi abi.ABI +} + +// NewDAO creates a new instance of DAO. +func NewDAO() (*DAO, error) { + parsed, err := DAOMetaData.GetAbi() + if err != nil { + return nil, err + } + return &DAO{abi: *parsed}, nil +} + +func (_DAO *DAO) PackConstructor(minimumQuorumForProposals *big.Int, minutesForDebate *big.Int, marginOfVotesForMajority *big.Int, congressLeader common.Address) []byte { + res, _ := _DAO.abi.Pack("", minimumQuorumForProposals, minutesForDebate, marginOfVotesForMajority, congressLeader) + return res +} + +// ChangeMembership is a free data retrieval call binding the contract method 0x9644fcbd. +// +// Solidity: function changeMembership(address targetMember, bool canVote, string memberName) returns() +func (_DAO *DAO) PackChangeMembership(targetMember common.Address, canVote bool, memberName string) ([]byte, error) { + return _DAO.abi.Pack("changeMembership", targetMember, canVote, memberName) +} + +// ChangeVotingRules is a free data retrieval call binding the contract method 0xbcca1fd3. +// +// Solidity: function changeVotingRules(uint256 minimumQuorumForProposals, uint256 minutesForDebate, int256 marginOfVotesForMajority) returns() +func (_DAO *DAO) PackChangeVotingRules(minimumQuorumForProposals *big.Int, minutesForDebate *big.Int, marginOfVotesForMajority *big.Int) ([]byte, error) { + return _DAO.abi.Pack("changeVotingRules", minimumQuorumForProposals, minutesForDebate, marginOfVotesForMajority) +} + +// CheckProposalCode is a free data retrieval call binding the contract method 0xeceb2945. +// +// Solidity: function checkProposalCode(uint256 proposalNumber, address beneficiary, uint256 etherAmount, bytes transactionBytecode) returns(bool codeChecksOut) +func (_DAO *DAO) PackCheckProposalCode(proposalNumber *big.Int, beneficiary common.Address, etherAmount *big.Int, transactionBytecode []byte) ([]byte, error) { + return _DAO.abi.Pack("checkProposalCode", proposalNumber, beneficiary, etherAmount, transactionBytecode) +} + +func (_DAO *DAO) UnpackCheckProposalCode(data []byte) (bool, error) { + out, err := _DAO.abi.Unpack("checkProposalCode", data) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// DebatingPeriodInMinutes is a free data retrieval call binding the contract method 0x69bd3436. +// +// Solidity: function debatingPeriodInMinutes() returns(uint256) +func (_DAO *DAO) PackDebatingPeriodInMinutes() ([]byte, error) { + return _DAO.abi.Pack("debatingPeriodInMinutes") +} + +func (_DAO *DAO) UnpackDebatingPeriodInMinutes(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("debatingPeriodInMinutes", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ExecuteProposal is a free data retrieval call binding the contract method 0x237e9492. +// +// Solidity: function executeProposal(uint256 proposalNumber, bytes transactionBytecode) returns(int256 result) +func (_DAO *DAO) PackExecuteProposal(proposalNumber *big.Int, transactionBytecode []byte) ([]byte, error) { + return _DAO.abi.Pack("executeProposal", proposalNumber, transactionBytecode) +} + +func (_DAO *DAO) UnpackExecuteProposal(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("executeProposal", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MajorityMargin is a free data retrieval call binding the contract method 0xaa02a90f. +// +// Solidity: function majorityMargin() returns(int256) +func (_DAO *DAO) PackMajorityMargin() ([]byte, error) { + return _DAO.abi.Pack("majorityMargin") +} + +func (_DAO *DAO) UnpackMajorityMargin(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("majorityMargin", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MemberId is a free data retrieval call binding the contract method 0x39106821. +// +// Solidity: function memberId(address ) returns(uint256) +func (_DAO *DAO) PackMemberId(arg0 common.Address) ([]byte, error) { + return _DAO.abi.Pack("memberId", arg0) +} + +func (_DAO *DAO) UnpackMemberId(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("memberId", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Members is a free data retrieval call binding the contract method 0x5daf08ca. +// +// Solidity: function members(uint256 ) returns(address member, bool canVote, string name, uint256 memberSince) +func (_DAO *DAO) PackMembers(arg0 *big.Int) ([]byte, error) { + return _DAO.abi.Pack("members", arg0) +} + +type MembersOutput struct { + Member common.Address + CanVote bool + Name string + MemberSince *big.Int +} + +func (_DAO *DAO) UnpackMembers(data []byte) (MembersOutput, error) { + out, err := _DAO.abi.Unpack("members", data) + + outstruct := new(MembersOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Member = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.CanVote = *abi.ConvertType(out[1], new(bool)).(*bool) + outstruct.Name = *abi.ConvertType(out[2], new(string)).(*string) + outstruct.MemberSince = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// MinimumQuorum is a free data retrieval call binding the contract method 0x8160f0b5. +// +// Solidity: function minimumQuorum() returns(uint256) +func (_DAO *DAO) PackMinimumQuorum() ([]byte, error) { + return _DAO.abi.Pack("minimumQuorum") +} + +func (_DAO *DAO) UnpackMinimumQuorum(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("minimumQuorum", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// NewProposal is a free data retrieval call binding the contract method 0xb1050da5. +// +// Solidity: function newProposal(address beneficiary, uint256 etherAmount, string JobDescription, bytes transactionBytecode) returns(uint256 proposalID) +func (_DAO *DAO) PackNewProposal(beneficiary common.Address, etherAmount *big.Int, JobDescription string, transactionBytecode []byte) ([]byte, error) { + return _DAO.abi.Pack("newProposal", beneficiary, etherAmount, JobDescription, transactionBytecode) +} + +func (_DAO *DAO) UnpackNewProposal(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("newProposal", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// NumProposals is a free data retrieval call binding the contract method 0x400e3949. +// +// Solidity: function numProposals() returns(uint256) +func (_DAO *DAO) PackNumProposals() ([]byte, error) { + return _DAO.abi.Pack("numProposals") +} + +func (_DAO *DAO) UnpackNumProposals(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("numProposals", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() returns(address) +func (_DAO *DAO) PackOwner() ([]byte, error) { + return _DAO.abi.Pack("owner") +} + +func (_DAO *DAO) UnpackOwner(data []byte) (common.Address, error) { + out, err := _DAO.abi.Unpack("owner", data) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Proposals is a free data retrieval call binding the contract method 0x013cf08b. +// +// Solidity: function proposals(uint256 ) returns(address recipient, uint256 amount, string description, uint256 votingDeadline, bool executed, bool proposalPassed, uint256 numberOfVotes, int256 currentResult, bytes32 proposalHash) +func (_DAO *DAO) PackProposals(arg0 *big.Int) ([]byte, error) { + return _DAO.abi.Pack("proposals", arg0) +} + +type ProposalsOutput struct { + Recipient common.Address + Amount *big.Int + Description string + VotingDeadline *big.Int + Executed bool + ProposalPassed bool + NumberOfVotes *big.Int + CurrentResult *big.Int + ProposalHash [32]byte +} + +func (_DAO *DAO) UnpackProposals(data []byte) (ProposalsOutput, error) { + out, err := _DAO.abi.Unpack("proposals", data) + + outstruct := new(ProposalsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Recipient = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.Amount = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.Description = *abi.ConvertType(out[2], new(string)).(*string) + outstruct.VotingDeadline = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) + outstruct.Executed = *abi.ConvertType(out[4], new(bool)).(*bool) + outstruct.ProposalPassed = *abi.ConvertType(out[5], new(bool)).(*bool) + outstruct.NumberOfVotes = *abi.ConvertType(out[6], new(*big.Int)).(**big.Int) + outstruct.CurrentResult = *abi.ConvertType(out[7], new(*big.Int)).(**big.Int) + outstruct.ProposalHash = *abi.ConvertType(out[8], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// TransferOwnership is a free data retrieval call binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_DAO *DAO) PackTransferOwnership(newOwner common.Address) ([]byte, error) { + return _DAO.abi.Pack("transferOwnership", newOwner) +} + +// Vote is a free data retrieval call binding the contract method 0xd3c0715b. +// +// Solidity: function vote(uint256 proposalNumber, bool supportsProposal, string justificationText) returns(uint256 voteID) +func (_DAO *DAO) PackVote(proposalNumber *big.Int, supportsProposal bool, justificationText string) ([]byte, error) { + return _DAO.abi.Pack("vote", proposalNumber, supportsProposal, justificationText) +} + +func (_DAO *DAO) UnpackVote(data []byte) (*big.Int, error) { + out, err := _DAO.abi.Unpack("vote", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DAOChangeOfRules represents a ChangeOfRules event raised by the DAO contract. +type DAOChangeOfRules struct { + MinimumQuorum *big.Int + DebatingPeriodInMinutes *big.Int + MajorityMargin *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOChangeOfRulesEventName = "ChangeOfRules" + +func (_DAO *DAO) UnpackChangeOfRulesEvent(log *types.Log) (*DAOChangeOfRules, error) { + event := "ChangeOfRules" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOChangeOfRules) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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 +} + +// DAOMembershipChanged represents a MembershipChanged event raised by the DAO contract. +type DAOMembershipChanged struct { + Member common.Address + IsMember bool + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOMembershipChangedEventName = "MembershipChanged" + +func (_DAO *DAO) UnpackMembershipChangedEvent(log *types.Log) (*DAOMembershipChanged, error) { + event := "MembershipChanged" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOMembershipChanged) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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 +} + +// DAOProposalAdded represents a ProposalAdded event raised by the DAO contract. +type DAOProposalAdded struct { + ProposalID *big.Int + Recipient common.Address + Amount *big.Int + Description string + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOProposalAddedEventName = "ProposalAdded" + +func (_DAO *DAO) UnpackProposalAddedEvent(log *types.Log) (*DAOProposalAdded, error) { + event := "ProposalAdded" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOProposalAdded) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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 +} + +// DAOProposalTallied represents a ProposalTallied event raised by the DAO contract. +type DAOProposalTallied struct { + ProposalID *big.Int + Result *big.Int + Quorum *big.Int + Active bool + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOProposalTalliedEventName = "ProposalTallied" + +func (_DAO *DAO) UnpackProposalTalliedEvent(log *types.Log) (*DAOProposalTallied, error) { + event := "ProposalTallied" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOProposalTallied) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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 +} + +// DAOVoted represents a Voted event raised by the DAO contract. +type DAOVoted struct { + ProposalID *big.Int + Position bool + Voter common.Address + Justification string + Raw *types.Log // Blockchain specific contextual infos +} + +const DAOVotedEventName = "Voted" + +func (_DAO *DAO) UnpackVotedEvent(log *types.Log) (*DAOVoted, error) { + event := "Voted" + if log.Topics[0] != _DAO.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(DAOVoted) + if len(log.Data) > 0 { + if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _DAO.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/convertedv1bindtests/deeplynestedarray.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/deeplynestedarray.go new file mode 100644 index 000000000000..ab2cd5574a5c --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/deeplynestedarray.go @@ -0,0 +1,98 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// DeeplyNestedArrayMetaData contains all meta data concerning the DeeplyNestedArray contract. +var DeeplyNestedArrayMetaData = &bind.MetaData{ + ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"arr\",\"type\":\"uint64[3][4][5]\"}],\"name\":\"storeDeepUintArray\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"retrieveDeepArray\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64[3][4][5]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"deepUint64Array\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", + Pattern: "3a44c26b21f02743d5dbeb02d24a67bf41", + Bin: "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", +} + +// DeeplyNestedArray is an auto generated Go binding around an Ethereum contract. +type DeeplyNestedArray struct { + abi abi.ABI +} + +// NewDeeplyNestedArray creates a new instance of DeeplyNestedArray. +func NewDeeplyNestedArray() (*DeeplyNestedArray, error) { + parsed, err := DeeplyNestedArrayMetaData.GetAbi() + if err != nil { + return nil, err + } + return &DeeplyNestedArray{abi: *parsed}, nil +} + +func (_DeeplyNestedArray *DeeplyNestedArray) PackConstructor() []byte { + res, _ := _DeeplyNestedArray.abi.Pack("") + return res +} + +// DeepUint64Array is a free data retrieval call binding the contract method 0x98ed1856. +// +// Solidity: function deepUint64Array(uint256 , uint256 , uint256 ) view returns(uint64) +func (_DeeplyNestedArray *DeeplyNestedArray) PackDeepUint64Array(arg0 *big.Int, arg1 *big.Int, arg2 *big.Int) ([]byte, error) { + return _DeeplyNestedArray.abi.Pack("deepUint64Array", arg0, arg1, arg2) +} + +func (_DeeplyNestedArray *DeeplyNestedArray) UnpackDeepUint64Array(data []byte) (uint64, error) { + out, err := _DeeplyNestedArray.abi.Unpack("deepUint64Array", data) + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// RetrieveDeepArray is a free data retrieval call binding the contract method 0x8ed4573a. +// +// Solidity: function retrieveDeepArray() view returns(uint64[3][4][5]) +func (_DeeplyNestedArray *DeeplyNestedArray) PackRetrieveDeepArray() ([]byte, error) { + return _DeeplyNestedArray.abi.Pack("retrieveDeepArray") +} + +func (_DeeplyNestedArray *DeeplyNestedArray) UnpackRetrieveDeepArray(data []byte) ([5][4][3]uint64, error) { + out, err := _DeeplyNestedArray.abi.Unpack("retrieveDeepArray", data) + + if err != nil { + return *new([5][4][3]uint64), err + } + + out0 := *abi.ConvertType(out[0], new([5][4][3]uint64)).(*[5][4][3]uint64) + + return out0, err + +} + +// StoreDeepUintArray is a free data retrieval call binding the contract method 0x34424855. +// +// Solidity: function storeDeepUintArray(uint64[3][4][5] arr) returns() +func (_DeeplyNestedArray *DeeplyNestedArray) PackStoreDeepUintArray(arr [5][4][3]uint64) ([]byte, error) { + return _DeeplyNestedArray.abi.Pack("storeDeepUintArray", arr) +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/empty.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/empty.go new file mode 100644 index 000000000000..e6c7efd7ae65 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/empty.go @@ -0,0 +1,51 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// EmptyMetaData contains all meta data concerning the Empty contract. +var EmptyMetaData = &bind.MetaData{ + ABI: "[]", + Pattern: "c4ce3210982aa6fc94dabe46dc1dbf454d", + Bin: "0x606060405260068060106000396000f3606060405200", +} + +// Empty is an auto generated Go binding around an Ethereum contract. +type Empty struct { + abi abi.ABI +} + +// NewEmpty creates a new instance of Empty. +func NewEmpty() (*Empty, error) { + parsed, err := EmptyMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Empty{abi: *parsed}, nil +} + +func (_Empty *Empty) PackConstructor() []byte { + res, _ := _Empty.abi.Pack("") + return res +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/eventchecker.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/eventchecker.go new file mode 100644 index 000000000000..742d9876b098 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/eventchecker.go @@ -0,0 +1,215 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// EventCheckerMetaData contains all meta data concerning the EventChecker contract. +var EventCheckerMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"event\",\"name\":\"empty\",\"inputs\":[]},{\"type\":\"event\",\"name\":\"indexed\",\"inputs\":[{\"name\":\"addr\",\"type\":\"address\",\"indexed\":true},{\"name\":\"num\",\"type\":\"int256\",\"indexed\":true}]},{\"type\":\"event\",\"name\":\"mixed\",\"inputs\":[{\"name\":\"addr\",\"type\":\"address\",\"indexed\":true},{\"name\":\"num\",\"type\":\"int256\"}]},{\"type\":\"event\",\"name\":\"anonymous\",\"anonymous\":true,\"inputs\":[]},{\"type\":\"event\",\"name\":\"dynamic\",\"inputs\":[{\"name\":\"idxStr\",\"type\":\"string\",\"indexed\":true},{\"name\":\"idxDat\",\"type\":\"bytes\",\"indexed\":true},{\"name\":\"str\",\"type\":\"string\"},{\"name\":\"dat\",\"type\":\"bytes\"}]},{\"type\":\"event\",\"name\":\"unnamed\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"\",\"type\":\"uint256\",\"indexed\":true}]}]", + Pattern: "253d421f98e29b25315bde79c1251ab27c", +} + +// EventChecker is an auto generated Go binding around an Ethereum contract. +type EventChecker struct { + abi abi.ABI +} + +// NewEventChecker creates a new instance of EventChecker. +func NewEventChecker() (*EventChecker, error) { + parsed, err := EventCheckerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &EventChecker{abi: *parsed}, nil +} + +func (_EventChecker *EventChecker) PackConstructor() []byte { + res, _ := _EventChecker.abi.Pack("") + return res +} + +// EventCheckerDynamic represents a Dynamic event raised by the EventChecker contract. +type EventCheckerDynamic struct { + IdxStr common.Hash + IdxDat common.Hash + Str string + Dat []byte + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerDynamicEventName = "dynamic" + +func (_EventChecker *EventChecker) UnpackDynamicEvent(log *types.Log) (*EventCheckerDynamic, error) { + event := "dynamic" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerDynamic) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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 +} + +// EventCheckerEmpty represents a Empty event raised by the EventChecker contract. +type EventCheckerEmpty struct { + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerEmptyEventName = "empty" + +func (_EventChecker *EventChecker) UnpackEmptyEvent(log *types.Log) (*EventCheckerEmpty, error) { + event := "empty" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerEmpty) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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 +} + +// EventCheckerIndexed represents a Indexed event raised by the EventChecker contract. +type EventCheckerIndexed struct { + Addr common.Address + Num *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerIndexedEventName = "indexed" + +func (_EventChecker *EventChecker) UnpackIndexedEvent(log *types.Log) (*EventCheckerIndexed, error) { + event := "indexed" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerIndexed) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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 +} + +// EventCheckerMixed represents a Mixed event raised by the EventChecker contract. +type EventCheckerMixed struct { + Addr common.Address + Num *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerMixedEventName = "mixed" + +func (_EventChecker *EventChecker) UnpackMixedEvent(log *types.Log) (*EventCheckerMixed, error) { + event := "mixed" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerMixed) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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 +} + +// EventCheckerUnnamed represents a Unnamed event raised by the EventChecker contract. +type EventCheckerUnnamed struct { + Arg0 *big.Int + Arg1 *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const EventCheckerUnnamedEventName = "unnamed" + +func (_EventChecker *EventChecker) UnpackUnnamedEvent(log *types.Log) (*EventCheckerUnnamed, error) { + event := "unnamed" + if log.Topics[0] != _EventChecker.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(EventCheckerUnnamed) + if len(log.Data) > 0 { + if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _EventChecker.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/convertedv1bindtests/getter.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/getter.go new file mode 100644 index 000000000000..067dc21af80b --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/getter.go @@ -0,0 +1,80 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// GetterMetaData contains all meta data concerning the Getter contract. +var GetterMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"getter\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"int256\"},{\"name\":\"\",\"type\":\"bytes32\"}],\"type\":\"function\"}]", + Pattern: "e23a74c8979fe93c9fff15e4f51535ad54", + Bin: "0x606060405260dc8060106000396000f3606060405260e060020a6000350463993a04b78114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3", +} + +// Getter is an auto generated Go binding around an Ethereum contract. +type Getter struct { + abi abi.ABI +} + +// NewGetter creates a new instance of Getter. +func NewGetter() (*Getter, error) { + parsed, err := GetterMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Getter{abi: *parsed}, nil +} + +func (_Getter *Getter) PackConstructor() []byte { + res, _ := _Getter.abi.Pack("") + return res +} + +// Getter is a free data retrieval call binding the contract method 0x993a04b7. +// +// Solidity: function getter() returns(string, int256, bytes32) +func (_Getter *Getter) PackGetter() ([]byte, error) { + return _Getter.abi.Pack("getter") +} + +type GetterOutput struct { + Arg string + Arg0 *big.Int + Arg1 [32]byte +} + +func (_Getter *Getter) UnpackGetter(data []byte) (GetterOutput, error) { + out, err := _Getter.abi.Unpack("getter", data) + + outstruct := new(GetterOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Arg0 = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.Arg1 = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/identifiercollision.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/identifiercollision.go new file mode 100644 index 000000000000..150a1ad16391 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/identifiercollision.go @@ -0,0 +1,91 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// IdentifierCollisionMetaData contains all meta data concerning the IdentifierCollision contract. +var IdentifierCollisionMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"MyVar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_myVar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", + Pattern: "1863c5622f8ac2c09c42f063ca883fe438", + Bin: "0x60806040523480156100115760006000fd5b50610017565b60c3806100256000396000f3fe608060405234801560105760006000fd5b506004361060365760003560e01c806301ad4d8714603c5780634ef1f0ad146058576036565b60006000fd5b60426074565b6040518082815260200191505060405180910390f35b605e607d565b6040518082815260200191505060405180910390f35b60006000505481565b60006000600050549050608b565b9056fea265627a7a7231582067c8d84688b01c4754ba40a2a871cede94ea1f28b5981593ab2a45b46ac43af664736f6c634300050c0032", +} + +// IdentifierCollision is an auto generated Go binding around an Ethereum contract. +type IdentifierCollision struct { + abi abi.ABI +} + +// NewIdentifierCollision creates a new instance of IdentifierCollision. +func NewIdentifierCollision() (*IdentifierCollision, error) { + parsed, err := IdentifierCollisionMetaData.GetAbi() + if err != nil { + return nil, err + } + return &IdentifierCollision{abi: *parsed}, nil +} + +func (_IdentifierCollision *IdentifierCollision) PackConstructor() []byte { + res, _ := _IdentifierCollision.abi.Pack("") + return res +} + +// MyVar is a free data retrieval call binding the contract method 0x4ef1f0ad. +// +// Solidity: function MyVar() view returns(uint256) +func (_IdentifierCollision *IdentifierCollision) PackMyVar() ([]byte, error) { + return _IdentifierCollision.abi.Pack("MyVar") +} + +func (_IdentifierCollision *IdentifierCollision) UnpackMyVar(data []byte) (*big.Int, error) { + out, err := _IdentifierCollision.abi.Unpack("MyVar", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PubVar is a free data retrieval call binding the contract method 0x01ad4d87. +// +// Solidity: function _myVar() view returns(uint256) +func (_IdentifierCollision *IdentifierCollision) PackPubVar() ([]byte, error) { + return _IdentifierCollision.abi.Pack("_myVar") +} + +func (_IdentifierCollision *IdentifierCollision) UnpackPubVar(data []byte) (*big.Int, error) { + out, err := _IdentifierCollision.abi.Unpack("_myVar", 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/convertedv1bindtests/inputchecker.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/inputchecker.go new file mode 100644 index 000000000000..59664669361b --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/inputchecker.go @@ -0,0 +1,92 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// InputCheckerMetaData contains all meta data concerning the InputChecker contract. +var InputCheckerMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"noInput\",\"constant\":true,\"inputs\":[],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedInput\",\"constant\":true,\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"anonInput\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedInputs\",\"constant\":true,\"inputs\":[{\"name\":\"str1\",\"type\":\"string\"},{\"name\":\"str2\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"anonInputs\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"mixedInputs\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"str\",\"type\":\"string\"}],\"outputs\":[]}]", + Pattern: "e551ce092312e54f54f45ffdf06caa4cdc", +} + +// InputChecker is an auto generated Go binding around an Ethereum contract. +type InputChecker struct { + abi abi.ABI +} + +// NewInputChecker creates a new instance of InputChecker. +func NewInputChecker() (*InputChecker, error) { + parsed, err := InputCheckerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &InputChecker{abi: *parsed}, nil +} + +func (_InputChecker *InputChecker) PackConstructor() []byte { + res, _ := _InputChecker.abi.Pack("") + return res +} + +// AnonInput is a free data retrieval call binding the contract method 0x3e708e82. +// +// Solidity: function anonInput(string ) returns() +func (_InputChecker *InputChecker) PackAnonInput(arg0 string) ([]byte, error) { + return _InputChecker.abi.Pack("anonInput", arg0) +} + +// AnonInputs is a free data retrieval call binding the contract method 0x28160527. +// +// Solidity: function anonInputs(string , string ) returns() +func (_InputChecker *InputChecker) PackAnonInputs(arg0 string, arg1 string) ([]byte, error) { + return _InputChecker.abi.Pack("anonInputs", arg0, arg1) +} + +// MixedInputs is a free data retrieval call binding the contract method 0xc689ebdc. +// +// Solidity: function mixedInputs(string , string str) returns() +func (_InputChecker *InputChecker) PackMixedInputs(arg0 string, str string) ([]byte, error) { + return _InputChecker.abi.Pack("mixedInputs", arg0, str) +} + +// NamedInput is a free data retrieval call binding the contract method 0x0d402005. +// +// Solidity: function namedInput(string str) returns() +func (_InputChecker *InputChecker) PackNamedInput(str string) ([]byte, error) { + return _InputChecker.abi.Pack("namedInput", str) +} + +// NamedInputs is a free data retrieval call binding the contract method 0x63c796ed. +// +// Solidity: function namedInputs(string str1, string str2) returns() +func (_InputChecker *InputChecker) PackNamedInputs(str1 string, str2 string) ([]byte, error) { + return _InputChecker.abi.Pack("namedInputs", str1, str2) +} + +// NoInput is a free data retrieval call binding the contract method 0x53539029. +// +// Solidity: function noInput() returns() +func (_InputChecker *InputChecker) PackNoInput() ([]byte, error) { + return _InputChecker.abi.Pack("noInput") +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/interactor.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/interactor.go new file mode 100644 index 000000000000..d921c9031bf9 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/interactor.go @@ -0,0 +1,98 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// InteractorMetaData contains all meta data concerning the Interactor contract. +var InteractorMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"transactString\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"deployString\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"name\":\"transact\",\"outputs\":[],\"type\":\"function\"},{\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"type\":\"constructor\"}]", + Pattern: "f63980878028f3242c9033fdc30fd21a81", + Bin: "0x6060604052604051610328380380610328833981016040528051018060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10608d57805160ff19168380011785555b50607c9291505b8082111560ba57838155600101606b565b50505061026a806100be6000396000f35b828001600101855582156064579182015b828111156064578251826000505591602001919060010190609e565b509056606060405260e060020a60003504630d86a0e181146100315780636874e8091461008d578063d736c513146100ea575b005b610190600180546020600282841615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b61019060008054602060026001831615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b60206004803580820135601f81018490049093026080908101604052606084815261002f946024939192918401918190838280828437509496505050505050508060016000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061023157805160ff19168380011785555b506102619291505b808211156102665760008155830161017d565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101f05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b820191906000526020600020905b81548152906001019060200180831161020c57829003601f168201915b505050505081565b82800160010185558215610175579182015b82811115610175578251826000505591602001919060010190610243565b505050565b509056", +} + +// Interactor is an auto generated Go binding around an Ethereum contract. +type Interactor struct { + abi abi.ABI +} + +// NewInteractor creates a new instance of Interactor. +func NewInteractor() (*Interactor, error) { + parsed, err := InteractorMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Interactor{abi: *parsed}, nil +} + +func (_Interactor *Interactor) PackConstructor(str string) []byte { + res, _ := _Interactor.abi.Pack("", str) + return res +} + +// DeployString is a free data retrieval call binding the contract method 0x6874e809. +// +// Solidity: function deployString() returns(string) +func (_Interactor *Interactor) PackDeployString() ([]byte, error) { + return _Interactor.abi.Pack("deployString") +} + +func (_Interactor *Interactor) UnpackDeployString(data []byte) (string, error) { + out, err := _Interactor.abi.Unpack("deployString", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Transact is a free data retrieval call binding the contract method 0xd736c513. +// +// Solidity: function transact(string str) returns() +func (_Interactor *Interactor) PackTransact(str string) ([]byte, error) { + return _Interactor.abi.Pack("transact", str) +} + +// TransactString is a free data retrieval call binding the contract method 0x0d86a0e1. +// +// Solidity: function transactString() returns(string) +func (_Interactor *Interactor) PackTransactString() ([]byte, error) { + return _Interactor.abi.Pack("transactString") +} + +func (_Interactor *Interactor) UnpackTransactString(data []byte) (string, error) { + out, err := _Interactor.abi.Unpack("transactString", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/nameconflict.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/nameconflict.go new file mode 100644 index 000000000000..8046fd67ccb8 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/nameconflict.go @@ -0,0 +1,117 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// Oraclerequest is an auto generated low-level Go binding around an user-defined struct. +type Oraclerequest struct { + Data []byte + Data0 []byte +} + +// TODO: convert this type to value type after everything works. +// NameConflictMetaData contains all meta data concerning the NameConflict contract. +var NameConflictMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"msg\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"_msg\",\"type\":\"int256\"}],\"name\":\"log\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"internalType\":\"structoracle.request\",\"name\":\"req\",\"type\":\"tuple\"}],\"name\":\"addRequest\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRequest\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"internalType\":\"structoracle.request\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "8f6e2703b307244ae6bd61ed94ce959cf9", + Bin: "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", +} + +// NameConflict is an auto generated Go binding around an Ethereum contract. +type NameConflict struct { + abi abi.ABI +} + +// NewNameConflict creates a new instance of NameConflict. +func NewNameConflict() (*NameConflict, error) { + parsed, err := NameConflictMetaData.GetAbi() + if err != nil { + return nil, err + } + return &NameConflict{abi: *parsed}, nil +} + +func (_NameConflict *NameConflict) PackConstructor() []byte { + res, _ := _NameConflict.abi.Pack("") + return res +} + +// AddRequest is a free data retrieval call binding the contract method 0xcce7b048. +// +// Solidity: function addRequest((bytes,bytes) req) pure returns() +func (_NameConflict *NameConflict) PackAddRequest(req Oraclerequest) ([]byte, error) { + return _NameConflict.abi.Pack("addRequest", req) +} + +// GetRequest is a free data retrieval call binding the contract method 0xc2bb515f. +// +// Solidity: function getRequest() pure returns((bytes,bytes)) +func (_NameConflict *NameConflict) PackGetRequest() ([]byte, error) { + return _NameConflict.abi.Pack("getRequest") +} + +func (_NameConflict *NameConflict) UnpackGetRequest(data []byte) (Oraclerequest, error) { + out, err := _NameConflict.abi.Unpack("getRequest", data) + + if err != nil { + return *new(Oraclerequest), err + } + + out0 := *abi.ConvertType(out[0], new(Oraclerequest)).(*Oraclerequest) + + return out0, err + +} + +// NameConflictLog represents a Log event raised by the NameConflict contract. +type NameConflictLog struct { + Msg *big.Int + Msg0 *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const NameConflictLogEventName = "log" + +func (_NameConflict *NameConflict) UnpackLogEvent(log *types.Log) (*NameConflictLog, error) { + event := "log" + if log.Topics[0] != _NameConflict.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(NameConflictLog) + if len(log.Data) > 0 { + if err := _NameConflict.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _NameConflict.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/convertedv1bindtests/numericmethodname.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/numericmethodname.go new file mode 100644 index 000000000000..21e075cd2254 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/numericmethodname.go @@ -0,0 +1,104 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// NumericMethodNameMetaData contains all meta data concerning the NumericMethodName contract. +var NumericMethodNameMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_param\",\"type\":\"address\"}],\"name\":\"_1TestEvent\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"_1test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__1test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__2test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "a691b347afbc44b90dd9a1dfbc65661904", + Bin: "0x6080604052348015600f57600080fd5b5060958061001e6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80639d993132146041578063d02767c7146049578063ffa02795146051575b600080fd5b60476059565b005b604f605b565b005b6057605d565b005b565b565b56fea26469706673582212200382ca602dff96a7e2ba54657985e2b4ac423a56abe4a1f0667bc635c4d4371f64736f6c63430008110033", +} + +// NumericMethodName is an auto generated Go binding around an Ethereum contract. +type NumericMethodName struct { + abi abi.ABI +} + +// NewNumericMethodName creates a new instance of NumericMethodName. +func NewNumericMethodName() (*NumericMethodName, error) { + parsed, err := NumericMethodNameMetaData.GetAbi() + if err != nil { + return nil, err + } + return &NumericMethodName{abi: *parsed}, nil +} + +func (_NumericMethodName *NumericMethodName) PackConstructor() []byte { + res, _ := _NumericMethodName.abi.Pack("") + return res +} + +// E1test is a free data retrieval call binding the contract method 0xffa02795. +// +// Solidity: function _1test() pure returns() +func (_NumericMethodName *NumericMethodName) PackE1test() ([]byte, error) { + return _NumericMethodName.abi.Pack("_1test") +} + +// E1test0 is a free data retrieval call binding the contract method 0xd02767c7. +// +// Solidity: function __1test() pure returns() +func (_NumericMethodName *NumericMethodName) PackE1test0() ([]byte, error) { + return _NumericMethodName.abi.Pack("__1test") +} + +// E2test is a free data retrieval call binding the contract method 0x9d993132. +// +// Solidity: function __2test() pure returns() +func (_NumericMethodName *NumericMethodName) PackE2test() ([]byte, error) { + return _NumericMethodName.abi.Pack("__2test") +} + +// NumericMethodNameE1TestEvent represents a E1TestEvent event raised by the NumericMethodName contract. +type NumericMethodNameE1TestEvent struct { + Param common.Address + Raw *types.Log // Blockchain specific contextual infos +} + +const NumericMethodNameE1TestEventEventName = "_1TestEvent" + +func (_NumericMethodName *NumericMethodName) UnpackE1TestEventEvent(log *types.Log) (*NumericMethodNameE1TestEvent, error) { + event := "_1TestEvent" + if log.Topics[0] != _NumericMethodName.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(NumericMethodNameE1TestEvent) + if len(log.Data) > 0 { + if err := _NumericMethodName.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _NumericMethodName.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/convertedv1bindtests/outputchecker.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/outputchecker.go new file mode 100644 index 000000000000..b1487461add2 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/outputchecker.go @@ -0,0 +1,205 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// OutputCheckerMetaData contains all meta data concerning the OutputChecker contract. +var OutputCheckerMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"noOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"anonOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"namedOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str1\",\"type\":\"string\"},{\"name\":\"str2\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"collidingOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str\",\"type\":\"string\"},{\"name\":\"Str\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"anonOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"mixedOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"str\",\"type\":\"string\"}]}]", + Pattern: "cc1d4e235801a590b506d5130b0cca90a1", +} + +// OutputChecker is an auto generated Go binding around an Ethereum contract. +type OutputChecker struct { + abi abi.ABI +} + +// NewOutputChecker creates a new instance of OutputChecker. +func NewOutputChecker() (*OutputChecker, error) { + parsed, err := OutputCheckerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &OutputChecker{abi: *parsed}, nil +} + +func (_OutputChecker *OutputChecker) PackConstructor() []byte { + res, _ := _OutputChecker.abi.Pack("") + return res +} + +// AnonOutput is a free data retrieval call binding the contract method 0x008bda05. +// +// Solidity: function anonOutput() returns(string) +func (_OutputChecker *OutputChecker) PackAnonOutput() ([]byte, error) { + return _OutputChecker.abi.Pack("anonOutput") +} + +func (_OutputChecker *OutputChecker) UnpackAnonOutput(data []byte) (string, error) { + out, err := _OutputChecker.abi.Unpack("anonOutput", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// AnonOutputs is a free data retrieval call binding the contract method 0x3c401115. +// +// Solidity: function anonOutputs() returns(string, string) +func (_OutputChecker *OutputChecker) PackAnonOutputs() ([]byte, error) { + return _OutputChecker.abi.Pack("anonOutputs") +} + +type AnonOutputsOutput struct { + Arg string + Arg0 string +} + +func (_OutputChecker *OutputChecker) UnpackAnonOutputs(data []byte) (AnonOutputsOutput, error) { + out, err := _OutputChecker.abi.Unpack("anonOutputs", data) + + outstruct := new(AnonOutputsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Arg0 = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// CollidingOutputs is a free data retrieval call binding the contract method 0xeccbc1ee. +// +// Solidity: function collidingOutputs() returns(string str, string Str) +func (_OutputChecker *OutputChecker) PackCollidingOutputs() ([]byte, error) { + return _OutputChecker.abi.Pack("collidingOutputs") +} + +type CollidingOutputsOutput struct { + Str string + Str string +} + +func (_OutputChecker *OutputChecker) UnpackCollidingOutputs(data []byte) (CollidingOutputsOutput, error) { + out, err := _OutputChecker.abi.Unpack("collidingOutputs", data) + + outstruct := new(CollidingOutputsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Str = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Str = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// MixedOutputs is a free data retrieval call binding the contract method 0x21b77b44. +// +// Solidity: function mixedOutputs() returns(string, string str) +func (_OutputChecker *OutputChecker) PackMixedOutputs() ([]byte, error) { + return _OutputChecker.abi.Pack("mixedOutputs") +} + +type MixedOutputsOutput struct { + Arg string + Str string +} + +func (_OutputChecker *OutputChecker) UnpackMixedOutputs(data []byte) (MixedOutputsOutput, error) { + out, err := _OutputChecker.abi.Unpack("mixedOutputs", data) + + outstruct := new(MixedOutputsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Str = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// NamedOutput is a free data retrieval call binding the contract method 0x5e632bd5. +// +// Solidity: function namedOutput() returns(string str) +func (_OutputChecker *OutputChecker) PackNamedOutput() ([]byte, error) { + return _OutputChecker.abi.Pack("namedOutput") +} + +func (_OutputChecker *OutputChecker) UnpackNamedOutput(data []byte) (string, error) { + out, err := _OutputChecker.abi.Unpack("namedOutput", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// NamedOutputs is a free data retrieval call binding the contract method 0x7970a189. +// +// Solidity: function namedOutputs() returns(string str1, string str2) +func (_OutputChecker *OutputChecker) PackNamedOutputs() ([]byte, error) { + return _OutputChecker.abi.Pack("namedOutputs") +} + +type NamedOutputsOutput struct { + Str1 string + Str2 string +} + +func (_OutputChecker *OutputChecker) UnpackNamedOutputs(data []byte) (NamedOutputsOutput, error) { + out, err := _OutputChecker.abi.Unpack("namedOutputs", data) + + outstruct := new(NamedOutputsOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Str1 = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Str2 = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// NoOutput is a free data retrieval call binding the contract method 0x625f0306. +// +// Solidity: function noOutput() returns() +func (_OutputChecker *OutputChecker) PackNoOutput() ([]byte, error) { + return _OutputChecker.abi.Pack("noOutput") +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/overload.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/overload.go new file mode 100644 index 000000000000..93894f34010d --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/overload.go @@ -0,0 +1,130 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// OverloadMetaData contains all meta data concerning the Overload contract. +var OverloadMetaData = &bind.MetaData{ + ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"},{\"name\":\"j\",\"type\":\"uint256\"}],\"name\":\"foo\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"}],\"name\":\"foo\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"i\",\"type\":\"uint256\"}],\"name\":\"bar\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"i\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"j\",\"type\":\"uint256\"}],\"name\":\"bar\",\"type\":\"event\"}]", + Pattern: "f49f0ff7ed407de5c37214f49309072aec", + Bin: "0x608060405234801561001057600080fd5b50610153806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806304bc52f81461003b5780632fbebd3814610073575b600080fd5b6100716004803603604081101561005157600080fd5b8101908080359060200190929190803590602001909291905050506100a1565b005b61009f6004803603602081101561008957600080fd5b81019080803590602001909291905050506100e4565b005b7fae42e9514233792a47a1e4554624e83fe852228e1503f63cd383e8a431f4f46d8282604051808381526020018281526020019250505060405180910390a15050565b7f0423a1321222a0a8716c22b92fac42d85a45a612b696a461784d9fa537c81e5c816040518082815260200191505060405180910390a15056fea265627a7a72305820e22b049858b33291cbe67eeaece0c5f64333e439d27032ea8337d08b1de18fe864736f6c634300050a0032", +} + +// Overload is an auto generated Go binding around an Ethereum contract. +type Overload struct { + abi abi.ABI +} + +// NewOverload creates a new instance of Overload. +func NewOverload() (*Overload, error) { + parsed, err := OverloadMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Overload{abi: *parsed}, nil +} + +func (_Overload *Overload) PackConstructor() []byte { + res, _ := _Overload.abi.Pack("") + return res +} + +// Foo is a free data retrieval call binding the contract method 0x04bc52f8. +// +// Solidity: function foo(uint256 i, uint256 j) returns() +func (_Overload *Overload) PackFoo(i *big.Int, j *big.Int) ([]byte, error) { + return _Overload.abi.Pack("foo", i, j) +} + +// Foo0 is a free data retrieval call binding the contract method 0x2fbebd38. +// +// Solidity: function foo(uint256 i) returns() +func (_Overload *Overload) PackFoo0(i *big.Int) ([]byte, error) { + return _Overload.abi.Pack("foo0", i) +} + +// OverloadBar represents a Bar event raised by the Overload contract. +type OverloadBar struct { + I *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const OverloadBarEventName = "bar" + +func (_Overload *Overload) UnpackBarEvent(log *types.Log) (*OverloadBar, error) { + event := "bar" + if log.Topics[0] != _Overload.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(OverloadBar) + if len(log.Data) > 0 { + if err := _Overload.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Overload.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 +} + +// OverloadBar0 represents a Bar0 event raised by the Overload contract. +type OverloadBar0 struct { + I *big.Int + J *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const OverloadBar0EventName = "bar0" + +func (_Overload *Overload) UnpackBar0Event(log *types.Log) (*OverloadBar0, error) { + event := "bar0" + if log.Topics[0] != _Overload.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(OverloadBar0) + if len(log.Data) > 0 { + if err := _Overload.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Overload.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/convertedv1bindtests/rangekeyword.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/rangekeyword.go new file mode 100644 index 000000000000..e9a957d66c24 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/rangekeyword.go @@ -0,0 +1,58 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// RangeKeywordMetaData contains all meta data concerning the RangeKeyword contract. +var RangeKeywordMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"range\",\"type\":\"uint256\"}],\"name\":\"functionWithKeywordParameter\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "cec8c872ba06feb1b8f0a00e7b237eb226", + Bin: "0x608060405234801561001057600080fd5b5060dc8061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063527a119f14602d575b600080fd5b60436004803603810190603f9190605b565b6045565b005b50565b6000813590506055816092565b92915050565b600060208284031215606e57606d608d565b5b6000607a848285016048565b91505092915050565b6000819050919050565b600080fd5b6099816083565b811460a357600080fd5b5056fea2646970667358221220d4f4525e2615516394055d369fb17df41c359e5e962734f27fd683ea81fd9db164736f6c63430008070033", +} + +// RangeKeyword is an auto generated Go binding around an Ethereum contract. +type RangeKeyword struct { + abi abi.ABI +} + +// NewRangeKeyword creates a new instance of RangeKeyword. +func NewRangeKeyword() (*RangeKeyword, error) { + parsed, err := RangeKeywordMetaData.GetAbi() + if err != nil { + return nil, err + } + return &RangeKeyword{abi: *parsed}, nil +} + +func (_RangeKeyword *RangeKeyword) PackConstructor() []byte { + res, _ := _RangeKeyword.abi.Pack("") + return res +} + +// FunctionWithKeywordParameter is a free data retrieval call binding the contract method 0x527a119f. +// +// Solidity: function functionWithKeywordParameter(uint256 range) pure returns() +func (_RangeKeyword *RangeKeyword) PackFunctionWithKeywordParameter(arg0 *big.Int) ([]byte, error) { + return _RangeKeyword.abi.Pack("functionWithKeywordParameter", arg0) +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/slicer.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/slicer.go new file mode 100644 index 000000000000..8deb68d012c2 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/slicer.go @@ -0,0 +1,131 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// SlicerMetaData contains all meta data concerning the Slicer contract. +var SlicerMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"address[]\"}],\"name\":\"echoAddresses\",\"outputs\":[{\"name\":\"output\",\"type\":\"address[]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"uint24[23]\"}],\"name\":\"echoFancyInts\",\"outputs\":[{\"name\":\"output\",\"type\":\"uint24[23]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"int256[]\"}],\"name\":\"echoInts\",\"outputs\":[{\"name\":\"output\",\"type\":\"int256[]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"bool[]\"}],\"name\":\"echoBools\",\"outputs\":[{\"name\":\"output\",\"type\":\"bool[]\"}],\"type\":\"function\"}]", + Pattern: "082c0740ab6537c7169cb573d097c52112", + Bin: "0x606060405261015c806100126000396000f3606060405260e060020a6000350463be1127a3811461003c578063d88becc014610092578063e15a3db71461003c578063f637e5891461003c575b005b604080516020600480358082013583810285810185019096528085526100ee959294602494909392850192829185019084908082843750949650505050505050604080516020810190915260009052805b919050565b604080516102e0818101909252610138916004916102e491839060179083908390808284375090955050505050506102e0604051908101604052806017905b60008152602001906001900390816100d15790505081905061008d565b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600f02600301f1509050019250505060405180910390f35b60405180826102e0808381846000600461015cf15090500191505060405180910390f3", +} + +// Slicer is an auto generated Go binding around an Ethereum contract. +type Slicer struct { + abi abi.ABI +} + +// NewSlicer creates a new instance of Slicer. +func NewSlicer() (*Slicer, error) { + parsed, err := SlicerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Slicer{abi: *parsed}, nil +} + +func (_Slicer *Slicer) PackConstructor() []byte { + res, _ := _Slicer.abi.Pack("") + return res +} + +// EchoAddresses is a free data retrieval call binding the contract method 0xbe1127a3. +// +// Solidity: function echoAddresses(address[] input) returns(address[] output) +func (_Slicer *Slicer) PackEchoAddresses(input []common.Address) ([]byte, error) { + return _Slicer.abi.Pack("echoAddresses", input) +} + +func (_Slicer *Slicer) UnpackEchoAddresses(data []byte) ([]common.Address, error) { + out, err := _Slicer.abi.Unpack("echoAddresses", data) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// EchoBools is a free data retrieval call binding the contract method 0xf637e589. +// +// Solidity: function echoBools(bool[] input) returns(bool[] output) +func (_Slicer *Slicer) PackEchoBools(input []bool) ([]byte, error) { + return _Slicer.abi.Pack("echoBools", input) +} + +func (_Slicer *Slicer) UnpackEchoBools(data []byte) ([]bool, error) { + out, err := _Slicer.abi.Unpack("echoBools", data) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// EchoFancyInts is a free data retrieval call binding the contract method 0xd88becc0. +// +// Solidity: function echoFancyInts(uint24[23] input) returns(uint24[23] output) +func (_Slicer *Slicer) PackEchoFancyInts(input [23]*big.Int) ([]byte, error) { + return _Slicer.abi.Pack("echoFancyInts", input) +} + +func (_Slicer *Slicer) UnpackEchoFancyInts(data []byte) ([23]*big.Int, error) { + out, err := _Slicer.abi.Unpack("echoFancyInts", data) + + if err != nil { + return *new([23]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([23]*big.Int)).(*[23]*big.Int) + + return out0, err + +} + +// EchoInts is a free data retrieval call binding the contract method 0xe15a3db7. +// +// Solidity: function echoInts(int256[] input) returns(int256[] output) +func (_Slicer *Slicer) PackEchoInts(input []*big.Int) ([]byte, error) { + return _Slicer.abi.Pack("echoInts", input) +} + +func (_Slicer *Slicer) UnpackEchoInts(data []byte) ([]*big.Int, error) { + out, err := _Slicer.abi.Unpack("echoInts", 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/convertedv1bindtests/structs.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/structs.go new file mode 100644 index 000000000000..0e0d116fa6bb --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/structs.go @@ -0,0 +1,105 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// Struct0 is an auto generated low-level Go binding around an user-defined struct. +type Struct0 struct { + B [32]byte +} + +// TODO: convert this type to value type after everything works. +// StructsMetaData contains all meta data concerning the Structs contract. +var StructsMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"F\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"c\",\"type\":\"uint256[]\"},{\"internalType\":\"bool[]\",\"name\":\"d\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"G\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Pattern: "920a35318e7581766aec7a17218628a91d", + Bin: "0x608060405234801561001057600080fd5b50610278806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806328811f591461003b5780636fecb6231461005b575b600080fd5b610043610070565b604051610052939291906101a0565b60405180910390f35b6100636100d6565b6040516100529190610186565b604080516002808252606082810190935282918291829190816020015b610095610131565b81526020019060019003908161008d575050805190915061026960611b9082906000906100be57fe5b60209081029190910101515293606093508392509050565b6040805160028082526060828101909352829190816020015b6100f7610131565b8152602001906001900390816100ef575050805190915061026960611b90829060009061012057fe5b602090810291909101015152905090565b60408051602081019091526000815290565b815260200190565b6000815180845260208085019450808401835b8381101561017b578151518752958201959082019060010161015e565b509495945050505050565b600060208252610199602083018461014b565b9392505050565b6000606082526101b3606083018661014b565b6020838203818501528186516101c98185610239565b91508288019350845b818110156101f3576101e5838651610143565b9484019492506001016101d2565b505084810360408601528551808252908201925081860190845b8181101561022b57825115158552938301939183019160010161020d565b509298975050505050505050565b9081526020019056fea2646970667358221220eb85327e285def14230424c52893aebecec1e387a50bb6b75fc4fdbed647f45f64736f6c63430006050033", +} + +// Structs is an auto generated Go binding around an Ethereum contract. +type Structs struct { + abi abi.ABI +} + +// NewStructs creates a new instance of Structs. +func NewStructs() (*Structs, error) { + parsed, err := StructsMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Structs{abi: *parsed}, nil +} + +func (_Structs *Structs) PackConstructor() []byte { + res, _ := _Structs.abi.Pack("") + return res +} + +// F is a free data retrieval call binding the contract method 0x28811f59. +// +// Solidity: function F() view returns((bytes32)[] a, uint256[] c, bool[] d) +func (_Structs *Structs) PackF() ([]byte, error) { + return _Structs.abi.Pack("F") +} + +type FOutput struct { + A []Struct0 + C []*big.Int + D []bool +} + +func (_Structs *Structs) UnpackF(data []byte) (FOutput, error) { + out, err := _Structs.abi.Unpack("F", data) + + outstruct := new(FOutput) + if err != nil { + return *outstruct, err + } + + outstruct.A = *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0) + outstruct.C = *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int) + outstruct.D = *abi.ConvertType(out[2], new([]bool)).(*[]bool) + + return *outstruct, err + +} + +// G is a free data retrieval call binding the contract method 0x6fecb623. +// +// Solidity: function G() view returns((bytes32)[] a) +func (_Structs *Structs) PackG() ([]byte, error) { + return _Structs.abi.Pack("G") +} + +func (_Structs *Structs) UnpackG(data []byte) ([]Struct0, error) { + out, err := _Structs.abi.Unpack("G", data) + + if err != nil { + return *new([]Struct0), err + } + + out0 := *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0) + + return out0, err + +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/token.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/token.go new file mode 100644 index 000000000000..27452999bd71 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/token.go @@ -0,0 +1,252 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// TokenMetaData contains all meta data concerning the Token contract. +var TokenMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"},{\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"spentAllowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"inputs\":[{\"name\":\"initialSupply\",\"type\":\"uint256\"},{\"name\":\"tokenName\",\"type\":\"string\"},{\"name\":\"decimalUnits\",\"type\":\"uint8\"},{\"name\":\"tokenSymbol\",\"type\":\"string\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]", + Pattern: "1317f51c845ce3bfb7c268e5337a825f12", + Bin: "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", +} + +// Token is an auto generated Go binding around an Ethereum contract. +type Token struct { + abi abi.ABI +} + +// NewToken creates a new instance of Token. +func NewToken() (*Token, error) { + parsed, err := TokenMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Token{abi: *parsed}, nil +} + +func (_Token *Token) PackConstructor(initialSupply *big.Int, tokenName string, decimalUnits uint8, tokenSymbol string) []byte { + res, _ := _Token.abi.Pack("", initialSupply, tokenName, decimalUnits, tokenSymbol) + return res +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address , address ) returns(uint256) +func (_Token *Token) PackAllowance(arg0 common.Address, arg1 common.Address) ([]byte, error) { + return _Token.abi.Pack("allowance", arg0, arg1) +} + +func (_Token *Token) UnpackAllowance(data []byte) (*big.Int, error) { + out, err := _Token.abi.Unpack("allowance", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ApproveAndCall is a free data retrieval call binding the contract method 0xcae9ca51. +// +// Solidity: function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns(bool success) +func (_Token *Token) PackApproveAndCall(_spender common.Address, _value *big.Int, _extraData []byte) ([]byte, error) { + return _Token.abi.Pack("approveAndCall", _spender, _value, _extraData) +} + +func (_Token *Token) UnpackApproveAndCall(data []byte) (bool, error) { + out, err := _Token.abi.Unpack("approveAndCall", data) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address ) returns(uint256) +func (_Token *Token) PackBalanceOf(arg0 common.Address) ([]byte, error) { + return _Token.abi.Pack("balanceOf", arg0) +} + +func (_Token *Token) UnpackBalanceOf(data []byte) (*big.Int, error) { + out, err := _Token.abi.Unpack("balanceOf", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() returns(uint8) +func (_Token *Token) PackDecimals() ([]byte, error) { + return _Token.abi.Pack("decimals") +} + +func (_Token *Token) UnpackDecimals(data []byte) (uint8, error) { + out, err := _Token.abi.Unpack("decimals", data) + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() returns(string) +func (_Token *Token) PackName() ([]byte, error) { + return _Token.abi.Pack("name") +} + +func (_Token *Token) UnpackName(data []byte) (string, error) { + out, err := _Token.abi.Unpack("name", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// SpentAllowance is a free data retrieval call binding the contract method 0xdc3080f2. +// +// Solidity: function spentAllowance(address , address ) returns(uint256) +func (_Token *Token) PackSpentAllowance(arg0 common.Address, arg1 common.Address) ([]byte, error) { + return _Token.abi.Pack("spentAllowance", arg0, arg1) +} + +func (_Token *Token) UnpackSpentAllowance(data []byte) (*big.Int, error) { + out, err := _Token.abi.Unpack("spentAllowance", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() returns(string) +func (_Token *Token) PackSymbol() ([]byte, error) { + return _Token.abi.Pack("symbol") +} + +func (_Token *Token) UnpackSymbol(data []byte) (string, error) { + out, err := _Token.abi.Unpack("symbol", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Transfer is a free data retrieval call binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_Token *Token) PackTransfer(_to common.Address, _value *big.Int) ([]byte, error) { + return _Token.abi.Pack("transfer", _to, _value) +} + +// TransferFrom is a free data retrieval call binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success) +func (_Token *Token) PackTransferFrom(_from common.Address, _to common.Address, _value *big.Int) ([]byte, error) { + return _Token.abi.Pack("transferFrom", _from, _to, _value) +} + +func (_Token *Token) UnpackTransferFrom(data []byte) (bool, error) { + out, err := _Token.abi.Unpack("transferFrom", data) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// TokenTransfer represents a Transfer event raised by the Token contract. +type TokenTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const TokenTransferEventName = "Transfer" + +func (_Token *Token) UnpackTransferEvent(log *types.Log) (*TokenTransfer, error) { + event := "Transfer" + if log.Topics[0] != _Token.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(TokenTransfer) + if len(log.Data) > 0 { + if err := _Token.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Token.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/convertedv1bindtests/tuple.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/tuple.go new file mode 100644 index 000000000000..602a3d8887c7 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/tuple.go @@ -0,0 +1,191 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TupleP is an auto generated low-level Go binding around an user-defined struct. +type TupleP struct { + X uint8 + Y uint8 +} + +// TupleQ is an auto generated low-level Go binding around an user-defined struct. +type TupleQ struct { + X uint16 + Y uint16 +} + +// TupleS is an auto generated low-level Go binding around an user-defined struct. +type TupleS struct { + A *big.Int + B []*big.Int + C []TupleT +} + +// TupleT is an auto generated low-level Go binding around an user-defined struct. +type TupleT struct { + X *big.Int + Y *big.Int +} + +// TODO: convert this type to value type after everything works. +// TupleMetaData contains all meta data concerning the Tuple contract. +var TupleMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"indexed\":false,\"internalType\":\"structTuple.S\",\"name\":\"a\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"structTuple.T[2][]\",\"name\":\"b\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"structTuple.T[][2]\",\"name\":\"c\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"indexed\":false,\"internalType\":\"structTuple.S[]\",\"name\":\"d\",\"type\":\"tuple[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"e\",\"type\":\"uint256[]\"}],\"name\":\"TupleEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"x\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"y\",\"type\":\"uint8\"}],\"indexed\":false,\"internalType\":\"structTuple.P[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"name\":\"TupleEvent2\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S\",\"name\":\"a\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[2][]\",\"name\":\"b\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[][2]\",\"name\":\"c\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S[]\",\"name\":\"d\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"e\",\"type\":\"uint256[]\"}],\"name\":\"func1\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S\",\"name\":\"\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[2][]\",\"name\":\"\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[][2]\",\"name\":\"\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S[]\",\"name\":\"\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S\",\"name\":\"a\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[2][]\",\"name\":\"b\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[][2]\",\"name\":\"c\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S[]\",\"name\":\"d\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"e\",\"type\":\"uint256[]\"}],\"name\":\"func2\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"y\",\"type\":\"uint16\"}],\"internalType\":\"structTuple.Q[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"name\":\"func3\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Pattern: "96ee1e2b1b89f8c495f200e4956278a4d4", + Bin: "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", +} + +// Tuple is an auto generated Go binding around an Ethereum contract. +type Tuple struct { + abi abi.ABI +} + +// NewTuple creates a new instance of Tuple. +func NewTuple() (*Tuple, error) { + parsed, err := TupleMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Tuple{abi: *parsed}, nil +} + +func (_Tuple *Tuple) PackConstructor() []byte { + res, _ := _Tuple.abi.Pack("") + return res +} + +// Func1 is a free data retrieval call binding the contract method 0x443c79b4. +// +// Solidity: function func1((uint256,uint256[],(uint256,uint256)[]) a, (uint256,uint256)[2][] b, (uint256,uint256)[][2] c, (uint256,uint256[],(uint256,uint256)[])[] d, uint256[] e) pure returns((uint256,uint256[],(uint256,uint256)[]), (uint256,uint256)[2][], (uint256,uint256)[][2], (uint256,uint256[],(uint256,uint256)[])[], uint256[]) +func (_Tuple *Tuple) PackFunc1(a TupleS, b [][2]TupleT, c [2][]TupleT, d []TupleS, e []*big.Int) ([]byte, error) { + return _Tuple.abi.Pack("func1", a, b, c, d, e) +} + +type Func1Output struct { + Arg TupleS + Arg0 [][2]TupleT + Arg1 [2][]TupleT + Arg2 []TupleS + Arg3 []*big.Int +} + +func (_Tuple *Tuple) UnpackFunc1(data []byte) (Func1Output, error) { + out, err := _Tuple.abi.Unpack("func1", data) + + outstruct := new(Func1Output) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(TupleS)).(*TupleS) + outstruct.Arg0 = *abi.ConvertType(out[1], new([][2]TupleT)).(*[][2]TupleT) + outstruct.Arg1 = *abi.ConvertType(out[2], new([2][]TupleT)).(*[2][]TupleT) + outstruct.Arg2 = *abi.ConvertType(out[3], new([]TupleS)).(*[]TupleS) + outstruct.Arg3 = *abi.ConvertType(out[4], new([]*big.Int)).(*[]*big.Int) + + return *outstruct, err + +} + +// Func2 is a free data retrieval call binding the contract method 0xd0062cdd. +// +// Solidity: function func2((uint256,uint256[],(uint256,uint256)[]) a, (uint256,uint256)[2][] b, (uint256,uint256)[][2] c, (uint256,uint256[],(uint256,uint256)[])[] d, uint256[] e) returns() +func (_Tuple *Tuple) PackFunc2(a TupleS, b [][2]TupleT, c [2][]TupleT, d []TupleS, e []*big.Int) ([]byte, error) { + return _Tuple.abi.Pack("func2", a, b, c, d, e) +} + +// Func3 is a free data retrieval call binding the contract method 0xe4d9a43b. +// +// Solidity: function func3((uint16,uint16)[] ) pure returns() +func (_Tuple *Tuple) PackFunc3(arg0 []TupleQ) ([]byte, error) { + return _Tuple.abi.Pack("func3", arg0) +} + +// TupleTupleEvent represents a TupleEvent event raised by the Tuple contract. +type TupleTupleEvent struct { + A TupleS + B [][2]TupleT + C [2][]TupleT + D []TupleS + E []*big.Int + Raw *types.Log // Blockchain specific contextual infos +} + +const TupleTupleEventEventName = "TupleEvent" + +func (_Tuple *Tuple) UnpackTupleEventEvent(log *types.Log) (*TupleTupleEvent, error) { + event := "TupleEvent" + if log.Topics[0] != _Tuple.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(TupleTupleEvent) + if len(log.Data) > 0 { + if err := _Tuple.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Tuple.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 +} + +// TupleTupleEvent2 represents a TupleEvent2 event raised by the Tuple contract. +type TupleTupleEvent2 struct { + Arg0 []TupleP + Raw *types.Log // Blockchain specific contextual infos +} + +const TupleTupleEvent2EventName = "TupleEvent2" + +func (_Tuple *Tuple) UnpackTupleEvent2Event(log *types.Log) (*TupleTupleEvent2, error) { + event := "TupleEvent2" + if log.Topics[0] != _Tuple.abi.Events[event].ID { + return nil, errors.New("event signature mismatch") + } + out := new(TupleTupleEvent2) + if len(log.Data) > 0 { + if err := _Tuple.abi.UnpackIntoInterface(out, event, log.Data); err != nil { + return nil, err + } + } + var indexed abi.Arguments + for _, arg := range _Tuple.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/convertedv1bindtests/tupler.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/tupler.go new file mode 100644 index 000000000000..d315611b3f16 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/tupler.go @@ -0,0 +1,80 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// TuplerMetaData contains all meta data concerning the Tupler contract. +var TuplerMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"tuple\",\"outputs\":[{\"name\":\"a\",\"type\":\"string\"},{\"name\":\"b\",\"type\":\"int256\"},{\"name\":\"c\",\"type\":\"bytes32\"}],\"type\":\"function\"}]", + Pattern: "a8f4d2061f55c712cfae266c426a1cd568", + Bin: "0x606060405260dc8060106000396000f3606060405260e060020a60003504633175aae28114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3", +} + +// Tupler is an auto generated Go binding around an Ethereum contract. +type Tupler struct { + abi abi.ABI +} + +// NewTupler creates a new instance of Tupler. +func NewTupler() (*Tupler, error) { + parsed, err := TuplerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Tupler{abi: *parsed}, nil +} + +func (_Tupler *Tupler) PackConstructor() []byte { + res, _ := _Tupler.abi.Pack("") + return res +} + +// Tuple is a free data retrieval call binding the contract method 0x3175aae2. +// +// Solidity: function tuple() returns(string a, int256 b, bytes32 c) +func (_Tupler *Tupler) PackTuple() ([]byte, error) { + return _Tupler.abi.Pack("tuple") +} + +type TupleOutput struct { + A string + B *big.Int + C [32]byte +} + +func (_Tupler *Tupler) UnpackTuple(data []byte) (TupleOutput, error) { + out, err := _Tupler.abi.Unpack("tuple", data) + + outstruct := new(TupleOutput) + if err != nil { + return *outstruct, err + } + + outstruct.A = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.B = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.C = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} diff --git a/accounts/abi/bind/v2/internal/convertedv1bindtests/underscorer.go b/accounts/abi/bind/v2/internal/convertedv1bindtests/underscorer.go new file mode 100644 index 000000000000..0ad5c5e3e951 --- /dev/null +++ b/accounts/abi/bind/v2/internal/convertedv1bindtests/underscorer.go @@ -0,0 +1,260 @@ +// Code generated via abigen V2 - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package convertedv1bindtests + +import ( + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = abi.ConvertType +) + +// TODO: convert this type to value type after everything works. +// UnderscorerMetaData contains all meta data concerning the Underscorer contract. +var UnderscorerMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"LowerUpperCollision\",\"outputs\":[{\"name\":\"_res\",\"type\":\"int256\"},{\"name\":\"Res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_under_scored_func\",\"outputs\":[{\"name\":\"_int\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UnderscoredOutput\",\"outputs\":[{\"name\":\"_int\",\"type\":\"int256\"},{\"name\":\"_string\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"PurelyUnderscoredOutput\",\"outputs\":[{\"name\":\"_\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UpperLowerCollision\",\"outputs\":[{\"name\":\"_Res\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"AllPurelyUnderscoredOutput\",\"outputs\":[{\"name\":\"_\",\"type\":\"int256\"},{\"name\":\"__\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UpperUpperCollision\",\"outputs\":[{\"name\":\"_Res\",\"type\":\"int256\"},{\"name\":\"Res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"LowerLowerCollision\",\"outputs\":[{\"name\":\"_res\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", + Pattern: "5873a90ab43c925dfced86ad53f871f01d", + Bin: "0x6060604052341561000f57600080fd5b6103858061001e6000396000f30060606040526004361061008e576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806303a592131461009357806346546dbe146100c357806367e6633d146100ec5780639df4848514610181578063af7486ab146101b1578063b564b34d146101e1578063e02ab24d14610211578063e409ca4514610241575b600080fd5b341561009e57600080fd5b6100a6610271565b604051808381526020018281526020019250505060405180910390f35b34156100ce57600080fd5b6100d6610286565b6040518082815260200191505060405180910390f35b34156100f757600080fd5b6100ff61028e565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561014557808201518184015260208101905061012a565b50505050905090810190601f1680156101725780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561018c57600080fd5b6101946102dc565b604051808381526020018281526020019250505060405180910390f35b34156101bc57600080fd5b6101c46102f1565b604051808381526020018281526020019250505060405180910390f35b34156101ec57600080fd5b6101f4610306565b604051808381526020018281526020019250505060405180910390f35b341561021c57600080fd5b61022461031b565b604051808381526020018281526020019250505060405180910390f35b341561024c57600080fd5b610254610330565b604051808381526020018281526020019250505060405180910390f35b60008060016002819150809050915091509091565b600080905090565b6000610298610345565b61013a8090506040805190810160405280600281526020017f7069000000000000000000000000000000000000000000000000000000000000815250915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b6020604051908101604052806000815250905600a165627a7a72305820d1a53d9de9d1e3d55cb3dc591900b63c4f1ded79114f7b79b332684840e186a40029", +} + +// Underscorer is an auto generated Go binding around an Ethereum contract. +type Underscorer struct { + abi abi.ABI +} + +// NewUnderscorer creates a new instance of Underscorer. +func NewUnderscorer() (*Underscorer, error) { + parsed, err := UnderscorerMetaData.GetAbi() + if err != nil { + return nil, err + } + return &Underscorer{abi: *parsed}, nil +} + +func (_Underscorer *Underscorer) PackConstructor() []byte { + res, _ := _Underscorer.abi.Pack("") + return res +} + +// AllPurelyUnderscoredOutput is a free data retrieval call binding the contract method 0xb564b34d. +// +// Solidity: function AllPurelyUnderscoredOutput() view returns(int256 _, int256 __) +func (_Underscorer *Underscorer) PackAllPurelyUnderscoredOutput() ([]byte, error) { + return _Underscorer.abi.Pack("AllPurelyUnderscoredOutput") +} + +type AllPurelyUnderscoredOutputOutput struct { + Arg *big.Int + Arg0 *big.Int +} + +func (_Underscorer *Underscorer) UnpackAllPurelyUnderscoredOutput(data []byte) (AllPurelyUnderscoredOutputOutput, error) { + out, err := _Underscorer.abi.Unpack("AllPurelyUnderscoredOutput", data) + + outstruct := new(AllPurelyUnderscoredOutputOutput) + 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) + + return *outstruct, err + +} + +// LowerLowerCollision is a free data retrieval call binding the contract method 0xe409ca45. +// +// Solidity: function LowerLowerCollision() view returns(int256 _res, int256 res) +func (_Underscorer *Underscorer) PackLowerLowerCollision() ([]byte, error) { + return _Underscorer.abi.Pack("LowerLowerCollision") +} + +type LowerLowerCollisionOutput struct { + Res *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackLowerLowerCollision(data []byte) (LowerLowerCollisionOutput, error) { + out, err := _Underscorer.abi.Unpack("LowerLowerCollision", data) + + outstruct := new(LowerLowerCollisionOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// LowerUpperCollision is a free data retrieval call binding the contract method 0x03a59213. +// +// Solidity: function LowerUpperCollision() view returns(int256 _res, int256 Res) +func (_Underscorer *Underscorer) PackLowerUpperCollision() ([]byte, error) { + return _Underscorer.abi.Pack("LowerUpperCollision") +} + +type LowerUpperCollisionOutput struct { + Res *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackLowerUpperCollision(data []byte) (LowerUpperCollisionOutput, error) { + out, err := _Underscorer.abi.Unpack("LowerUpperCollision", data) + + outstruct := new(LowerUpperCollisionOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// PurelyUnderscoredOutput is a free data retrieval call binding the contract method 0x9df48485. +// +// Solidity: function PurelyUnderscoredOutput() view returns(int256 _, int256 res) +func (_Underscorer *Underscorer) PackPurelyUnderscoredOutput() ([]byte, error) { + return _Underscorer.abi.Pack("PurelyUnderscoredOutput") +} + +type PurelyUnderscoredOutputOutput struct { + Arg *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackPurelyUnderscoredOutput(data []byte) (PurelyUnderscoredOutputOutput, error) { + out, err := _Underscorer.abi.Unpack("PurelyUnderscoredOutput", data) + + outstruct := new(PurelyUnderscoredOutputOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Arg = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// UnderscoredOutput is a free data retrieval call binding the contract method 0x67e6633d. +// +// Solidity: function UnderscoredOutput() view returns(int256 _int, string _string) +func (_Underscorer *Underscorer) PackUnderscoredOutput() ([]byte, error) { + return _Underscorer.abi.Pack("UnderscoredOutput") +} + +type UnderscoredOutputOutput struct { + Int *big.Int + String string +} + +func (_Underscorer *Underscorer) UnpackUnderscoredOutput(data []byte) (UnderscoredOutputOutput, error) { + out, err := _Underscorer.abi.Unpack("UnderscoredOutput", data) + + outstruct := new(UnderscoredOutputOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Int = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.String = *abi.ConvertType(out[1], new(string)).(*string) + + return *outstruct, err + +} + +// UpperLowerCollision is a free data retrieval call binding the contract method 0xaf7486ab. +// +// Solidity: function UpperLowerCollision() view returns(int256 _Res, int256 res) +func (_Underscorer *Underscorer) PackUpperLowerCollision() ([]byte, error) { + return _Underscorer.abi.Pack("UpperLowerCollision") +} + +type UpperLowerCollisionOutput struct { + Res *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackUpperLowerCollision(data []byte) (UpperLowerCollisionOutput, error) { + out, err := _Underscorer.abi.Unpack("UpperLowerCollision", data) + + outstruct := new(UpperLowerCollisionOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// UpperUpperCollision is a free data retrieval call binding the contract method 0xe02ab24d. +// +// Solidity: function UpperUpperCollision() view returns(int256 _Res, int256 Res) +func (_Underscorer *Underscorer) PackUpperUpperCollision() ([]byte, error) { + return _Underscorer.abi.Pack("UpperUpperCollision") +} + +type UpperUpperCollisionOutput struct { + Res *big.Int + Res *big.Int +} + +func (_Underscorer *Underscorer) UnpackUpperUpperCollision(data []byte) (UpperUpperCollisionOutput, error) { + out, err := _Underscorer.abi.Unpack("UpperUpperCollision", data) + + outstruct := new(UpperUpperCollisionOutput) + if err != nil { + return *outstruct, err + } + + outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// UnderScoredFunc is a free data retrieval call binding the contract method 0x46546dbe. +// +// Solidity: function _under_scored_func() view returns(int256 _int) +func (_Underscorer *Underscorer) PackUnderScoredFunc() ([]byte, error) { + return _Underscorer.abi.Pack("_under_scored_func") +} + +func (_Underscorer *Underscorer) UnpackUnderScoredFunc(data []byte) (*big.Int, error) { + out, err := _Underscorer.abi.Unpack("_under_scored_func", data) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} From 8b33f640477b3d1d8d4f2983800bb2737015c95a Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 30 Dec 2024 15:59:22 +0700 Subject: [PATCH 102/104] accounts/abi/bind/v2: fix lib_test.go (update test to reflect that bindings changed s.t. constructor unpack does not return error) --- accounts/abi/bind/v2/lib_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/accounts/abi/bind/v2/lib_test.go b/accounts/abi/bind/v2/lib_test.go index 1bd8104b144b..a2c792aa8fee 100644 --- a/accounts/abi/bind/v2/lib_test.go +++ b/accounts/abi/bind/v2/lib_test.go @@ -117,7 +117,7 @@ func TestDeploymentLibraries(t *testing.T) { panic(err) } - constructorInput, err := ctrct.PackConstructor(big.NewInt(42), big.NewInt(1)) + constructorInput := ctrct.PackConstructor(big.NewInt(42), big.NewInt(1)) if err != nil { t.Fatalf("failed to pack constructor: %v", err) } @@ -199,7 +199,7 @@ func TestDeploymentWithOverrides(t *testing.T) { if err != nil { panic(err) } - constructorInput, err := ctrct.PackConstructor(big.NewInt(42), big.NewInt(1)) + constructorInput := ctrct.PackConstructor(big.NewInt(42), big.NewInt(1)) if err != nil { t.Fatalf("failed to pack constructor: %v", err) } From 50f8694521d89efac5bb1cbf6c2dfa392b9f6d8b Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 30 Dec 2024 15:59:53 +0700 Subject: [PATCH 103/104] accounts/abi/bind: remove duplicate convertedv1bindtests --- .../convertedv1bindtests/callbackparam.go | 58 -- .../bind/convertedv1bindtests/crowdsale.go | 239 -------- accounts/abi/bind/convertedv1bindtests/dao.go | 516 ------------------ .../convertedv1bindtests/deeplynestedarray.go | 98 ---- .../abi/bind/convertedv1bindtests/empty.go | 51 -- .../bind/convertedv1bindtests/eventchecker.go | 215 -------- .../abi/bind/convertedv1bindtests/getter.go | 80 --- .../identifiercollision.go | 91 --- .../bind/convertedv1bindtests/inputchecker.go | 92 ---- .../bind/convertedv1bindtests/interactor.go | 98 ---- .../bind/convertedv1bindtests/nameconflict.go | 117 ---- .../convertedv1bindtests/numericmethodname.go | 104 ---- .../convertedv1bindtests/outputchecker.go | 205 ------- .../abi/bind/convertedv1bindtests/overload.go | 130 ----- .../bind/convertedv1bindtests/rangekeyword.go | 58 -- .../abi/bind/convertedv1bindtests/slicer.go | 131 ----- .../abi/bind/convertedv1bindtests/structs.go | 105 ---- .../abi/bind/convertedv1bindtests/token.go | 252 --------- .../abi/bind/convertedv1bindtests/tuple.go | 191 ------- .../abi/bind/convertedv1bindtests/tupler.go | 80 --- .../bind/convertedv1bindtests/underscorer.go | 260 --------- 21 files changed, 3171 deletions(-) delete mode 100644 accounts/abi/bind/convertedv1bindtests/callbackparam.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/crowdsale.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/dao.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/deeplynestedarray.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/empty.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/eventchecker.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/getter.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/identifiercollision.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/inputchecker.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/interactor.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/nameconflict.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/numericmethodname.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/outputchecker.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/overload.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/rangekeyword.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/slicer.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/structs.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/token.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/tuple.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/tupler.go delete mode 100644 accounts/abi/bind/convertedv1bindtests/underscorer.go diff --git a/accounts/abi/bind/convertedv1bindtests/callbackparam.go b/accounts/abi/bind/convertedv1bindtests/callbackparam.go deleted file mode 100644 index 6e951829b68f..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/callbackparam.go +++ /dev/null @@ -1,58 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// CallbackParamMetaData contains all meta data concerning the CallbackParam contract. -var CallbackParamMetaData = &bind.MetaData{ - ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"callback\",\"type\":\"function\"}],\"name\":\"test\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Pattern: "949f96f86d3c2e1bcc15563ad898beaaca", - Bin: "0x608060405234801561001057600080fd5b5061015e806100206000396000f3fe60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063d7a5aba214610040575b600080fd5b34801561004c57600080fd5b506100be6004803603602081101561006357600080fd5b810190808035806c0100000000000000000000000090049068010000000000000000900463ffffffff1677ffffffffffffffffffffffffffffffffffffffffffffffff169091602001919093929190939291905050506100c0565b005b818160016040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15801561011657600080fd5b505af115801561012a573d6000803e3d6000fd5b50505050505056fea165627a7a7230582062f87455ff84be90896dbb0c4e4ddb505c600d23089f8e80a512548440d7e2580029", -} - -// CallbackParam is an auto generated Go binding around an Ethereum contract. -type CallbackParam struct { - abi abi.ABI -} - -// NewCallbackParam creates a new instance of CallbackParam. -func NewCallbackParam() (*CallbackParam, error) { - parsed, err := CallbackParamMetaData.GetAbi() - if err != nil { - return nil, err - } - return &CallbackParam{abi: *parsed}, nil -} - -func (_CallbackParam *CallbackParam) PackConstructor() []byte { - res, _ := _CallbackParam.abi.Pack("") - return res -} - -// Test is a free data retrieval call binding the contract method 0xd7a5aba2. -// -// Solidity: function test(function callback) returns() -func (_CallbackParam *CallbackParam) PackTest(callback [24]byte) ([]byte, error) { - return _CallbackParam.abi.Pack("test", callback) -} diff --git a/accounts/abi/bind/convertedv1bindtests/crowdsale.go b/accounts/abi/bind/convertedv1bindtests/crowdsale.go deleted file mode 100644 index 66c17fff0132..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/crowdsale.go +++ /dev/null @@ -1,239 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// CrowdsaleMetaData contains all meta data concerning the Crowdsale contract. -var CrowdsaleMetaData = &bind.MetaData{ - ABI: "[{\"constant\":false,\"inputs\":[],\"name\":\"checkGoalReached\",\"outputs\":[],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"deadline\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"beneficiary\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tokenReward\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"fundingGoal\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"amountRaised\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"price\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"funders\",\"outputs\":[{\"name\":\"addr\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"inputs\":[{\"name\":\"ifSuccessfulSendTo\",\"type\":\"address\"},{\"name\":\"fundingGoalInEthers\",\"type\":\"uint256\"},{\"name\":\"durationInMinutes\",\"type\":\"uint256\"},{\"name\":\"etherCostOfEachToken\",\"type\":\"uint256\"},{\"name\":\"addressOfTokenUsedAsReward\",\"type\":\"address\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"backer\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"isContribution\",\"type\":\"bool\"}],\"name\":\"FundTransfer\",\"type\":\"event\"}]", - Pattern: "84d7e935785c5c648282d326307bb8fa0d", - Bin: "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", -} - -// Crowdsale is an auto generated Go binding around an Ethereum contract. -type Crowdsale struct { - abi abi.ABI -} - -// NewCrowdsale creates a new instance of Crowdsale. -func NewCrowdsale() (*Crowdsale, error) { - parsed, err := CrowdsaleMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Crowdsale{abi: *parsed}, nil -} - -func (_Crowdsale *Crowdsale) PackConstructor(ifSuccessfulSendTo common.Address, fundingGoalInEthers *big.Int, durationInMinutes *big.Int, etherCostOfEachToken *big.Int, addressOfTokenUsedAsReward common.Address) []byte { - res, _ := _Crowdsale.abi.Pack("", ifSuccessfulSendTo, fundingGoalInEthers, durationInMinutes, etherCostOfEachToken, addressOfTokenUsedAsReward) - return res -} - -// AmountRaised is a free data retrieval call binding the contract method 0x7b3e5e7b. -// -// Solidity: function amountRaised() returns(uint256) -func (_Crowdsale *Crowdsale) PackAmountRaised() ([]byte, error) { - return _Crowdsale.abi.Pack("amountRaised") -} - -func (_Crowdsale *Crowdsale) UnpackAmountRaised(data []byte) (*big.Int, error) { - out, err := _Crowdsale.abi.Unpack("amountRaised", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Beneficiary is a free data retrieval call binding the contract method 0x38af3eed. -// -// Solidity: function beneficiary() returns(address) -func (_Crowdsale *Crowdsale) PackBeneficiary() ([]byte, error) { - return _Crowdsale.abi.Pack("beneficiary") -} - -func (_Crowdsale *Crowdsale) UnpackBeneficiary(data []byte) (common.Address, error) { - out, err := _Crowdsale.abi.Unpack("beneficiary", data) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// CheckGoalReached is a free data retrieval call binding the contract method 0x01cb3b20. -// -// Solidity: function checkGoalReached() returns() -func (_Crowdsale *Crowdsale) PackCheckGoalReached() ([]byte, error) { - return _Crowdsale.abi.Pack("checkGoalReached") -} - -// Deadline is a free data retrieval call binding the contract method 0x29dcb0cf. -// -// Solidity: function deadline() returns(uint256) -func (_Crowdsale *Crowdsale) PackDeadline() ([]byte, error) { - return _Crowdsale.abi.Pack("deadline") -} - -func (_Crowdsale *Crowdsale) UnpackDeadline(data []byte) (*big.Int, error) { - out, err := _Crowdsale.abi.Unpack("deadline", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Funders is a free data retrieval call binding the contract method 0xdc0d3dff. -// -// Solidity: function funders(uint256 ) returns(address addr, uint256 amount) -func (_Crowdsale *Crowdsale) PackFunders(arg0 *big.Int) ([]byte, error) { - return _Crowdsale.abi.Pack("funders", arg0) -} - -type FundersOutput struct { - Addr common.Address - Amount *big.Int -} - -func (_Crowdsale *Crowdsale) UnpackFunders(data []byte) (FundersOutput, error) { - out, err := _Crowdsale.abi.Unpack("funders", data) - - outstruct := new(FundersOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Addr = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - outstruct.Amount = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// FundingGoal is a free data retrieval call binding the contract method 0x7a3a0e84. -// -// Solidity: function fundingGoal() returns(uint256) -func (_Crowdsale *Crowdsale) PackFundingGoal() ([]byte, error) { - return _Crowdsale.abi.Pack("fundingGoal") -} - -func (_Crowdsale *Crowdsale) UnpackFundingGoal(data []byte) (*big.Int, error) { - out, err := _Crowdsale.abi.Unpack("fundingGoal", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Price is a free data retrieval call binding the contract method 0xa035b1fe. -// -// Solidity: function price() returns(uint256) -func (_Crowdsale *Crowdsale) PackPrice() ([]byte, error) { - return _Crowdsale.abi.Pack("price") -} - -func (_Crowdsale *Crowdsale) UnpackPrice(data []byte) (*big.Int, error) { - out, err := _Crowdsale.abi.Unpack("price", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// TokenReward is a free data retrieval call binding the contract method 0x6e66f6e9. -// -// Solidity: function tokenReward() returns(address) -func (_Crowdsale *Crowdsale) PackTokenReward() ([]byte, error) { - return _Crowdsale.abi.Pack("tokenReward") -} - -func (_Crowdsale *Crowdsale) UnpackTokenReward(data []byte) (common.Address, error) { - out, err := _Crowdsale.abi.Unpack("tokenReward", data) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// CrowdsaleFundTransfer represents a FundTransfer event raised by the Crowdsale contract. -type CrowdsaleFundTransfer struct { - Backer common.Address - Amount *big.Int - IsContribution bool - Raw *types.Log // Blockchain specific contextual infos -} - -const CrowdsaleFundTransferEventName = "FundTransfer" - -func (_Crowdsale *Crowdsale) UnpackFundTransferEvent(log *types.Log) (*CrowdsaleFundTransfer, error) { - event := "FundTransfer" - if log.Topics[0] != _Crowdsale.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(CrowdsaleFundTransfer) - if len(log.Data) > 0 { - if err := _Crowdsale.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _Crowdsale.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/convertedv1bindtests/dao.go b/accounts/abi/bind/convertedv1bindtests/dao.go deleted file mode 100644 index 0d6b6e2f3b1d..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/dao.go +++ /dev/null @@ -1,516 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// DAOMetaData contains all meta data concerning the DAO contract. -var DAOMetaData = &bind.MetaData{ - ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"proposals\",\"outputs\":[{\"name\":\"recipient\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"},{\"name\":\"description\",\"type\":\"string\"},{\"name\":\"votingDeadline\",\"type\":\"uint256\"},{\"name\":\"executed\",\"type\":\"bool\"},{\"name\":\"proposalPassed\",\"type\":\"bool\"},{\"name\":\"numberOfVotes\",\"type\":\"uint256\"},{\"name\":\"currentResult\",\"type\":\"int256\"},{\"name\":\"proposalHash\",\"type\":\"bytes32\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"proposalNumber\",\"type\":\"uint256\"},{\"name\":\"transactionBytecode\",\"type\":\"bytes\"}],\"name\":\"executeProposal\",\"outputs\":[{\"name\":\"result\",\"type\":\"int256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"memberId\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"numProposals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"members\",\"outputs\":[{\"name\":\"member\",\"type\":\"address\"},{\"name\":\"canVote\",\"type\":\"bool\"},{\"name\":\"name\",\"type\":\"string\"},{\"name\":\"memberSince\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"debatingPeriodInMinutes\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"minimumQuorum\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"targetMember\",\"type\":\"address\"},{\"name\":\"canVote\",\"type\":\"bool\"},{\"name\":\"memberName\",\"type\":\"string\"}],\"name\":\"changeMembership\",\"outputs\":[],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"majorityMargin\",\"outputs\":[{\"name\":\"\",\"type\":\"int256\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"beneficiary\",\"type\":\"address\"},{\"name\":\"etherAmount\",\"type\":\"uint256\"},{\"name\":\"JobDescription\",\"type\":\"string\"},{\"name\":\"transactionBytecode\",\"type\":\"bytes\"}],\"name\":\"newProposal\",\"outputs\":[{\"name\":\"proposalID\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"minimumQuorumForProposals\",\"type\":\"uint256\"},{\"name\":\"minutesForDebate\",\"type\":\"uint256\"},{\"name\":\"marginOfVotesForMajority\",\"type\":\"int256\"}],\"name\":\"changeVotingRules\",\"outputs\":[],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"proposalNumber\",\"type\":\"uint256\"},{\"name\":\"supportsProposal\",\"type\":\"bool\"},{\"name\":\"justificationText\",\"type\":\"string\"}],\"name\":\"vote\",\"outputs\":[{\"name\":\"voteID\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"proposalNumber\",\"type\":\"uint256\"},{\"name\":\"beneficiary\",\"type\":\"address\"},{\"name\":\"etherAmount\",\"type\":\"uint256\"},{\"name\":\"transactionBytecode\",\"type\":\"bytes\"}],\"name\":\"checkProposalCode\",\"outputs\":[{\"name\":\"codeChecksOut\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"type\":\"function\"},{\"inputs\":[{\"name\":\"minimumQuorumForProposals\",\"type\":\"uint256\"},{\"name\":\"minutesForDebate\",\"type\":\"uint256\"},{\"name\":\"marginOfVotesForMajority\",\"type\":\"int256\"},{\"name\":\"congressLeader\",\"type\":\"address\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"proposalID\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"description\",\"type\":\"string\"}],\"name\":\"ProposalAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"proposalID\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"position\",\"type\":\"bool\"},{\"indexed\":false,\"name\":\"voter\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"justification\",\"type\":\"string\"}],\"name\":\"Voted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"proposalID\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"result\",\"type\":\"int256\"},{\"indexed\":false,\"name\":\"quorum\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"active\",\"type\":\"bool\"}],\"name\":\"ProposalTallied\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"member\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"isMember\",\"type\":\"bool\"}],\"name\":\"MembershipChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"minimumQuorum\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"debatingPeriodInMinutes\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"majorityMargin\",\"type\":\"int256\"}],\"name\":\"ChangeOfRules\",\"type\":\"event\"}]", - Pattern: "d0a4ad96d49edb1c33461cebc6fb260919", - Bin: "0x606060405260405160808061145f833960e06040529051905160a05160c05160008054600160a060020a03191633179055600184815560028490556003839055600780549182018082558280158290116100b8576003028160030283600052602060002091820191016100b891906101c8565b50506060919091015160029190910155600160a060020a0381166000146100a65760008054600160a060020a031916821790555b505050506111f18061026e6000396000f35b505060408051608081018252600080825260208281018290528351908101845281815292820192909252426060820152600780549194509250811015610002579081527fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c6889050815181546020848101517401000000000000000000000000000000000000000002600160a060020a03199290921690921760a060020a60ff021916178255604083015180516001848101805460008281528690209195600293821615610100026000190190911692909204601f9081018390048201949192919091019083901061023e57805160ff19168380011785555b50610072929150610226565b5050600060028201556001015b8082111561023a578054600160a860020a031916815560018181018054600080835592600290821615610100026000190190911604601f81901061020c57506101bb565b601f0160209004906000526020600020908101906101bb91905b8082111561023a5760008155600101610226565b5090565b828001600101855582156101af579182015b828111156101af57825182600050559160200191906001019061025056606060405236156100b95760e060020a6000350463013cf08b81146100bb578063237e9492146101285780633910682114610281578063400e3949146102995780635daf08ca146102a257806369bd34361461032f5780638160f0b5146103385780638da5cb5b146103415780639644fcbd14610353578063aa02a90f146103be578063b1050da5146103c7578063bcca1fd3146104b5578063d3c0715b146104dc578063eceb29451461058d578063f2fde38b1461067b575b005b61069c6004356004805482908110156100025790600052602060002090600a02016000506005810154815460018301546003840154600485015460068601546007870154600160a060020a03959095169750929560020194919360ff828116946101009093041692919089565b60408051602060248035600481810135601f81018590048502860185019096528585526107759581359591946044949293909201918190840183828082843750949650505050505050600060006004600050848154811015610002575090527f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19e600a8402908101547f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b909101904210806101e65750600481015460ff165b8061026757508060000160009054906101000a9004600160a060020a03168160010160005054846040518084600160a060020a0316606060020a0281526014018381526020018280519060200190808383829060006004602084601f0104600f02600301f15090500193505050506040518091039020816007016000505414155b8061027757506001546005820154105b1561109257610002565b61077560043560066020526000908152604090205481565b61077560055481565b61078760043560078054829081101561000257506000526003026000805160206111d18339815191528101547fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c68a820154600160a060020a0382169260a060020a90920460ff16917fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c689019084565b61077560025481565b61077560015481565b610830600054600160a060020a031681565b604080516020604435600481810135601f81018490048402850184019095528484526100b9948135946024803595939460649492939101918190840183828082843750949650505050505050600080548190600160a060020a03908116339091161461084d57610002565b61077560035481565b604080516020604435600481810135601f8101849004840285018401909552848452610775948135946024803595939460649492939101918190840183828082843750506040805160209735808a0135601f81018a90048a0283018a019093528282529698976084979196506024909101945090925082915084018382808284375094965050505050505033600160a060020a031660009081526006602052604081205481908114806104ab5750604081205460078054909190811015610002579082526003026000805160206111d1833981519152015460a060020a900460ff16155b15610ce557610002565b6100b960043560243560443560005433600160a060020a03908116911614610b1857610002565b604080516020604435600481810135601f810184900484028501840190955284845261077594813594602480359593946064949293910191819084018382808284375094965050505050505033600160a060020a031660009081526006602052604081205481908114806105835750604081205460078054909190811015610002579082526003026000805160206111d18339815191520181505460a060020a900460ff16155b15610f1d57610002565b604080516020606435600481810135601f81018490048402850184019095528484526107759481359460248035956044359560849492019190819084018382808284375094965050505050505060006000600460005086815481101561000257908252600a027f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b01815090508484846040518084600160a060020a0316606060020a0281526014018381526020018280519060200190808383829060006004602084601f0104600f02600301f150905001935050505060405180910390208160070160005054149150610cdc565b6100b960043560005433600160a060020a03908116911614610f0857610002565b604051808a600160a060020a031681526020018981526020018060200188815260200187815260200186815260200185815260200184815260200183815260200182810382528981815460018160011615610100020316600290048152602001915080546001816001161561010002031660029004801561075e5780601f106107335761010080835404028352916020019161075e565b820191906000526020600020905b81548152906001019060200180831161074157829003601f168201915b50509a505050505050505050505060405180910390f35b60408051918252519081900360200190f35b60408051600160a060020a038616815260208101859052606081018390526080918101828152845460026001821615610100026000190190911604928201839052909160a08301908590801561081e5780601f106107f35761010080835404028352916020019161081e565b820191906000526020600020905b81548152906001019060200180831161080157829003601f168201915b50509550505050505060405180910390f35b60408051600160a060020a03929092168252519081900360200190f35b600160a060020a03851660009081526006602052604081205414156108a957604060002060078054918290556001820180825582801582901161095c5760030281600302836000526020600020918201910161095c9190610a4f565b600160a060020a03851660009081526006602052604090205460078054919350908390811015610002575060005250600381026000805160206111d183398151915201805474ff0000000000000000000000000000000000000000191660a060020a85021781555b60408051600160a060020a03871681526020810186905281517f27b022af4a8347100c7a041ce5ccf8e14d644ff05de696315196faae8cd50c9b929181900390910190a15050505050565b505050915081506080604051908101604052808681526020018581526020018481526020014281526020015060076000508381548110156100025790600052602060002090600302016000508151815460208481015160a060020a02600160a060020a03199290921690921774ff00000000000000000000000000000000000000001916178255604083015180516001848101805460008281528690209195600293821615610100026000190190911692909204601f90810183900482019491929190910190839010610ad357805160ff19168380011785555b50610b03929150610abb565b5050600060028201556001015b80821115610acf57805474ffffffffffffffffffffffffffffffffffffffffff1916815560018181018054600080835592600290821615610100026000190190911604601f819010610aa15750610a42565b601f016020900490600052602060002090810190610a4291905b80821115610acf5760008155600101610abb565b5090565b82800160010185558215610a36579182015b82811115610a36578251826000505591602001919060010190610ae5565b50506060919091015160029190910155610911565b600183905560028290556003819055604080518481526020810184905280820183905290517fa439d3fa452be5e0e1e24a8145e715f4fd8b9c08c96a42fd82a855a85e5d57de9181900360600190a1505050565b50508585846040518084600160a060020a0316606060020a0281526014018381526020018280519060200190808383829060006004602084601f0104600f02600301f150905001935050505060405180910390208160070160005081905550600260005054603c024201816003016000508190555060008160040160006101000a81548160ff0219169083021790555060008160040160016101000a81548160ff02191690830217905550600081600501600050819055507f646fec02522b41e7125cfc859a64fd4f4cefd5dc3b6237ca0abe251ded1fa881828787876040518085815260200184600160a060020a03168152602001838152602001806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f168015610cc45780820380516001836020036101000a031916815260200191505b509550505050505060405180910390a1600182016005555b50949350505050565b6004805460018101808355909190828015829011610d1c57600a0281600a028360005260206000209182019101610d1c9190610db8565b505060048054929450918491508110156100025790600052602060002090600a02016000508054600160a060020a031916871781556001818101879055855160028381018054600082815260209081902096975091959481161561010002600019011691909104601f90810182900484019391890190839010610ed857805160ff19168380011785555b50610b6c929150610abb565b50506001015b80821115610acf578054600160a060020a03191681556000600182810182905560028381018054848255909281161561010002600019011604601f819010610e9c57505b5060006003830181905560048301805461ffff191690556005830181905560068301819055600783018190556008830180548282559082526020909120610db2916002028101905b80821115610acf57805474ffffffffffffffffffffffffffffffffffffffffff1916815560018181018054600080835592600290821615610100026000190190911604601f819010610eba57505b5050600101610e44565b601f016020900490600052602060002090810190610dfc9190610abb565b601f016020900490600052602060002090810190610e929190610abb565b82800160010185558215610da6579182015b82811115610da6578251826000505591602001919060010190610eea565b60008054600160a060020a0319168217905550565b600480548690811015610002576000918252600a027f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b01905033600160a060020a0316600090815260098201602052604090205490915060ff1660011415610f8457610002565b33600160a060020a031660009081526009820160205260409020805460ff1916600190811790915560058201805490910190558315610fcd576006810180546001019055610fda565b6006810180546000190190555b7fc34f869b7ff431b034b7b9aea9822dac189a685e0b015c7d1be3add3f89128e8858533866040518085815260200184815260200183600160a060020a03168152602001806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f16801561107a5780820380516001836020036101000a031916815260200191505b509550505050505060405180910390a1509392505050565b6006810154600354901315611158578060000160009054906101000a9004600160a060020a0316600160a060020a03168160010160005054670de0b6b3a76400000284604051808280519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156111225780820380516001836020036101000a031916815260200191505b5091505060006040518083038185876185025a03f15050505060048101805460ff191660011761ff00191661010017905561116d565b60048101805460ff191660011761ff00191690555b60068101546005820154600483015460408051888152602081019490945283810192909252610100900460ff166060830152517fd220b7272a8b6d0d7d6bcdace67b936a8f175e6d5c1b3ee438b72256b32ab3af9181900360800190a1509291505056a66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688", -} - -// DAO is an auto generated Go binding around an Ethereum contract. -type DAO struct { - abi abi.ABI -} - -// NewDAO creates a new instance of DAO. -func NewDAO() (*DAO, error) { - parsed, err := DAOMetaData.GetAbi() - if err != nil { - return nil, err - } - return &DAO{abi: *parsed}, nil -} - -func (_DAO *DAO) PackConstructor(minimumQuorumForProposals *big.Int, minutesForDebate *big.Int, marginOfVotesForMajority *big.Int, congressLeader common.Address) []byte { - res, _ := _DAO.abi.Pack("", minimumQuorumForProposals, minutesForDebate, marginOfVotesForMajority, congressLeader) - return res -} - -// ChangeMembership is a free data retrieval call binding the contract method 0x9644fcbd. -// -// Solidity: function changeMembership(address targetMember, bool canVote, string memberName) returns() -func (_DAO *DAO) PackChangeMembership(targetMember common.Address, canVote bool, memberName string) ([]byte, error) { - return _DAO.abi.Pack("changeMembership", targetMember, canVote, memberName) -} - -// ChangeVotingRules is a free data retrieval call binding the contract method 0xbcca1fd3. -// -// Solidity: function changeVotingRules(uint256 minimumQuorumForProposals, uint256 minutesForDebate, int256 marginOfVotesForMajority) returns() -func (_DAO *DAO) PackChangeVotingRules(minimumQuorumForProposals *big.Int, minutesForDebate *big.Int, marginOfVotesForMajority *big.Int) ([]byte, error) { - return _DAO.abi.Pack("changeVotingRules", minimumQuorumForProposals, minutesForDebate, marginOfVotesForMajority) -} - -// CheckProposalCode is a free data retrieval call binding the contract method 0xeceb2945. -// -// Solidity: function checkProposalCode(uint256 proposalNumber, address beneficiary, uint256 etherAmount, bytes transactionBytecode) returns(bool codeChecksOut) -func (_DAO *DAO) PackCheckProposalCode(proposalNumber *big.Int, beneficiary common.Address, etherAmount *big.Int, transactionBytecode []byte) ([]byte, error) { - return _DAO.abi.Pack("checkProposalCode", proposalNumber, beneficiary, etherAmount, transactionBytecode) -} - -func (_DAO *DAO) UnpackCheckProposalCode(data []byte) (bool, error) { - out, err := _DAO.abi.Unpack("checkProposalCode", data) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// DebatingPeriodInMinutes is a free data retrieval call binding the contract method 0x69bd3436. -// -// Solidity: function debatingPeriodInMinutes() returns(uint256) -func (_DAO *DAO) PackDebatingPeriodInMinutes() ([]byte, error) { - return _DAO.abi.Pack("debatingPeriodInMinutes") -} - -func (_DAO *DAO) UnpackDebatingPeriodInMinutes(data []byte) (*big.Int, error) { - out, err := _DAO.abi.Unpack("debatingPeriodInMinutes", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// ExecuteProposal is a free data retrieval call binding the contract method 0x237e9492. -// -// Solidity: function executeProposal(uint256 proposalNumber, bytes transactionBytecode) returns(int256 result) -func (_DAO *DAO) PackExecuteProposal(proposalNumber *big.Int, transactionBytecode []byte) ([]byte, error) { - return _DAO.abi.Pack("executeProposal", proposalNumber, transactionBytecode) -} - -func (_DAO *DAO) UnpackExecuteProposal(data []byte) (*big.Int, error) { - out, err := _DAO.abi.Unpack("executeProposal", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// MajorityMargin is a free data retrieval call binding the contract method 0xaa02a90f. -// -// Solidity: function majorityMargin() returns(int256) -func (_DAO *DAO) PackMajorityMargin() ([]byte, error) { - return _DAO.abi.Pack("majorityMargin") -} - -func (_DAO *DAO) UnpackMajorityMargin(data []byte) (*big.Int, error) { - out, err := _DAO.abi.Unpack("majorityMargin", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// MemberId is a free data retrieval call binding the contract method 0x39106821. -// -// Solidity: function memberId(address ) returns(uint256) -func (_DAO *DAO) PackMemberId(arg0 common.Address) ([]byte, error) { - return _DAO.abi.Pack("memberId", arg0) -} - -func (_DAO *DAO) UnpackMemberId(data []byte) (*big.Int, error) { - out, err := _DAO.abi.Unpack("memberId", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Members is a free data retrieval call binding the contract method 0x5daf08ca. -// -// Solidity: function members(uint256 ) returns(address member, bool canVote, string name, uint256 memberSince) -func (_DAO *DAO) PackMembers(arg0 *big.Int) ([]byte, error) { - return _DAO.abi.Pack("members", arg0) -} - -type MembersOutput struct { - Member common.Address - CanVote bool - Name string - MemberSince *big.Int -} - -func (_DAO *DAO) UnpackMembers(data []byte) (MembersOutput, error) { - out, err := _DAO.abi.Unpack("members", data) - - outstruct := new(MembersOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Member = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - outstruct.CanVote = *abi.ConvertType(out[1], new(bool)).(*bool) - outstruct.Name = *abi.ConvertType(out[2], new(string)).(*string) - outstruct.MemberSince = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// MinimumQuorum is a free data retrieval call binding the contract method 0x8160f0b5. -// -// Solidity: function minimumQuorum() returns(uint256) -func (_DAO *DAO) PackMinimumQuorum() ([]byte, error) { - return _DAO.abi.Pack("minimumQuorum") -} - -func (_DAO *DAO) UnpackMinimumQuorum(data []byte) (*big.Int, error) { - out, err := _DAO.abi.Unpack("minimumQuorum", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// NewProposal is a free data retrieval call binding the contract method 0xb1050da5. -// -// Solidity: function newProposal(address beneficiary, uint256 etherAmount, string JobDescription, bytes transactionBytecode) returns(uint256 proposalID) -func (_DAO *DAO) PackNewProposal(beneficiary common.Address, etherAmount *big.Int, JobDescription string, transactionBytecode []byte) ([]byte, error) { - return _DAO.abi.Pack("newProposal", beneficiary, etherAmount, JobDescription, transactionBytecode) -} - -func (_DAO *DAO) UnpackNewProposal(data []byte) (*big.Int, error) { - out, err := _DAO.abi.Unpack("newProposal", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// NumProposals is a free data retrieval call binding the contract method 0x400e3949. -// -// Solidity: function numProposals() returns(uint256) -func (_DAO *DAO) PackNumProposals() ([]byte, error) { - return _DAO.abi.Pack("numProposals") -} - -func (_DAO *DAO) UnpackNumProposals(data []byte) (*big.Int, error) { - out, err := _DAO.abi.Unpack("numProposals", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() returns(address) -func (_DAO *DAO) PackOwner() ([]byte, error) { - return _DAO.abi.Pack("owner") -} - -func (_DAO *DAO) UnpackOwner(data []byte) (common.Address, error) { - out, err := _DAO.abi.Unpack("owner", data) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Proposals is a free data retrieval call binding the contract method 0x013cf08b. -// -// Solidity: function proposals(uint256 ) returns(address recipient, uint256 amount, string description, uint256 votingDeadline, bool executed, bool proposalPassed, uint256 numberOfVotes, int256 currentResult, bytes32 proposalHash) -func (_DAO *DAO) PackProposals(arg0 *big.Int) ([]byte, error) { - return _DAO.abi.Pack("proposals", arg0) -} - -type ProposalsOutput struct { - Recipient common.Address - Amount *big.Int - Description string - VotingDeadline *big.Int - Executed bool - ProposalPassed bool - NumberOfVotes *big.Int - CurrentResult *big.Int - ProposalHash [32]byte -} - -func (_DAO *DAO) UnpackProposals(data []byte) (ProposalsOutput, error) { - out, err := _DAO.abi.Unpack("proposals", data) - - outstruct := new(ProposalsOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Recipient = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - outstruct.Amount = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - outstruct.Description = *abi.ConvertType(out[2], new(string)).(*string) - outstruct.VotingDeadline = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) - outstruct.Executed = *abi.ConvertType(out[4], new(bool)).(*bool) - outstruct.ProposalPassed = *abi.ConvertType(out[5], new(bool)).(*bool) - outstruct.NumberOfVotes = *abi.ConvertType(out[6], new(*big.Int)).(**big.Int) - outstruct.CurrentResult = *abi.ConvertType(out[7], new(*big.Int)).(**big.Int) - outstruct.ProposalHash = *abi.ConvertType(out[8], new([32]byte)).(*[32]byte) - - return *outstruct, err - -} - -// TransferOwnership is a free data retrieval call binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_DAO *DAO) PackTransferOwnership(newOwner common.Address) ([]byte, error) { - return _DAO.abi.Pack("transferOwnership", newOwner) -} - -// Vote is a free data retrieval call binding the contract method 0xd3c0715b. -// -// Solidity: function vote(uint256 proposalNumber, bool supportsProposal, string justificationText) returns(uint256 voteID) -func (_DAO *DAO) PackVote(proposalNumber *big.Int, supportsProposal bool, justificationText string) ([]byte, error) { - return _DAO.abi.Pack("vote", proposalNumber, supportsProposal, justificationText) -} - -func (_DAO *DAO) UnpackVote(data []byte) (*big.Int, error) { - out, err := _DAO.abi.Unpack("vote", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// DAOChangeOfRules represents a ChangeOfRules event raised by the DAO contract. -type DAOChangeOfRules struct { - MinimumQuorum *big.Int - DebatingPeriodInMinutes *big.Int - MajorityMargin *big.Int - Raw *types.Log // Blockchain specific contextual infos -} - -const DAOChangeOfRulesEventName = "ChangeOfRules" - -func (_DAO *DAO) UnpackChangeOfRulesEvent(log *types.Log) (*DAOChangeOfRules, error) { - event := "ChangeOfRules" - if log.Topics[0] != _DAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(DAOChangeOfRules) - if len(log.Data) > 0 { - if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _DAO.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 -} - -// DAOMembershipChanged represents a MembershipChanged event raised by the DAO contract. -type DAOMembershipChanged struct { - Member common.Address - IsMember bool - Raw *types.Log // Blockchain specific contextual infos -} - -const DAOMembershipChangedEventName = "MembershipChanged" - -func (_DAO *DAO) UnpackMembershipChangedEvent(log *types.Log) (*DAOMembershipChanged, error) { - event := "MembershipChanged" - if log.Topics[0] != _DAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(DAOMembershipChanged) - if len(log.Data) > 0 { - if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _DAO.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 -} - -// DAOProposalAdded represents a ProposalAdded event raised by the DAO contract. -type DAOProposalAdded struct { - ProposalID *big.Int - Recipient common.Address - Amount *big.Int - Description string - Raw *types.Log // Blockchain specific contextual infos -} - -const DAOProposalAddedEventName = "ProposalAdded" - -func (_DAO *DAO) UnpackProposalAddedEvent(log *types.Log) (*DAOProposalAdded, error) { - event := "ProposalAdded" - if log.Topics[0] != _DAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(DAOProposalAdded) - if len(log.Data) > 0 { - if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _DAO.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 -} - -// DAOProposalTallied represents a ProposalTallied event raised by the DAO contract. -type DAOProposalTallied struct { - ProposalID *big.Int - Result *big.Int - Quorum *big.Int - Active bool - Raw *types.Log // Blockchain specific contextual infos -} - -const DAOProposalTalliedEventName = "ProposalTallied" - -func (_DAO *DAO) UnpackProposalTalliedEvent(log *types.Log) (*DAOProposalTallied, error) { - event := "ProposalTallied" - if log.Topics[0] != _DAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(DAOProposalTallied) - if len(log.Data) > 0 { - if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _DAO.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 -} - -// DAOVoted represents a Voted event raised by the DAO contract. -type DAOVoted struct { - ProposalID *big.Int - Position bool - Voter common.Address - Justification string - Raw *types.Log // Blockchain specific contextual infos -} - -const DAOVotedEventName = "Voted" - -func (_DAO *DAO) UnpackVotedEvent(log *types.Log) (*DAOVoted, error) { - event := "Voted" - if log.Topics[0] != _DAO.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(DAOVoted) - if len(log.Data) > 0 { - if err := _DAO.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _DAO.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/convertedv1bindtests/deeplynestedarray.go b/accounts/abi/bind/convertedv1bindtests/deeplynestedarray.go deleted file mode 100644 index ab2cd5574a5c..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/deeplynestedarray.go +++ /dev/null @@ -1,98 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// DeeplyNestedArrayMetaData contains all meta data concerning the DeeplyNestedArray contract. -var DeeplyNestedArrayMetaData = &bind.MetaData{ - ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"arr\",\"type\":\"uint64[3][4][5]\"}],\"name\":\"storeDeepUintArray\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"retrieveDeepArray\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64[3][4][5]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"deepUint64Array\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", - Pattern: "3a44c26b21f02743d5dbeb02d24a67bf41", - Bin: "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", -} - -// DeeplyNestedArray is an auto generated Go binding around an Ethereum contract. -type DeeplyNestedArray struct { - abi abi.ABI -} - -// NewDeeplyNestedArray creates a new instance of DeeplyNestedArray. -func NewDeeplyNestedArray() (*DeeplyNestedArray, error) { - parsed, err := DeeplyNestedArrayMetaData.GetAbi() - if err != nil { - return nil, err - } - return &DeeplyNestedArray{abi: *parsed}, nil -} - -func (_DeeplyNestedArray *DeeplyNestedArray) PackConstructor() []byte { - res, _ := _DeeplyNestedArray.abi.Pack("") - return res -} - -// DeepUint64Array is a free data retrieval call binding the contract method 0x98ed1856. -// -// Solidity: function deepUint64Array(uint256 , uint256 , uint256 ) view returns(uint64) -func (_DeeplyNestedArray *DeeplyNestedArray) PackDeepUint64Array(arg0 *big.Int, arg1 *big.Int, arg2 *big.Int) ([]byte, error) { - return _DeeplyNestedArray.abi.Pack("deepUint64Array", arg0, arg1, arg2) -} - -func (_DeeplyNestedArray *DeeplyNestedArray) UnpackDeepUint64Array(data []byte) (uint64, error) { - out, err := _DeeplyNestedArray.abi.Unpack("deepUint64Array", data) - - if err != nil { - return *new(uint64), err - } - - out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) - - return out0, err - -} - -// RetrieveDeepArray is a free data retrieval call binding the contract method 0x8ed4573a. -// -// Solidity: function retrieveDeepArray() view returns(uint64[3][4][5]) -func (_DeeplyNestedArray *DeeplyNestedArray) PackRetrieveDeepArray() ([]byte, error) { - return _DeeplyNestedArray.abi.Pack("retrieveDeepArray") -} - -func (_DeeplyNestedArray *DeeplyNestedArray) UnpackRetrieveDeepArray(data []byte) ([5][4][3]uint64, error) { - out, err := _DeeplyNestedArray.abi.Unpack("retrieveDeepArray", data) - - if err != nil { - return *new([5][4][3]uint64), err - } - - out0 := *abi.ConvertType(out[0], new([5][4][3]uint64)).(*[5][4][3]uint64) - - return out0, err - -} - -// StoreDeepUintArray is a free data retrieval call binding the contract method 0x34424855. -// -// Solidity: function storeDeepUintArray(uint64[3][4][5] arr) returns() -func (_DeeplyNestedArray *DeeplyNestedArray) PackStoreDeepUintArray(arr [5][4][3]uint64) ([]byte, error) { - return _DeeplyNestedArray.abi.Pack("storeDeepUintArray", arr) -} diff --git a/accounts/abi/bind/convertedv1bindtests/empty.go b/accounts/abi/bind/convertedv1bindtests/empty.go deleted file mode 100644 index e6c7efd7ae65..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/empty.go +++ /dev/null @@ -1,51 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// EmptyMetaData contains all meta data concerning the Empty contract. -var EmptyMetaData = &bind.MetaData{ - ABI: "[]", - Pattern: "c4ce3210982aa6fc94dabe46dc1dbf454d", - Bin: "0x606060405260068060106000396000f3606060405200", -} - -// Empty is an auto generated Go binding around an Ethereum contract. -type Empty struct { - abi abi.ABI -} - -// NewEmpty creates a new instance of Empty. -func NewEmpty() (*Empty, error) { - parsed, err := EmptyMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Empty{abi: *parsed}, nil -} - -func (_Empty *Empty) PackConstructor() []byte { - res, _ := _Empty.abi.Pack("") - return res -} diff --git a/accounts/abi/bind/convertedv1bindtests/eventchecker.go b/accounts/abi/bind/convertedv1bindtests/eventchecker.go deleted file mode 100644 index 742d9876b098..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/eventchecker.go +++ /dev/null @@ -1,215 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// EventCheckerMetaData contains all meta data concerning the EventChecker contract. -var EventCheckerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"event\",\"name\":\"empty\",\"inputs\":[]},{\"type\":\"event\",\"name\":\"indexed\",\"inputs\":[{\"name\":\"addr\",\"type\":\"address\",\"indexed\":true},{\"name\":\"num\",\"type\":\"int256\",\"indexed\":true}]},{\"type\":\"event\",\"name\":\"mixed\",\"inputs\":[{\"name\":\"addr\",\"type\":\"address\",\"indexed\":true},{\"name\":\"num\",\"type\":\"int256\"}]},{\"type\":\"event\",\"name\":\"anonymous\",\"anonymous\":true,\"inputs\":[]},{\"type\":\"event\",\"name\":\"dynamic\",\"inputs\":[{\"name\":\"idxStr\",\"type\":\"string\",\"indexed\":true},{\"name\":\"idxDat\",\"type\":\"bytes\",\"indexed\":true},{\"name\":\"str\",\"type\":\"string\"},{\"name\":\"dat\",\"type\":\"bytes\"}]},{\"type\":\"event\",\"name\":\"unnamed\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"\",\"type\":\"uint256\",\"indexed\":true}]}]", - Pattern: "253d421f98e29b25315bde79c1251ab27c", -} - -// EventChecker is an auto generated Go binding around an Ethereum contract. -type EventChecker struct { - abi abi.ABI -} - -// NewEventChecker creates a new instance of EventChecker. -func NewEventChecker() (*EventChecker, error) { - parsed, err := EventCheckerMetaData.GetAbi() - if err != nil { - return nil, err - } - return &EventChecker{abi: *parsed}, nil -} - -func (_EventChecker *EventChecker) PackConstructor() []byte { - res, _ := _EventChecker.abi.Pack("") - return res -} - -// EventCheckerDynamic represents a Dynamic event raised by the EventChecker contract. -type EventCheckerDynamic struct { - IdxStr common.Hash - IdxDat common.Hash - Str string - Dat []byte - Raw *types.Log // Blockchain specific contextual infos -} - -const EventCheckerDynamicEventName = "dynamic" - -func (_EventChecker *EventChecker) UnpackDynamicEvent(log *types.Log) (*EventCheckerDynamic, error) { - event := "dynamic" - if log.Topics[0] != _EventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(EventCheckerDynamic) - if len(log.Data) > 0 { - if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _EventChecker.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 -} - -// EventCheckerEmpty represents a Empty event raised by the EventChecker contract. -type EventCheckerEmpty struct { - Raw *types.Log // Blockchain specific contextual infos -} - -const EventCheckerEmptyEventName = "empty" - -func (_EventChecker *EventChecker) UnpackEmptyEvent(log *types.Log) (*EventCheckerEmpty, error) { - event := "empty" - if log.Topics[0] != _EventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(EventCheckerEmpty) - if len(log.Data) > 0 { - if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _EventChecker.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 -} - -// EventCheckerIndexed represents a Indexed event raised by the EventChecker contract. -type EventCheckerIndexed struct { - Addr common.Address - Num *big.Int - Raw *types.Log // Blockchain specific contextual infos -} - -const EventCheckerIndexedEventName = "indexed" - -func (_EventChecker *EventChecker) UnpackIndexedEvent(log *types.Log) (*EventCheckerIndexed, error) { - event := "indexed" - if log.Topics[0] != _EventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(EventCheckerIndexed) - if len(log.Data) > 0 { - if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _EventChecker.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 -} - -// EventCheckerMixed represents a Mixed event raised by the EventChecker contract. -type EventCheckerMixed struct { - Addr common.Address - Num *big.Int - Raw *types.Log // Blockchain specific contextual infos -} - -const EventCheckerMixedEventName = "mixed" - -func (_EventChecker *EventChecker) UnpackMixedEvent(log *types.Log) (*EventCheckerMixed, error) { - event := "mixed" - if log.Topics[0] != _EventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(EventCheckerMixed) - if len(log.Data) > 0 { - if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _EventChecker.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 -} - -// EventCheckerUnnamed represents a Unnamed event raised by the EventChecker contract. -type EventCheckerUnnamed struct { - Arg0 *big.Int - Arg1 *big.Int - Raw *types.Log // Blockchain specific contextual infos -} - -const EventCheckerUnnamedEventName = "unnamed" - -func (_EventChecker *EventChecker) UnpackUnnamedEvent(log *types.Log) (*EventCheckerUnnamed, error) { - event := "unnamed" - if log.Topics[0] != _EventChecker.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(EventCheckerUnnamed) - if len(log.Data) > 0 { - if err := _EventChecker.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _EventChecker.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/convertedv1bindtests/getter.go b/accounts/abi/bind/convertedv1bindtests/getter.go deleted file mode 100644 index 067dc21af80b..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/getter.go +++ /dev/null @@ -1,80 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// GetterMetaData contains all meta data concerning the Getter contract. -var GetterMetaData = &bind.MetaData{ - ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"getter\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"int256\"},{\"name\":\"\",\"type\":\"bytes32\"}],\"type\":\"function\"}]", - Pattern: "e23a74c8979fe93c9fff15e4f51535ad54", - Bin: "0x606060405260dc8060106000396000f3606060405260e060020a6000350463993a04b78114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3", -} - -// Getter is an auto generated Go binding around an Ethereum contract. -type Getter struct { - abi abi.ABI -} - -// NewGetter creates a new instance of Getter. -func NewGetter() (*Getter, error) { - parsed, err := GetterMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Getter{abi: *parsed}, nil -} - -func (_Getter *Getter) PackConstructor() []byte { - res, _ := _Getter.abi.Pack("") - return res -} - -// Getter is a free data retrieval call binding the contract method 0x993a04b7. -// -// Solidity: function getter() returns(string, int256, bytes32) -func (_Getter *Getter) PackGetter() ([]byte, error) { - return _Getter.abi.Pack("getter") -} - -type GetterOutput struct { - Arg string - Arg0 *big.Int - Arg1 [32]byte -} - -func (_Getter *Getter) UnpackGetter(data []byte) (GetterOutput, error) { - out, err := _Getter.abi.Unpack("getter", data) - - outstruct := new(GetterOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Arg = *abi.ConvertType(out[0], new(string)).(*string) - outstruct.Arg0 = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - outstruct.Arg1 = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) - - return *outstruct, err - -} diff --git a/accounts/abi/bind/convertedv1bindtests/identifiercollision.go b/accounts/abi/bind/convertedv1bindtests/identifiercollision.go deleted file mode 100644 index 150a1ad16391..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/identifiercollision.go +++ /dev/null @@ -1,91 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// IdentifierCollisionMetaData contains all meta data concerning the IdentifierCollision contract. -var IdentifierCollisionMetaData = &bind.MetaData{ - ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"MyVar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_myVar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", - Pattern: "1863c5622f8ac2c09c42f063ca883fe438", - Bin: "0x60806040523480156100115760006000fd5b50610017565b60c3806100256000396000f3fe608060405234801560105760006000fd5b506004361060365760003560e01c806301ad4d8714603c5780634ef1f0ad146058576036565b60006000fd5b60426074565b6040518082815260200191505060405180910390f35b605e607d565b6040518082815260200191505060405180910390f35b60006000505481565b60006000600050549050608b565b9056fea265627a7a7231582067c8d84688b01c4754ba40a2a871cede94ea1f28b5981593ab2a45b46ac43af664736f6c634300050c0032", -} - -// IdentifierCollision is an auto generated Go binding around an Ethereum contract. -type IdentifierCollision struct { - abi abi.ABI -} - -// NewIdentifierCollision creates a new instance of IdentifierCollision. -func NewIdentifierCollision() (*IdentifierCollision, error) { - parsed, err := IdentifierCollisionMetaData.GetAbi() - if err != nil { - return nil, err - } - return &IdentifierCollision{abi: *parsed}, nil -} - -func (_IdentifierCollision *IdentifierCollision) PackConstructor() []byte { - res, _ := _IdentifierCollision.abi.Pack("") - return res -} - -// MyVar is a free data retrieval call binding the contract method 0x4ef1f0ad. -// -// Solidity: function MyVar() view returns(uint256) -func (_IdentifierCollision *IdentifierCollision) PackMyVar() ([]byte, error) { - return _IdentifierCollision.abi.Pack("MyVar") -} - -func (_IdentifierCollision *IdentifierCollision) UnpackMyVar(data []byte) (*big.Int, error) { - out, err := _IdentifierCollision.abi.Unpack("MyVar", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// PubVar is a free data retrieval call binding the contract method 0x01ad4d87. -// -// Solidity: function _myVar() view returns(uint256) -func (_IdentifierCollision *IdentifierCollision) PackPubVar() ([]byte, error) { - return _IdentifierCollision.abi.Pack("_myVar") -} - -func (_IdentifierCollision *IdentifierCollision) UnpackPubVar(data []byte) (*big.Int, error) { - out, err := _IdentifierCollision.abi.Unpack("_myVar", 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/convertedv1bindtests/inputchecker.go b/accounts/abi/bind/convertedv1bindtests/inputchecker.go deleted file mode 100644 index 59664669361b..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/inputchecker.go +++ /dev/null @@ -1,92 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// InputCheckerMetaData contains all meta data concerning the InputChecker contract. -var InputCheckerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"noInput\",\"constant\":true,\"inputs\":[],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedInput\",\"constant\":true,\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"anonInput\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedInputs\",\"constant\":true,\"inputs\":[{\"name\":\"str1\",\"type\":\"string\"},{\"name\":\"str2\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"anonInputs\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"string\"}],\"outputs\":[]},{\"type\":\"function\",\"name\":\"mixedInputs\",\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"str\",\"type\":\"string\"}],\"outputs\":[]}]", - Pattern: "e551ce092312e54f54f45ffdf06caa4cdc", -} - -// InputChecker is an auto generated Go binding around an Ethereum contract. -type InputChecker struct { - abi abi.ABI -} - -// NewInputChecker creates a new instance of InputChecker. -func NewInputChecker() (*InputChecker, error) { - parsed, err := InputCheckerMetaData.GetAbi() - if err != nil { - return nil, err - } - return &InputChecker{abi: *parsed}, nil -} - -func (_InputChecker *InputChecker) PackConstructor() []byte { - res, _ := _InputChecker.abi.Pack("") - return res -} - -// AnonInput is a free data retrieval call binding the contract method 0x3e708e82. -// -// Solidity: function anonInput(string ) returns() -func (_InputChecker *InputChecker) PackAnonInput(arg0 string) ([]byte, error) { - return _InputChecker.abi.Pack("anonInput", arg0) -} - -// AnonInputs is a free data retrieval call binding the contract method 0x28160527. -// -// Solidity: function anonInputs(string , string ) returns() -func (_InputChecker *InputChecker) PackAnonInputs(arg0 string, arg1 string) ([]byte, error) { - return _InputChecker.abi.Pack("anonInputs", arg0, arg1) -} - -// MixedInputs is a free data retrieval call binding the contract method 0xc689ebdc. -// -// Solidity: function mixedInputs(string , string str) returns() -func (_InputChecker *InputChecker) PackMixedInputs(arg0 string, str string) ([]byte, error) { - return _InputChecker.abi.Pack("mixedInputs", arg0, str) -} - -// NamedInput is a free data retrieval call binding the contract method 0x0d402005. -// -// Solidity: function namedInput(string str) returns() -func (_InputChecker *InputChecker) PackNamedInput(str string) ([]byte, error) { - return _InputChecker.abi.Pack("namedInput", str) -} - -// NamedInputs is a free data retrieval call binding the contract method 0x63c796ed. -// -// Solidity: function namedInputs(string str1, string str2) returns() -func (_InputChecker *InputChecker) PackNamedInputs(str1 string, str2 string) ([]byte, error) { - return _InputChecker.abi.Pack("namedInputs", str1, str2) -} - -// NoInput is a free data retrieval call binding the contract method 0x53539029. -// -// Solidity: function noInput() returns() -func (_InputChecker *InputChecker) PackNoInput() ([]byte, error) { - return _InputChecker.abi.Pack("noInput") -} diff --git a/accounts/abi/bind/convertedv1bindtests/interactor.go b/accounts/abi/bind/convertedv1bindtests/interactor.go deleted file mode 100644 index d921c9031bf9..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/interactor.go +++ /dev/null @@ -1,98 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// InteractorMetaData contains all meta data concerning the Interactor contract. -var InteractorMetaData = &bind.MetaData{ - ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"transactString\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"deployString\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"name\":\"transact\",\"outputs\":[],\"type\":\"function\"},{\"inputs\":[{\"name\":\"str\",\"type\":\"string\"}],\"type\":\"constructor\"}]", - Pattern: "f63980878028f3242c9033fdc30fd21a81", - Bin: "0x6060604052604051610328380380610328833981016040528051018060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10608d57805160ff19168380011785555b50607c9291505b8082111560ba57838155600101606b565b50505061026a806100be6000396000f35b828001600101855582156064579182015b828111156064578251826000505591602001919060010190609e565b509056606060405260e060020a60003504630d86a0e181146100315780636874e8091461008d578063d736c513146100ea575b005b610190600180546020600282841615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b61019060008054602060026001831615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b60206004803580820135601f81018490049093026080908101604052606084815261002f946024939192918401918190838280828437509496505050505050508060016000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061023157805160ff19168380011785555b506102619291505b808211156102665760008155830161017d565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101f05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b820191906000526020600020905b81548152906001019060200180831161020c57829003601f168201915b505050505081565b82800160010185558215610175579182015b82811115610175578251826000505591602001919060010190610243565b505050565b509056", -} - -// Interactor is an auto generated Go binding around an Ethereum contract. -type Interactor struct { - abi abi.ABI -} - -// NewInteractor creates a new instance of Interactor. -func NewInteractor() (*Interactor, error) { - parsed, err := InteractorMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Interactor{abi: *parsed}, nil -} - -func (_Interactor *Interactor) PackConstructor(str string) []byte { - res, _ := _Interactor.abi.Pack("", str) - return res -} - -// DeployString is a free data retrieval call binding the contract method 0x6874e809. -// -// Solidity: function deployString() returns(string) -func (_Interactor *Interactor) PackDeployString() ([]byte, error) { - return _Interactor.abi.Pack("deployString") -} - -func (_Interactor *Interactor) UnpackDeployString(data []byte) (string, error) { - out, err := _Interactor.abi.Unpack("deployString", data) - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// Transact is a free data retrieval call binding the contract method 0xd736c513. -// -// Solidity: function transact(string str) returns() -func (_Interactor *Interactor) PackTransact(str string) ([]byte, error) { - return _Interactor.abi.Pack("transact", str) -} - -// TransactString is a free data retrieval call binding the contract method 0x0d86a0e1. -// -// Solidity: function transactString() returns(string) -func (_Interactor *Interactor) PackTransactString() ([]byte, error) { - return _Interactor.abi.Pack("transactString") -} - -func (_Interactor *Interactor) UnpackTransactString(data []byte) (string, error) { - out, err := _Interactor.abi.Unpack("transactString", data) - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} diff --git a/accounts/abi/bind/convertedv1bindtests/nameconflict.go b/accounts/abi/bind/convertedv1bindtests/nameconflict.go deleted file mode 100644 index 8046fd67ccb8..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/nameconflict.go +++ /dev/null @@ -1,117 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// Oraclerequest is an auto generated low-level Go binding around an user-defined struct. -type Oraclerequest struct { - Data []byte - Data0 []byte -} - -// TODO: convert this type to value type after everything works. -// NameConflictMetaData contains all meta data concerning the NameConflict contract. -var NameConflictMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"msg\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"_msg\",\"type\":\"int256\"}],\"name\":\"log\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"internalType\":\"structoracle.request\",\"name\":\"req\",\"type\":\"tuple\"}],\"name\":\"addRequest\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRequest\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"internalType\":\"structoracle.request\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", - Pattern: "8f6e2703b307244ae6bd61ed94ce959cf9", - Bin: "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", -} - -// NameConflict is an auto generated Go binding around an Ethereum contract. -type NameConflict struct { - abi abi.ABI -} - -// NewNameConflict creates a new instance of NameConflict. -func NewNameConflict() (*NameConflict, error) { - parsed, err := NameConflictMetaData.GetAbi() - if err != nil { - return nil, err - } - return &NameConflict{abi: *parsed}, nil -} - -func (_NameConflict *NameConflict) PackConstructor() []byte { - res, _ := _NameConflict.abi.Pack("") - return res -} - -// AddRequest is a free data retrieval call binding the contract method 0xcce7b048. -// -// Solidity: function addRequest((bytes,bytes) req) pure returns() -func (_NameConflict *NameConflict) PackAddRequest(req Oraclerequest) ([]byte, error) { - return _NameConflict.abi.Pack("addRequest", req) -} - -// GetRequest is a free data retrieval call binding the contract method 0xc2bb515f. -// -// Solidity: function getRequest() pure returns((bytes,bytes)) -func (_NameConflict *NameConflict) PackGetRequest() ([]byte, error) { - return _NameConflict.abi.Pack("getRequest") -} - -func (_NameConflict *NameConflict) UnpackGetRequest(data []byte) (Oraclerequest, error) { - out, err := _NameConflict.abi.Unpack("getRequest", data) - - if err != nil { - return *new(Oraclerequest), err - } - - out0 := *abi.ConvertType(out[0], new(Oraclerequest)).(*Oraclerequest) - - return out0, err - -} - -// NameConflictLog represents a Log event raised by the NameConflict contract. -type NameConflictLog struct { - Msg *big.Int - Msg0 *big.Int - Raw *types.Log // Blockchain specific contextual infos -} - -const NameConflictLogEventName = "log" - -func (_NameConflict *NameConflict) UnpackLogEvent(log *types.Log) (*NameConflictLog, error) { - event := "log" - if log.Topics[0] != _NameConflict.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(NameConflictLog) - if len(log.Data) > 0 { - if err := _NameConflict.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _NameConflict.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/convertedv1bindtests/numericmethodname.go b/accounts/abi/bind/convertedv1bindtests/numericmethodname.go deleted file mode 100644 index 21e075cd2254..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/numericmethodname.go +++ /dev/null @@ -1,104 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// NumericMethodNameMetaData contains all meta data concerning the NumericMethodName contract. -var NumericMethodNameMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_param\",\"type\":\"address\"}],\"name\":\"_1TestEvent\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"_1test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__1test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__2test\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", - Pattern: "a691b347afbc44b90dd9a1dfbc65661904", - Bin: "0x6080604052348015600f57600080fd5b5060958061001e6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80639d993132146041578063d02767c7146049578063ffa02795146051575b600080fd5b60476059565b005b604f605b565b005b6057605d565b005b565b565b56fea26469706673582212200382ca602dff96a7e2ba54657985e2b4ac423a56abe4a1f0667bc635c4d4371f64736f6c63430008110033", -} - -// NumericMethodName is an auto generated Go binding around an Ethereum contract. -type NumericMethodName struct { - abi abi.ABI -} - -// NewNumericMethodName creates a new instance of NumericMethodName. -func NewNumericMethodName() (*NumericMethodName, error) { - parsed, err := NumericMethodNameMetaData.GetAbi() - if err != nil { - return nil, err - } - return &NumericMethodName{abi: *parsed}, nil -} - -func (_NumericMethodName *NumericMethodName) PackConstructor() []byte { - res, _ := _NumericMethodName.abi.Pack("") - return res -} - -// E1test is a free data retrieval call binding the contract method 0xffa02795. -// -// Solidity: function _1test() pure returns() -func (_NumericMethodName *NumericMethodName) PackE1test() ([]byte, error) { - return _NumericMethodName.abi.Pack("_1test") -} - -// E1test0 is a free data retrieval call binding the contract method 0xd02767c7. -// -// Solidity: function __1test() pure returns() -func (_NumericMethodName *NumericMethodName) PackE1test0() ([]byte, error) { - return _NumericMethodName.abi.Pack("__1test") -} - -// E2test is a free data retrieval call binding the contract method 0x9d993132. -// -// Solidity: function __2test() pure returns() -func (_NumericMethodName *NumericMethodName) PackE2test() ([]byte, error) { - return _NumericMethodName.abi.Pack("__2test") -} - -// NumericMethodNameE1TestEvent represents a E1TestEvent event raised by the NumericMethodName contract. -type NumericMethodNameE1TestEvent struct { - Param common.Address - Raw *types.Log // Blockchain specific contextual infos -} - -const NumericMethodNameE1TestEventEventName = "_1TestEvent" - -func (_NumericMethodName *NumericMethodName) UnpackE1TestEventEvent(log *types.Log) (*NumericMethodNameE1TestEvent, error) { - event := "_1TestEvent" - if log.Topics[0] != _NumericMethodName.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(NumericMethodNameE1TestEvent) - if len(log.Data) > 0 { - if err := _NumericMethodName.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _NumericMethodName.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/convertedv1bindtests/outputchecker.go b/accounts/abi/bind/convertedv1bindtests/outputchecker.go deleted file mode 100644 index b1487461add2..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/outputchecker.go +++ /dev/null @@ -1,205 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// OutputCheckerMetaData contains all meta data concerning the OutputChecker contract. -var OutputCheckerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"noOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[]},{\"type\":\"function\",\"name\":\"namedOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"anonOutput\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"namedOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str1\",\"type\":\"string\"},{\"name\":\"str2\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"collidingOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"str\",\"type\":\"string\"},{\"name\":\"Str\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"anonOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"\",\"type\":\"string\"}]},{\"type\":\"function\",\"name\":\"mixedOutputs\",\"constant\":true,\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\"},{\"name\":\"str\",\"type\":\"string\"}]}]", - Pattern: "cc1d4e235801a590b506d5130b0cca90a1", -} - -// OutputChecker is an auto generated Go binding around an Ethereum contract. -type OutputChecker struct { - abi abi.ABI -} - -// NewOutputChecker creates a new instance of OutputChecker. -func NewOutputChecker() (*OutputChecker, error) { - parsed, err := OutputCheckerMetaData.GetAbi() - if err != nil { - return nil, err - } - return &OutputChecker{abi: *parsed}, nil -} - -func (_OutputChecker *OutputChecker) PackConstructor() []byte { - res, _ := _OutputChecker.abi.Pack("") - return res -} - -// AnonOutput is a free data retrieval call binding the contract method 0x008bda05. -// -// Solidity: function anonOutput() returns(string) -func (_OutputChecker *OutputChecker) PackAnonOutput() ([]byte, error) { - return _OutputChecker.abi.Pack("anonOutput") -} - -func (_OutputChecker *OutputChecker) UnpackAnonOutput(data []byte) (string, error) { - out, err := _OutputChecker.abi.Unpack("anonOutput", data) - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// AnonOutputs is a free data retrieval call binding the contract method 0x3c401115. -// -// Solidity: function anonOutputs() returns(string, string) -func (_OutputChecker *OutputChecker) PackAnonOutputs() ([]byte, error) { - return _OutputChecker.abi.Pack("anonOutputs") -} - -type AnonOutputsOutput struct { - Arg string - Arg0 string -} - -func (_OutputChecker *OutputChecker) UnpackAnonOutputs(data []byte) (AnonOutputsOutput, error) { - out, err := _OutputChecker.abi.Unpack("anonOutputs", data) - - outstruct := new(AnonOutputsOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Arg = *abi.ConvertType(out[0], new(string)).(*string) - outstruct.Arg0 = *abi.ConvertType(out[1], new(string)).(*string) - - return *outstruct, err - -} - -// CollidingOutputs is a free data retrieval call binding the contract method 0xeccbc1ee. -// -// Solidity: function collidingOutputs() returns(string str, string Str) -func (_OutputChecker *OutputChecker) PackCollidingOutputs() ([]byte, error) { - return _OutputChecker.abi.Pack("collidingOutputs") -} - -type CollidingOutputsOutput struct { - Str string - Str string -} - -func (_OutputChecker *OutputChecker) UnpackCollidingOutputs(data []byte) (CollidingOutputsOutput, error) { - out, err := _OutputChecker.abi.Unpack("collidingOutputs", data) - - outstruct := new(CollidingOutputsOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Str = *abi.ConvertType(out[0], new(string)).(*string) - outstruct.Str = *abi.ConvertType(out[1], new(string)).(*string) - - return *outstruct, err - -} - -// MixedOutputs is a free data retrieval call binding the contract method 0x21b77b44. -// -// Solidity: function mixedOutputs() returns(string, string str) -func (_OutputChecker *OutputChecker) PackMixedOutputs() ([]byte, error) { - return _OutputChecker.abi.Pack("mixedOutputs") -} - -type MixedOutputsOutput struct { - Arg string - Str string -} - -func (_OutputChecker *OutputChecker) UnpackMixedOutputs(data []byte) (MixedOutputsOutput, error) { - out, err := _OutputChecker.abi.Unpack("mixedOutputs", data) - - outstruct := new(MixedOutputsOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Arg = *abi.ConvertType(out[0], new(string)).(*string) - outstruct.Str = *abi.ConvertType(out[1], new(string)).(*string) - - return *outstruct, err - -} - -// NamedOutput is a free data retrieval call binding the contract method 0x5e632bd5. -// -// Solidity: function namedOutput() returns(string str) -func (_OutputChecker *OutputChecker) PackNamedOutput() ([]byte, error) { - return _OutputChecker.abi.Pack("namedOutput") -} - -func (_OutputChecker *OutputChecker) UnpackNamedOutput(data []byte) (string, error) { - out, err := _OutputChecker.abi.Unpack("namedOutput", data) - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// NamedOutputs is a free data retrieval call binding the contract method 0x7970a189. -// -// Solidity: function namedOutputs() returns(string str1, string str2) -func (_OutputChecker *OutputChecker) PackNamedOutputs() ([]byte, error) { - return _OutputChecker.abi.Pack("namedOutputs") -} - -type NamedOutputsOutput struct { - Str1 string - Str2 string -} - -func (_OutputChecker *OutputChecker) UnpackNamedOutputs(data []byte) (NamedOutputsOutput, error) { - out, err := _OutputChecker.abi.Unpack("namedOutputs", data) - - outstruct := new(NamedOutputsOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Str1 = *abi.ConvertType(out[0], new(string)).(*string) - outstruct.Str2 = *abi.ConvertType(out[1], new(string)).(*string) - - return *outstruct, err - -} - -// NoOutput is a free data retrieval call binding the contract method 0x625f0306. -// -// Solidity: function noOutput() returns() -func (_OutputChecker *OutputChecker) PackNoOutput() ([]byte, error) { - return _OutputChecker.abi.Pack("noOutput") -} diff --git a/accounts/abi/bind/convertedv1bindtests/overload.go b/accounts/abi/bind/convertedv1bindtests/overload.go deleted file mode 100644 index 93894f34010d..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/overload.go +++ /dev/null @@ -1,130 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// OverloadMetaData contains all meta data concerning the Overload contract. -var OverloadMetaData = &bind.MetaData{ - ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"},{\"name\":\"j\",\"type\":\"uint256\"}],\"name\":\"foo\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"}],\"name\":\"foo\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"i\",\"type\":\"uint256\"}],\"name\":\"bar\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"i\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"j\",\"type\":\"uint256\"}],\"name\":\"bar\",\"type\":\"event\"}]", - Pattern: "f49f0ff7ed407de5c37214f49309072aec", - Bin: "0x608060405234801561001057600080fd5b50610153806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806304bc52f81461003b5780632fbebd3814610073575b600080fd5b6100716004803603604081101561005157600080fd5b8101908080359060200190929190803590602001909291905050506100a1565b005b61009f6004803603602081101561008957600080fd5b81019080803590602001909291905050506100e4565b005b7fae42e9514233792a47a1e4554624e83fe852228e1503f63cd383e8a431f4f46d8282604051808381526020018281526020019250505060405180910390a15050565b7f0423a1321222a0a8716c22b92fac42d85a45a612b696a461784d9fa537c81e5c816040518082815260200191505060405180910390a15056fea265627a7a72305820e22b049858b33291cbe67eeaece0c5f64333e439d27032ea8337d08b1de18fe864736f6c634300050a0032", -} - -// Overload is an auto generated Go binding around an Ethereum contract. -type Overload struct { - abi abi.ABI -} - -// NewOverload creates a new instance of Overload. -func NewOverload() (*Overload, error) { - parsed, err := OverloadMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Overload{abi: *parsed}, nil -} - -func (_Overload *Overload) PackConstructor() []byte { - res, _ := _Overload.abi.Pack("") - return res -} - -// Foo is a free data retrieval call binding the contract method 0x04bc52f8. -// -// Solidity: function foo(uint256 i, uint256 j) returns() -func (_Overload *Overload) PackFoo(i *big.Int, j *big.Int) ([]byte, error) { - return _Overload.abi.Pack("foo", i, j) -} - -// Foo0 is a free data retrieval call binding the contract method 0x2fbebd38. -// -// Solidity: function foo(uint256 i) returns() -func (_Overload *Overload) PackFoo0(i *big.Int) ([]byte, error) { - return _Overload.abi.Pack("foo0", i) -} - -// OverloadBar represents a Bar event raised by the Overload contract. -type OverloadBar struct { - I *big.Int - Raw *types.Log // Blockchain specific contextual infos -} - -const OverloadBarEventName = "bar" - -func (_Overload *Overload) UnpackBarEvent(log *types.Log) (*OverloadBar, error) { - event := "bar" - if log.Topics[0] != _Overload.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(OverloadBar) - if len(log.Data) > 0 { - if err := _Overload.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _Overload.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 -} - -// OverloadBar0 represents a Bar0 event raised by the Overload contract. -type OverloadBar0 struct { - I *big.Int - J *big.Int - Raw *types.Log // Blockchain specific contextual infos -} - -const OverloadBar0EventName = "bar0" - -func (_Overload *Overload) UnpackBar0Event(log *types.Log) (*OverloadBar0, error) { - event := "bar0" - if log.Topics[0] != _Overload.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(OverloadBar0) - if len(log.Data) > 0 { - if err := _Overload.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _Overload.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/convertedv1bindtests/rangekeyword.go b/accounts/abi/bind/convertedv1bindtests/rangekeyword.go deleted file mode 100644 index e9a957d66c24..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/rangekeyword.go +++ /dev/null @@ -1,58 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// RangeKeywordMetaData contains all meta data concerning the RangeKeyword contract. -var RangeKeywordMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"range\",\"type\":\"uint256\"}],\"name\":\"functionWithKeywordParameter\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"}]", - Pattern: "cec8c872ba06feb1b8f0a00e7b237eb226", - Bin: "0x608060405234801561001057600080fd5b5060dc8061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063527a119f14602d575b600080fd5b60436004803603810190603f9190605b565b6045565b005b50565b6000813590506055816092565b92915050565b600060208284031215606e57606d608d565b5b6000607a848285016048565b91505092915050565b6000819050919050565b600080fd5b6099816083565b811460a357600080fd5b5056fea2646970667358221220d4f4525e2615516394055d369fb17df41c359e5e962734f27fd683ea81fd9db164736f6c63430008070033", -} - -// RangeKeyword is an auto generated Go binding around an Ethereum contract. -type RangeKeyword struct { - abi abi.ABI -} - -// NewRangeKeyword creates a new instance of RangeKeyword. -func NewRangeKeyword() (*RangeKeyword, error) { - parsed, err := RangeKeywordMetaData.GetAbi() - if err != nil { - return nil, err - } - return &RangeKeyword{abi: *parsed}, nil -} - -func (_RangeKeyword *RangeKeyword) PackConstructor() []byte { - res, _ := _RangeKeyword.abi.Pack("") - return res -} - -// FunctionWithKeywordParameter is a free data retrieval call binding the contract method 0x527a119f. -// -// Solidity: function functionWithKeywordParameter(uint256 range) pure returns() -func (_RangeKeyword *RangeKeyword) PackFunctionWithKeywordParameter(arg0 *big.Int) ([]byte, error) { - return _RangeKeyword.abi.Pack("functionWithKeywordParameter", arg0) -} diff --git a/accounts/abi/bind/convertedv1bindtests/slicer.go b/accounts/abi/bind/convertedv1bindtests/slicer.go deleted file mode 100644 index 8deb68d012c2..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/slicer.go +++ /dev/null @@ -1,131 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// SlicerMetaData contains all meta data concerning the Slicer contract. -var SlicerMetaData = &bind.MetaData{ - ABI: "[{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"address[]\"}],\"name\":\"echoAddresses\",\"outputs\":[{\"name\":\"output\",\"type\":\"address[]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"uint24[23]\"}],\"name\":\"echoFancyInts\",\"outputs\":[{\"name\":\"output\",\"type\":\"uint24[23]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"int256[]\"}],\"name\":\"echoInts\",\"outputs\":[{\"name\":\"output\",\"type\":\"int256[]\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"input\",\"type\":\"bool[]\"}],\"name\":\"echoBools\",\"outputs\":[{\"name\":\"output\",\"type\":\"bool[]\"}],\"type\":\"function\"}]", - Pattern: "082c0740ab6537c7169cb573d097c52112", - Bin: "0x606060405261015c806100126000396000f3606060405260e060020a6000350463be1127a3811461003c578063d88becc014610092578063e15a3db71461003c578063f637e5891461003c575b005b604080516020600480358082013583810285810185019096528085526100ee959294602494909392850192829185019084908082843750949650505050505050604080516020810190915260009052805b919050565b604080516102e0818101909252610138916004916102e491839060179083908390808284375090955050505050506102e0604051908101604052806017905b60008152602001906001900390816100d15790505081905061008d565b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600f02600301f1509050019250505060405180910390f35b60405180826102e0808381846000600461015cf15090500191505060405180910390f3", -} - -// Slicer is an auto generated Go binding around an Ethereum contract. -type Slicer struct { - abi abi.ABI -} - -// NewSlicer creates a new instance of Slicer. -func NewSlicer() (*Slicer, error) { - parsed, err := SlicerMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Slicer{abi: *parsed}, nil -} - -func (_Slicer *Slicer) PackConstructor() []byte { - res, _ := _Slicer.abi.Pack("") - return res -} - -// EchoAddresses is a free data retrieval call binding the contract method 0xbe1127a3. -// -// Solidity: function echoAddresses(address[] input) returns(address[] output) -func (_Slicer *Slicer) PackEchoAddresses(input []common.Address) ([]byte, error) { - return _Slicer.abi.Pack("echoAddresses", input) -} - -func (_Slicer *Slicer) UnpackEchoAddresses(data []byte) ([]common.Address, error) { - out, err := _Slicer.abi.Unpack("echoAddresses", data) - - if err != nil { - return *new([]common.Address), err - } - - out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) - - return out0, err - -} - -// EchoBools is a free data retrieval call binding the contract method 0xf637e589. -// -// Solidity: function echoBools(bool[] input) returns(bool[] output) -func (_Slicer *Slicer) PackEchoBools(input []bool) ([]byte, error) { - return _Slicer.abi.Pack("echoBools", input) -} - -func (_Slicer *Slicer) UnpackEchoBools(data []byte) ([]bool, error) { - out, err := _Slicer.abi.Unpack("echoBools", data) - - if err != nil { - return *new([]bool), err - } - - out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) - - return out0, err - -} - -// EchoFancyInts is a free data retrieval call binding the contract method 0xd88becc0. -// -// Solidity: function echoFancyInts(uint24[23] input) returns(uint24[23] output) -func (_Slicer *Slicer) PackEchoFancyInts(input [23]*big.Int) ([]byte, error) { - return _Slicer.abi.Pack("echoFancyInts", input) -} - -func (_Slicer *Slicer) UnpackEchoFancyInts(data []byte) ([23]*big.Int, error) { - out, err := _Slicer.abi.Unpack("echoFancyInts", data) - - if err != nil { - return *new([23]*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new([23]*big.Int)).(*[23]*big.Int) - - return out0, err - -} - -// EchoInts is a free data retrieval call binding the contract method 0xe15a3db7. -// -// Solidity: function echoInts(int256[] input) returns(int256[] output) -func (_Slicer *Slicer) PackEchoInts(input []*big.Int) ([]byte, error) { - return _Slicer.abi.Pack("echoInts", input) -} - -func (_Slicer *Slicer) UnpackEchoInts(data []byte) ([]*big.Int, error) { - out, err := _Slicer.abi.Unpack("echoInts", 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/convertedv1bindtests/structs.go b/accounts/abi/bind/convertedv1bindtests/structs.go deleted file mode 100644 index 0e0d116fa6bb..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/structs.go +++ /dev/null @@ -1,105 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// Struct0 is an auto generated low-level Go binding around an user-defined struct. -type Struct0 struct { - B [32]byte -} - -// TODO: convert this type to value type after everything works. -// StructsMetaData contains all meta data concerning the Structs contract. -var StructsMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"F\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"c\",\"type\":\"uint256[]\"},{\"internalType\":\"bool[]\",\"name\":\"d\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"G\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"B\",\"type\":\"bytes32\"}],\"internalType\":\"structStructs.A[]\",\"name\":\"a\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Pattern: "920a35318e7581766aec7a17218628a91d", - Bin: "0x608060405234801561001057600080fd5b50610278806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806328811f591461003b5780636fecb6231461005b575b600080fd5b610043610070565b604051610052939291906101a0565b60405180910390f35b6100636100d6565b6040516100529190610186565b604080516002808252606082810190935282918291829190816020015b610095610131565b81526020019060019003908161008d575050805190915061026960611b9082906000906100be57fe5b60209081029190910101515293606093508392509050565b6040805160028082526060828101909352829190816020015b6100f7610131565b8152602001906001900390816100ef575050805190915061026960611b90829060009061012057fe5b602090810291909101015152905090565b60408051602081019091526000815290565b815260200190565b6000815180845260208085019450808401835b8381101561017b578151518752958201959082019060010161015e565b509495945050505050565b600060208252610199602083018461014b565b9392505050565b6000606082526101b3606083018661014b565b6020838203818501528186516101c98185610239565b91508288019350845b818110156101f3576101e5838651610143565b9484019492506001016101d2565b505084810360408601528551808252908201925081860190845b8181101561022b57825115158552938301939183019160010161020d565b509298975050505050505050565b9081526020019056fea2646970667358221220eb85327e285def14230424c52893aebecec1e387a50bb6b75fc4fdbed647f45f64736f6c63430006050033", -} - -// Structs is an auto generated Go binding around an Ethereum contract. -type Structs struct { - abi abi.ABI -} - -// NewStructs creates a new instance of Structs. -func NewStructs() (*Structs, error) { - parsed, err := StructsMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Structs{abi: *parsed}, nil -} - -func (_Structs *Structs) PackConstructor() []byte { - res, _ := _Structs.abi.Pack("") - return res -} - -// F is a free data retrieval call binding the contract method 0x28811f59. -// -// Solidity: function F() view returns((bytes32)[] a, uint256[] c, bool[] d) -func (_Structs *Structs) PackF() ([]byte, error) { - return _Structs.abi.Pack("F") -} - -type FOutput struct { - A []Struct0 - C []*big.Int - D []bool -} - -func (_Structs *Structs) UnpackF(data []byte) (FOutput, error) { - out, err := _Structs.abi.Unpack("F", data) - - outstruct := new(FOutput) - if err != nil { - return *outstruct, err - } - - outstruct.A = *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0) - outstruct.C = *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int) - outstruct.D = *abi.ConvertType(out[2], new([]bool)).(*[]bool) - - return *outstruct, err - -} - -// G is a free data retrieval call binding the contract method 0x6fecb623. -// -// Solidity: function G() view returns((bytes32)[] a) -func (_Structs *Structs) PackG() ([]byte, error) { - return _Structs.abi.Pack("G") -} - -func (_Structs *Structs) UnpackG(data []byte) ([]Struct0, error) { - out, err := _Structs.abi.Unpack("G", data) - - if err != nil { - return *new([]Struct0), err - } - - out0 := *abi.ConvertType(out[0], new([]Struct0)).(*[]Struct0) - - return out0, err - -} diff --git a/accounts/abi/bind/convertedv1bindtests/token.go b/accounts/abi/bind/convertedv1bindtests/token.go deleted file mode 100644 index 27452999bd71..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/token.go +++ /dev/null @@ -1,252 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// TokenMetaData contains all meta data concerning the Token contract. -var TokenMetaData = &bind.MetaData{ - ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"},{\"name\":\"_extraData\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"spentAllowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"type\":\"function\"},{\"inputs\":[{\"name\":\"initialSupply\",\"type\":\"uint256\"},{\"name\":\"tokenName\",\"type\":\"string\"},{\"name\":\"decimalUnits\",\"type\":\"uint8\"},{\"name\":\"tokenSymbol\",\"type\":\"string\"}],\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]", - Pattern: "1317f51c845ce3bfb7c268e5337a825f12", - Bin: "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", -} - -// Token is an auto generated Go binding around an Ethereum contract. -type Token struct { - abi abi.ABI -} - -// NewToken creates a new instance of Token. -func NewToken() (*Token, error) { - parsed, err := TokenMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Token{abi: *parsed}, nil -} - -func (_Token *Token) PackConstructor(initialSupply *big.Int, tokenName string, decimalUnits uint8, tokenSymbol string) []byte { - res, _ := _Token.abi.Pack("", initialSupply, tokenName, decimalUnits, tokenSymbol) - return res -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address , address ) returns(uint256) -func (_Token *Token) PackAllowance(arg0 common.Address, arg1 common.Address) ([]byte, error) { - return _Token.abi.Pack("allowance", arg0, arg1) -} - -func (_Token *Token) UnpackAllowance(data []byte) (*big.Int, error) { - out, err := _Token.abi.Unpack("allowance", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// ApproveAndCall is a free data retrieval call binding the contract method 0xcae9ca51. -// -// Solidity: function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns(bool success) -func (_Token *Token) PackApproveAndCall(_spender common.Address, _value *big.Int, _extraData []byte) ([]byte, error) { - return _Token.abi.Pack("approveAndCall", _spender, _value, _extraData) -} - -func (_Token *Token) UnpackApproveAndCall(data []byte) (bool, error) { - out, err := _Token.abi.Unpack("approveAndCall", data) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address ) returns(uint256) -func (_Token *Token) PackBalanceOf(arg0 common.Address) ([]byte, error) { - return _Token.abi.Pack("balanceOf", arg0) -} - -func (_Token *Token) UnpackBalanceOf(data []byte) (*big.Int, error) { - out, err := _Token.abi.Unpack("balanceOf", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Decimals is a free data retrieval call binding the contract method 0x313ce567. -// -// Solidity: function decimals() returns(uint8) -func (_Token *Token) PackDecimals() ([]byte, error) { - return _Token.abi.Pack("decimals") -} - -func (_Token *Token) UnpackDecimals(data []byte) (uint8, error) { - out, err := _Token.abi.Unpack("decimals", data) - - if err != nil { - return *new(uint8), err - } - - out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) - - return out0, err - -} - -// Name is a free data retrieval call binding the contract method 0x06fdde03. -// -// Solidity: function name() returns(string) -func (_Token *Token) PackName() ([]byte, error) { - return _Token.abi.Pack("name") -} - -func (_Token *Token) UnpackName(data []byte) (string, error) { - out, err := _Token.abi.Unpack("name", data) - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// SpentAllowance is a free data retrieval call binding the contract method 0xdc3080f2. -// -// Solidity: function spentAllowance(address , address ) returns(uint256) -func (_Token *Token) PackSpentAllowance(arg0 common.Address, arg1 common.Address) ([]byte, error) { - return _Token.abi.Pack("spentAllowance", arg0, arg1) -} - -func (_Token *Token) UnpackSpentAllowance(data []byte) (*big.Int, error) { - out, err := _Token.abi.Unpack("spentAllowance", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Symbol is a free data retrieval call binding the contract method 0x95d89b41. -// -// Solidity: function symbol() returns(string) -func (_Token *Token) PackSymbol() ([]byte, error) { - return _Token.abi.Pack("symbol") -} - -func (_Token *Token) UnpackSymbol(data []byte) (string, error) { - out, err := _Token.abi.Unpack("symbol", data) - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// Transfer is a free data retrieval call binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address _to, uint256 _value) returns() -func (_Token *Token) PackTransfer(_to common.Address, _value *big.Int) ([]byte, error) { - return _Token.abi.Pack("transfer", _to, _value) -} - -// TransferFrom is a free data retrieval call binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success) -func (_Token *Token) PackTransferFrom(_from common.Address, _to common.Address, _value *big.Int) ([]byte, error) { - return _Token.abi.Pack("transferFrom", _from, _to, _value) -} - -func (_Token *Token) UnpackTransferFrom(data []byte) (bool, error) { - out, err := _Token.abi.Unpack("transferFrom", data) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// TokenTransfer represents a Transfer event raised by the Token contract. -type TokenTransfer struct { - From common.Address - To common.Address - Value *big.Int - Raw *types.Log // Blockchain specific contextual infos -} - -const TokenTransferEventName = "Transfer" - -func (_Token *Token) UnpackTransferEvent(log *types.Log) (*TokenTransfer, error) { - event := "Transfer" - if log.Topics[0] != _Token.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(TokenTransfer) - if len(log.Data) > 0 { - if err := _Token.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _Token.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/convertedv1bindtests/tuple.go b/accounts/abi/bind/convertedv1bindtests/tuple.go deleted file mode 100644 index 602a3d8887c7..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/tuple.go +++ /dev/null @@ -1,191 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TupleP is an auto generated low-level Go binding around an user-defined struct. -type TupleP struct { - X uint8 - Y uint8 -} - -// TupleQ is an auto generated low-level Go binding around an user-defined struct. -type TupleQ struct { - X uint16 - Y uint16 -} - -// TupleS is an auto generated low-level Go binding around an user-defined struct. -type TupleS struct { - A *big.Int - B []*big.Int - C []TupleT -} - -// TupleT is an auto generated low-level Go binding around an user-defined struct. -type TupleT struct { - X *big.Int - Y *big.Int -} - -// TODO: convert this type to value type after everything works. -// TupleMetaData contains all meta data concerning the Tuple contract. -var TupleMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"indexed\":false,\"internalType\":\"structTuple.S\",\"name\":\"a\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"structTuple.T[2][]\",\"name\":\"b\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"structTuple.T[][2]\",\"name\":\"c\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"indexed\":false,\"internalType\":\"structTuple.S[]\",\"name\":\"d\",\"type\":\"tuple[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"e\",\"type\":\"uint256[]\"}],\"name\":\"TupleEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"x\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"y\",\"type\":\"uint8\"}],\"indexed\":false,\"internalType\":\"structTuple.P[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"name\":\"TupleEvent2\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S\",\"name\":\"a\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[2][]\",\"name\":\"b\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[][2]\",\"name\":\"c\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S[]\",\"name\":\"d\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"e\",\"type\":\"uint256[]\"}],\"name\":\"func1\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S\",\"name\":\"\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[2][]\",\"name\":\"\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[][2]\",\"name\":\"\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S[]\",\"name\":\"\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S\",\"name\":\"a\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[2][]\",\"name\":\"b\",\"type\":\"tuple[2][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[][2]\",\"name\":\"c\",\"type\":\"tuple[][2]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"b\",\"type\":\"uint256[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"x\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"y\",\"type\":\"uint256\"}],\"internalType\":\"structTuple.T[]\",\"name\":\"c\",\"type\":\"tuple[]\"}],\"internalType\":\"structTuple.S[]\",\"name\":\"d\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256[]\",\"name\":\"e\",\"type\":\"uint256[]\"}],\"name\":\"func2\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"y\",\"type\":\"uint16\"}],\"internalType\":\"structTuple.Q[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"name\":\"func3\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}]", - Pattern: "96ee1e2b1b89f8c495f200e4956278a4d4", - Bin: "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", -} - -// Tuple is an auto generated Go binding around an Ethereum contract. -type Tuple struct { - abi abi.ABI -} - -// NewTuple creates a new instance of Tuple. -func NewTuple() (*Tuple, error) { - parsed, err := TupleMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Tuple{abi: *parsed}, nil -} - -func (_Tuple *Tuple) PackConstructor() []byte { - res, _ := _Tuple.abi.Pack("") - return res -} - -// Func1 is a free data retrieval call binding the contract method 0x443c79b4. -// -// Solidity: function func1((uint256,uint256[],(uint256,uint256)[]) a, (uint256,uint256)[2][] b, (uint256,uint256)[][2] c, (uint256,uint256[],(uint256,uint256)[])[] d, uint256[] e) pure returns((uint256,uint256[],(uint256,uint256)[]), (uint256,uint256)[2][], (uint256,uint256)[][2], (uint256,uint256[],(uint256,uint256)[])[], uint256[]) -func (_Tuple *Tuple) PackFunc1(a TupleS, b [][2]TupleT, c [2][]TupleT, d []TupleS, e []*big.Int) ([]byte, error) { - return _Tuple.abi.Pack("func1", a, b, c, d, e) -} - -type Func1Output struct { - Arg TupleS - Arg0 [][2]TupleT - Arg1 [2][]TupleT - Arg2 []TupleS - Arg3 []*big.Int -} - -func (_Tuple *Tuple) UnpackFunc1(data []byte) (Func1Output, error) { - out, err := _Tuple.abi.Unpack("func1", data) - - outstruct := new(Func1Output) - if err != nil { - return *outstruct, err - } - - outstruct.Arg = *abi.ConvertType(out[0], new(TupleS)).(*TupleS) - outstruct.Arg0 = *abi.ConvertType(out[1], new([][2]TupleT)).(*[][2]TupleT) - outstruct.Arg1 = *abi.ConvertType(out[2], new([2][]TupleT)).(*[2][]TupleT) - outstruct.Arg2 = *abi.ConvertType(out[3], new([]TupleS)).(*[]TupleS) - outstruct.Arg3 = *abi.ConvertType(out[4], new([]*big.Int)).(*[]*big.Int) - - return *outstruct, err - -} - -// Func2 is a free data retrieval call binding the contract method 0xd0062cdd. -// -// Solidity: function func2((uint256,uint256[],(uint256,uint256)[]) a, (uint256,uint256)[2][] b, (uint256,uint256)[][2] c, (uint256,uint256[],(uint256,uint256)[])[] d, uint256[] e) returns() -func (_Tuple *Tuple) PackFunc2(a TupleS, b [][2]TupleT, c [2][]TupleT, d []TupleS, e []*big.Int) ([]byte, error) { - return _Tuple.abi.Pack("func2", a, b, c, d, e) -} - -// Func3 is a free data retrieval call binding the contract method 0xe4d9a43b. -// -// Solidity: function func3((uint16,uint16)[] ) pure returns() -func (_Tuple *Tuple) PackFunc3(arg0 []TupleQ) ([]byte, error) { - return _Tuple.abi.Pack("func3", arg0) -} - -// TupleTupleEvent represents a TupleEvent event raised by the Tuple contract. -type TupleTupleEvent struct { - A TupleS - B [][2]TupleT - C [2][]TupleT - D []TupleS - E []*big.Int - Raw *types.Log // Blockchain specific contextual infos -} - -const TupleTupleEventEventName = "TupleEvent" - -func (_Tuple *Tuple) UnpackTupleEventEvent(log *types.Log) (*TupleTupleEvent, error) { - event := "TupleEvent" - if log.Topics[0] != _Tuple.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(TupleTupleEvent) - if len(log.Data) > 0 { - if err := _Tuple.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _Tuple.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 -} - -// TupleTupleEvent2 represents a TupleEvent2 event raised by the Tuple contract. -type TupleTupleEvent2 struct { - Arg0 []TupleP - Raw *types.Log // Blockchain specific contextual infos -} - -const TupleTupleEvent2EventName = "TupleEvent2" - -func (_Tuple *Tuple) UnpackTupleEvent2Event(log *types.Log) (*TupleTupleEvent2, error) { - event := "TupleEvent2" - if log.Topics[0] != _Tuple.abi.Events[event].ID { - return nil, errors.New("event signature mismatch") - } - out := new(TupleTupleEvent2) - if len(log.Data) > 0 { - if err := _Tuple.abi.UnpackIntoInterface(out, event, log.Data); err != nil { - return nil, err - } - } - var indexed abi.Arguments - for _, arg := range _Tuple.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/convertedv1bindtests/tupler.go b/accounts/abi/bind/convertedv1bindtests/tupler.go deleted file mode 100644 index d315611b3f16..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/tupler.go +++ /dev/null @@ -1,80 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// TuplerMetaData contains all meta data concerning the Tupler contract. -var TuplerMetaData = &bind.MetaData{ - ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"tuple\",\"outputs\":[{\"name\":\"a\",\"type\":\"string\"},{\"name\":\"b\",\"type\":\"int256\"},{\"name\":\"c\",\"type\":\"bytes32\"}],\"type\":\"function\"}]", - Pattern: "a8f4d2061f55c712cfae266c426a1cd568", - Bin: "0x606060405260dc8060106000396000f3606060405260e060020a60003504633175aae28114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3", -} - -// Tupler is an auto generated Go binding around an Ethereum contract. -type Tupler struct { - abi abi.ABI -} - -// NewTupler creates a new instance of Tupler. -func NewTupler() (*Tupler, error) { - parsed, err := TuplerMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Tupler{abi: *parsed}, nil -} - -func (_Tupler *Tupler) PackConstructor() []byte { - res, _ := _Tupler.abi.Pack("") - return res -} - -// Tuple is a free data retrieval call binding the contract method 0x3175aae2. -// -// Solidity: function tuple() returns(string a, int256 b, bytes32 c) -func (_Tupler *Tupler) PackTuple() ([]byte, error) { - return _Tupler.abi.Pack("tuple") -} - -type TupleOutput struct { - A string - B *big.Int - C [32]byte -} - -func (_Tupler *Tupler) UnpackTuple(data []byte) (TupleOutput, error) { - out, err := _Tupler.abi.Unpack("tuple", data) - - outstruct := new(TupleOutput) - if err != nil { - return *outstruct, err - } - - outstruct.A = *abi.ConvertType(out[0], new(string)).(*string) - outstruct.B = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - outstruct.C = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) - - return *outstruct, err - -} diff --git a/accounts/abi/bind/convertedv1bindtests/underscorer.go b/accounts/abi/bind/convertedv1bindtests/underscorer.go deleted file mode 100644 index 0ad5c5e3e951..000000000000 --- a/accounts/abi/bind/convertedv1bindtests/underscorer.go +++ /dev/null @@ -1,260 +0,0 @@ -// Code generated via abigen V2 - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package convertedv1bindtests - -import ( - "errors" - "math/big" - - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = abi.ConvertType -) - -// TODO: convert this type to value type after everything works. -// UnderscorerMetaData contains all meta data concerning the Underscorer contract. -var UnderscorerMetaData = &bind.MetaData{ - ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"LowerUpperCollision\",\"outputs\":[{\"name\":\"_res\",\"type\":\"int256\"},{\"name\":\"Res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_under_scored_func\",\"outputs\":[{\"name\":\"_int\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UnderscoredOutput\",\"outputs\":[{\"name\":\"_int\",\"type\":\"int256\"},{\"name\":\"_string\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"PurelyUnderscoredOutput\",\"outputs\":[{\"name\":\"_\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UpperLowerCollision\",\"outputs\":[{\"name\":\"_Res\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"AllPurelyUnderscoredOutput\",\"outputs\":[{\"name\":\"_\",\"type\":\"int256\"},{\"name\":\"__\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"UpperUpperCollision\",\"outputs\":[{\"name\":\"_Res\",\"type\":\"int256\"},{\"name\":\"Res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"LowerLowerCollision\",\"outputs\":[{\"name\":\"_res\",\"type\":\"int256\"},{\"name\":\"res\",\"type\":\"int256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", - Pattern: "5873a90ab43c925dfced86ad53f871f01d", - Bin: "0x6060604052341561000f57600080fd5b6103858061001e6000396000f30060606040526004361061008e576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806303a592131461009357806346546dbe146100c357806367e6633d146100ec5780639df4848514610181578063af7486ab146101b1578063b564b34d146101e1578063e02ab24d14610211578063e409ca4514610241575b600080fd5b341561009e57600080fd5b6100a6610271565b604051808381526020018281526020019250505060405180910390f35b34156100ce57600080fd5b6100d6610286565b6040518082815260200191505060405180910390f35b34156100f757600080fd5b6100ff61028e565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561014557808201518184015260208101905061012a565b50505050905090810190601f1680156101725780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561018c57600080fd5b6101946102dc565b604051808381526020018281526020019250505060405180910390f35b34156101bc57600080fd5b6101c46102f1565b604051808381526020018281526020019250505060405180910390f35b34156101ec57600080fd5b6101f4610306565b604051808381526020018281526020019250505060405180910390f35b341561021c57600080fd5b61022461031b565b604051808381526020018281526020019250505060405180910390f35b341561024c57600080fd5b610254610330565b604051808381526020018281526020019250505060405180910390f35b60008060016002819150809050915091509091565b600080905090565b6000610298610345565b61013a8090506040805190810160405280600281526020017f7069000000000000000000000000000000000000000000000000000000000000815250915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b6020604051908101604052806000815250905600a165627a7a72305820d1a53d9de9d1e3d55cb3dc591900b63c4f1ded79114f7b79b332684840e186a40029", -} - -// Underscorer is an auto generated Go binding around an Ethereum contract. -type Underscorer struct { - abi abi.ABI -} - -// NewUnderscorer creates a new instance of Underscorer. -func NewUnderscorer() (*Underscorer, error) { - parsed, err := UnderscorerMetaData.GetAbi() - if err != nil { - return nil, err - } - return &Underscorer{abi: *parsed}, nil -} - -func (_Underscorer *Underscorer) PackConstructor() []byte { - res, _ := _Underscorer.abi.Pack("") - return res -} - -// AllPurelyUnderscoredOutput is a free data retrieval call binding the contract method 0xb564b34d. -// -// Solidity: function AllPurelyUnderscoredOutput() view returns(int256 _, int256 __) -func (_Underscorer *Underscorer) PackAllPurelyUnderscoredOutput() ([]byte, error) { - return _Underscorer.abi.Pack("AllPurelyUnderscoredOutput") -} - -type AllPurelyUnderscoredOutputOutput struct { - Arg *big.Int - Arg0 *big.Int -} - -func (_Underscorer *Underscorer) UnpackAllPurelyUnderscoredOutput(data []byte) (AllPurelyUnderscoredOutputOutput, error) { - out, err := _Underscorer.abi.Unpack("AllPurelyUnderscoredOutput", data) - - outstruct := new(AllPurelyUnderscoredOutputOutput) - 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) - - return *outstruct, err - -} - -// LowerLowerCollision is a free data retrieval call binding the contract method 0xe409ca45. -// -// Solidity: function LowerLowerCollision() view returns(int256 _res, int256 res) -func (_Underscorer *Underscorer) PackLowerLowerCollision() ([]byte, error) { - return _Underscorer.abi.Pack("LowerLowerCollision") -} - -type LowerLowerCollisionOutput struct { - Res *big.Int - Res *big.Int -} - -func (_Underscorer *Underscorer) UnpackLowerLowerCollision(data []byte) (LowerLowerCollisionOutput, error) { - out, err := _Underscorer.abi.Unpack("LowerLowerCollision", data) - - outstruct := new(LowerLowerCollisionOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// LowerUpperCollision is a free data retrieval call binding the contract method 0x03a59213. -// -// Solidity: function LowerUpperCollision() view returns(int256 _res, int256 Res) -func (_Underscorer *Underscorer) PackLowerUpperCollision() ([]byte, error) { - return _Underscorer.abi.Pack("LowerUpperCollision") -} - -type LowerUpperCollisionOutput struct { - Res *big.Int - Res *big.Int -} - -func (_Underscorer *Underscorer) UnpackLowerUpperCollision(data []byte) (LowerUpperCollisionOutput, error) { - out, err := _Underscorer.abi.Unpack("LowerUpperCollision", data) - - outstruct := new(LowerUpperCollisionOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// PurelyUnderscoredOutput is a free data retrieval call binding the contract method 0x9df48485. -// -// Solidity: function PurelyUnderscoredOutput() view returns(int256 _, int256 res) -func (_Underscorer *Underscorer) PackPurelyUnderscoredOutput() ([]byte, error) { - return _Underscorer.abi.Pack("PurelyUnderscoredOutput") -} - -type PurelyUnderscoredOutputOutput struct { - Arg *big.Int - Res *big.Int -} - -func (_Underscorer *Underscorer) UnpackPurelyUnderscoredOutput(data []byte) (PurelyUnderscoredOutputOutput, error) { - out, err := _Underscorer.abi.Unpack("PurelyUnderscoredOutput", data) - - outstruct := new(PurelyUnderscoredOutputOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Arg = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// UnderscoredOutput is a free data retrieval call binding the contract method 0x67e6633d. -// -// Solidity: function UnderscoredOutput() view returns(int256 _int, string _string) -func (_Underscorer *Underscorer) PackUnderscoredOutput() ([]byte, error) { - return _Underscorer.abi.Pack("UnderscoredOutput") -} - -type UnderscoredOutputOutput struct { - Int *big.Int - String string -} - -func (_Underscorer *Underscorer) UnpackUnderscoredOutput(data []byte) (UnderscoredOutputOutput, error) { - out, err := _Underscorer.abi.Unpack("UnderscoredOutput", data) - - outstruct := new(UnderscoredOutputOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Int = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.String = *abi.ConvertType(out[1], new(string)).(*string) - - return *outstruct, err - -} - -// UpperLowerCollision is a free data retrieval call binding the contract method 0xaf7486ab. -// -// Solidity: function UpperLowerCollision() view returns(int256 _Res, int256 res) -func (_Underscorer *Underscorer) PackUpperLowerCollision() ([]byte, error) { - return _Underscorer.abi.Pack("UpperLowerCollision") -} - -type UpperLowerCollisionOutput struct { - Res *big.Int - Res *big.Int -} - -func (_Underscorer *Underscorer) UnpackUpperLowerCollision(data []byte) (UpperLowerCollisionOutput, error) { - out, err := _Underscorer.abi.Unpack("UpperLowerCollision", data) - - outstruct := new(UpperLowerCollisionOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// UpperUpperCollision is a free data retrieval call binding the contract method 0xe02ab24d. -// -// Solidity: function UpperUpperCollision() view returns(int256 _Res, int256 Res) -func (_Underscorer *Underscorer) PackUpperUpperCollision() ([]byte, error) { - return _Underscorer.abi.Pack("UpperUpperCollision") -} - -type UpperUpperCollisionOutput struct { - Res *big.Int - Res *big.Int -} - -func (_Underscorer *Underscorer) UnpackUpperUpperCollision(data []byte) (UpperUpperCollisionOutput, error) { - out, err := _Underscorer.abi.Unpack("UpperUpperCollision", data) - - outstruct := new(UpperUpperCollisionOutput) - if err != nil { - return *outstruct, err - } - - outstruct.Res = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.Res = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// UnderScoredFunc is a free data retrieval call binding the contract method 0x46546dbe. -// -// Solidity: function _under_scored_func() view returns(int256 _int) -func (_Underscorer *Underscorer) PackUnderScoredFunc() ([]byte, error) { - return _Underscorer.abi.Pack("_under_scored_func") -} - -func (_Underscorer *Underscorer) UnpackUnderScoredFunc(data []byte) (*big.Int, error) { - out, err := _Underscorer.abi.Unpack("_under_scored_func", data) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} From f9bca581ef36756de8a0197ef66777ace264c5df Mon Sep 17 00:00:00 2001 From: Jared Wasinger Date: Mon, 30 Dec 2024 16:12:13 +0700 Subject: [PATCH 104/104] 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: "0x6080604052348015600e575f80fd5b5061042c8061001c5f395ff3fe608060405234801561000f575f80fd5b506004361061004a575f3560e01c80636fd8b9681461004e578063cb4937491461006f578063e8e49a7114610079578063edcdc89414610083575b5f80fd5b6100566100b3565b6040516100669493929190610244565b60405180910390f35b6100776100c9565b005b61008161017a565b005b61009d600480360381019061009891906102ad565b6101b6565b6040516100aa9190610364565b60405180910390f35b5f805f805f805f80935093509350935090919293565b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd20760026040516100fb919061037d565b60405180910390a260037f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd2076004604051610135919061037d565b60405180910390a25f15157f3b29b9f6d15ba80d866afb3d70b7548ab1ffda3ef6e65f35f1cb05b0e2b29f4e6001604051610170919061037d565b60405180910390a2565b60017f8f17dc823e2f9fcdf730b8182c935574691e811e7d46399fe0ff0087795cd20760026040516101ac919061037d565b60405180910390a2565b366101bf6101fa565b6001835f01356101cf91906103c3565b815f018181525050600183602001356101e891906103c3565b81602001818152505082915050919050565b60405180604001604052805f81526020015f81525090565b5f819050919050565b61022481610212565b82525050565b5f8115159050919050565b61023e8161022a565b82525050565b5f6080820190506102575f83018761021b565b610264602083018661021b565b610271604083018561021b565b61027e6060830184610235565b95945050505050565b5f80fd5b5f80fd5b5f604082840312156102a4576102a361028b565b5b81905092915050565b5f604082840312156102c2576102c1610287565b5b5f6102cf8482850161028f565b91505092915050565b6102e181610212565b81146102eb575f80fd5b50565b5f813590506102fc816102d8565b92915050565b5f61031060208401846102ee565b905092915050565b61032181610212565b82525050565b604082016103375f830183610302565b6103435f850182610318565b506103516020830183610302565b61035e6020850182610318565b50505050565b5f6040820190506103775f830184610327565b92915050565b5f6020820190506103905f83018461021b565b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6103cd82610212565b91506103d883610212565b92508282019050808211156103f0576103ef610396565b5b9291505056fea264697066735822122037c4a3caaa4ac1fad7bb712bf2dc85b5d19726dd357808a46ac3b90d2f03dff564736f6c634300081a0033", +} + +// 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 +}