2016-03-16 05:48:33 -05:00
|
|
|
// Copyright 2016 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 <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
package bind
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"os"
|
|
|
|
"os/exec"
|
|
|
|
"path/filepath"
|
|
|
|
"runtime"
|
|
|
|
"strings"
|
|
|
|
"testing"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
)
|
|
|
|
|
|
|
|
var bindTests = []struct {
|
|
|
|
name string
|
|
|
|
contract string
|
2019-07-08 03:27:05 -05:00
|
|
|
bytecode []string
|
|
|
|
abi []string
|
2018-10-05 15:24:54 -05:00
|
|
|
imports string
|
2016-03-16 05:48:33 -05:00
|
|
|
tester string
|
2019-07-02 02:52:58 -05:00
|
|
|
fsigs []map[string]string
|
2019-07-08 03:27:05 -05:00
|
|
|
libs map[string]string
|
2019-11-14 01:26:10 -06:00
|
|
|
aliases map[string]string
|
2019-07-08 03:27:05 -05:00
|
|
|
types []string
|
2016-03-16 05:48:33 -05:00
|
|
|
}{
|
|
|
|
// Test that the binding is available in combined and separate forms too
|
|
|
|
{
|
|
|
|
`Empty`,
|
|
|
|
`contract NilContract {}`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`606060405260068060106000396000f3606060405200`},
|
|
|
|
[]string{`[]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`"github.com/ethereum/go-ethereum/common"`,
|
2016-03-21 07:34:49 -05:00
|
|
|
`
|
2016-08-21 10:06:25 -05:00
|
|
|
if b, err := NewEmpty(common.Address{}, nil); b == nil || err != nil {
|
2016-03-21 07:34:49 -05:00
|
|
|
t.Fatalf("combined binding (%v) nil or error (%v) not nil", b, nil)
|
|
|
|
}
|
2016-08-21 10:06:25 -05:00
|
|
|
if b, err := NewEmptyCaller(common.Address{}, nil); b == nil || err != nil {
|
2016-03-21 07:34:49 -05:00
|
|
|
t.Fatalf("caller binding (%v) nil or error (%v) not nil", b, nil)
|
|
|
|
}
|
2016-08-21 10:06:25 -05:00
|
|
|
if b, err := NewEmptyTransactor(common.Address{}, nil); b == nil || err != nil {
|
2016-03-21 07:34:49 -05:00
|
|
|
t.Fatalf("transactor binding (%v) nil or error (%v) not nil", b, nil)
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-03-16 05:48:33 -05:00
|
|
|
},
|
|
|
|
// Test that all the official sample contracts bind correctly
|
|
|
|
{
|
|
|
|
`Token`,
|
|
|
|
`https://ethereum.org/token`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`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
|
|
|
|
[]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"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`"github.com/ethereum/go-ethereum/common"`,
|
2016-03-21 07:34:49 -05:00
|
|
|
`
|
2016-08-21 10:06:25 -05:00
|
|
|
if b, err := NewToken(common.Address{}, nil); b == nil || err != nil {
|
2016-03-21 07:34:49 -05:00
|
|
|
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-03-16 05:48:33 -05:00
|
|
|
},
|
|
|
|
{
|
|
|
|
`Crowdsale`,
|
|
|
|
`https://ethereum.org/crowdsale`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`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`},
|
|
|
|
[]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"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`"github.com/ethereum/go-ethereum/common"`,
|
2016-03-21 07:34:49 -05:00
|
|
|
`
|
2016-08-21 10:06:25 -05:00
|
|
|
if b, err := NewCrowdsale(common.Address{}, nil); b == nil || err != nil {
|
2016-03-21 07:34:49 -05:00
|
|
|
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-03-16 05:48:33 -05:00
|
|
|
},
|
|
|
|
{
|
|
|
|
`DAO`,
|
|
|
|
`https://ethereum.org/dao`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`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
|
|
|
|
[]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":[
|
2018-10-05 15:24:54 -05:00
|
|
|
`"github.com/ethereum/go-ethereum/common"`,
|
2016-03-21 07:34:49 -05:00
|
|
|
`
|
2016-08-21 10:06:25 -05:00
|
|
|
if b, err := NewDAO(common.Address{}, nil); b == nil || err != nil {
|
2016-03-21 07:34:49 -05:00
|
|
|
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-03-21 07:34:49 -05:00
|
|
|
},
|
|
|
|
// Test that named and anonymous inputs are handled correctly
|
|
|
|
{
|
2019-07-08 03:27:05 -05:00
|
|
|
`InputChecker`, ``, []string{``},
|
|
|
|
[]string{`
|
2016-03-21 07:34:49 -05:00
|
|
|
[
|
|
|
|
{"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":[]}
|
|
|
|
]
|
2019-07-08 03:27:05 -05:00
|
|
|
`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"fmt"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
`,
|
2016-08-21 10:06:25 -05:00
|
|
|
`if b, err := NewInputChecker(common.Address{}, nil); b == nil || err != nil {
|
2016-03-16 05:48:33 -05:00
|
|
|
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
|
2016-03-21 07:34:49 -05:00
|
|
|
} else if false { // Don't run, just compile and test types
|
|
|
|
var err error
|
|
|
|
|
|
|
|
err = b.NoInput(nil)
|
|
|
|
err = b.NamedInput(nil, "")
|
|
|
|
err = b.AnonInput(nil, "")
|
|
|
|
err = b.NamedInputs(nil, "", "")
|
|
|
|
err = b.AnonInputs(nil, "", "")
|
|
|
|
err = b.MixedInputs(nil, "", "")
|
|
|
|
|
|
|
|
fmt.Println(err)
|
2016-03-16 05:48:33 -05:00
|
|
|
}`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-03-16 05:48:33 -05:00
|
|
|
},
|
2016-03-21 07:34:49 -05:00
|
|
|
// Test that named and anonymous outputs are handled correctly
|
|
|
|
{
|
2019-07-08 03:27:05 -05:00
|
|
|
`OutputChecker`, ``, []string{``},
|
|
|
|
[]string{`
|
2016-03-21 07:34:49 -05:00
|
|
|
[
|
|
|
|
{"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"}]},
|
2017-12-29 15:20:02 -06:00
|
|
|
{"type":"function","name":"collidingOutputs","constant":true,"inputs":[],"outputs":[{"name":"str","type":"string"},{"name":"Str","type":"string"}]},
|
2016-03-21 07:34:49 -05:00
|
|
|
{"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"}]}
|
|
|
|
]
|
2019-07-08 03:27:05 -05:00
|
|
|
`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"fmt"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
`,
|
2016-08-21 10:06:25 -05:00
|
|
|
`if b, err := NewOutputChecker(common.Address{}, nil); b == nil || err != nil {
|
2016-03-21 07:34:49 -05:00
|
|
|
t.Fatalf("binding (%v) nil or error (%v) not nil", b, nil)
|
|
|
|
} else if false { // Don't run, just compile and test types
|
|
|
|
var str1, str2 string
|
|
|
|
var err error
|
|
|
|
|
|
|
|
err = b.NoOutput(nil)
|
|
|
|
str1, err = b.NamedOutput(nil)
|
|
|
|
str1, err = b.AnonOutput(nil)
|
|
|
|
res, _ := b.NamedOutputs(nil)
|
2017-12-29 15:20:02 -06:00
|
|
|
str1, str2, err = b.CollidingOutputs(nil)
|
2016-03-21 07:34:49 -05:00
|
|
|
str1, str2, err = b.AnonOutputs(nil)
|
|
|
|
str1, str2, err = b.MixedOutputs(nil)
|
|
|
|
|
|
|
|
fmt.Println(str1, str2, res.Str1, res.Str2, err)
|
|
|
|
}`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-03-21 07:34:49 -05:00
|
|
|
},
|
2018-01-05 04:39:24 -06:00
|
|
|
// Tests that named, anonymous and indexed events are handled correctly
|
|
|
|
{
|
2019-07-08 03:27:05 -05:00
|
|
|
`EventChecker`, ``, []string{``},
|
|
|
|
[]string{`
|
2018-01-05 04:39:24 -06:00
|
|
|
[
|
|
|
|
{"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":[]},
|
2020-04-20 02:01:04 -05:00
|
|
|
{"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}]}
|
2018-01-05 04:39:24 -06:00
|
|
|
]
|
2019-07-08 03:27:05 -05:00
|
|
|
`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"fmt"
|
|
|
|
"math/big"
|
|
|
|
"reflect"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
`,
|
2018-01-05 04:39:24 -06:00
|
|
|
`if e, err := NewEventChecker(common.Address{}, nil); e == nil || err != nil {
|
|
|
|
t.Fatalf("binding (%v) nil or error (%v) not nil", e, nil)
|
|
|
|
} else if false { // Don't run, just compile and test types
|
|
|
|
var (
|
|
|
|
err error
|
|
|
|
res bool
|
|
|
|
str string
|
|
|
|
dat []byte
|
|
|
|
hash common.Hash
|
|
|
|
)
|
|
|
|
_, err = e.FilterEmpty(nil)
|
|
|
|
_, err = e.FilterIndexed(nil, []common.Address{}, []*big.Int{})
|
|
|
|
|
|
|
|
mit, err := e.FilterMixed(nil, []common.Address{})
|
|
|
|
|
|
|
|
res = mit.Next() // Make sure the iterator has a Next method
|
|
|
|
err = mit.Error() // Make sure the iterator has an Error method
|
|
|
|
err = mit.Close() // Make sure the iterator has a Close method
|
|
|
|
|
|
|
|
fmt.Println(mit.Event.Raw.BlockHash) // Make sure the raw log is contained within the results
|
|
|
|
fmt.Println(mit.Event.Num) // Make sure the unpacked non-indexed fields are present
|
|
|
|
fmt.Println(mit.Event.Addr) // Make sure the reconstructed indexed fields are present
|
|
|
|
|
|
|
|
dit, err := e.FilterDynamic(nil, []string{}, [][]byte{})
|
|
|
|
|
|
|
|
str = dit.Event.Str // Make sure non-indexed strings retain their type
|
|
|
|
dat = dit.Event.Dat // Make sure non-indexed bytes retain their type
|
|
|
|
hash = dit.Event.IdxStr // Make sure indexed strings turn into hashes
|
|
|
|
hash = dit.Event.IdxDat // Make sure indexed bytes turn into hashes
|
|
|
|
|
|
|
|
sink := make(chan *EventCheckerMixed)
|
|
|
|
sub, err := e.WatchMixed(nil, sink, []common.Address{})
|
|
|
|
defer sub.Unsubscribe()
|
|
|
|
|
|
|
|
event := <-sink
|
|
|
|
fmt.Println(event.Raw.BlockHash) // Make sure the raw log is contained within the results
|
|
|
|
fmt.Println(event.Num) // Make sure the unpacked non-indexed fields are present
|
|
|
|
fmt.Println(event.Addr) // Make sure the reconstructed indexed fields are present
|
|
|
|
|
|
|
|
fmt.Println(res, str, dat, hash, err)
|
2020-04-20 02:01:04 -05:00
|
|
|
|
|
|
|
oit, err := e.FilterUnnamed(nil, []*big.Int{}, []*big.Int{})
|
|
|
|
|
|
|
|
arg0 := oit.Event.Arg0 // Make sure unnamed arguments are handled correctly
|
|
|
|
arg1 := oit.Event.Arg1 // Make sure unnamed arguments are handled correctly
|
|
|
|
fmt.Println(arg0, arg1)
|
2018-01-05 04:39:24 -06:00
|
|
|
}
|
|
|
|
// Run a tiny reflection test to ensure disallowed methods don't appear
|
|
|
|
if _, ok := reflect.TypeOf(&EventChecker{}).MethodByName("FilterAnonymous"); ok {
|
|
|
|
t.Errorf("binding has disallowed method (FilterAnonymous)")
|
|
|
|
}`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2018-01-05 04:39:24 -06:00
|
|
|
},
|
2016-03-21 07:34:49 -05:00
|
|
|
// Test that contract interactions (deploy, transact and call) generate working code
|
|
|
|
{
|
|
|
|
`Interactor`,
|
|
|
|
`
|
|
|
|
contract Interactor {
|
|
|
|
string public deployString;
|
|
|
|
string public transactString;
|
|
|
|
|
|
|
|
function Interactor(string str) {
|
|
|
|
deployString = str;
|
|
|
|
}
|
|
|
|
|
|
|
|
function transact(string str) {
|
|
|
|
transactString = str;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`6060604052604051610328380380610328833981016040528051018060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f10608d57805160ff19168380011785555b50607c9291505b8082111560ba57838155600101606b565b50505061026a806100be6000396000f35b828001600101855582156064579182015b828111156064578251826000505591602001919060010190609e565b509056606060405260e060020a60003504630d86a0e181146100315780636874e8091461008d578063d736c513146100ea575b005b610190600180546020600282841615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b61019060008054602060026001831615610100026000190190921691909104601f810182900490910260809081016040526060828152929190828280156102295780601f106101fe57610100808354040283529160200191610229565b60206004803580820135601f81018490049093026080908101604052606084815261002f946024939192918401918190838280828437509496505050505050508060016000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f1061023157805160ff19168380011785555b506102619291505b808211156102665760008155830161017d565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600f02600301f150905090810190601f1680156101f05780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b820191906000526020600020905b81548152906001019060200180831161020c57829003601f168201915b505050505081565b82800160010185558215610175579182015b82811115610175578251826000505591602001919060010190610243565b505050565b509056`},
|
|
|
|
[]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"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
2016-03-21 07:34:49 -05:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
2016-03-02 06:57:15 -06:00
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2016-03-21 07:34:49 -05:00
|
|
|
|
|
|
|
// Deploy an interaction tester contract and call a transaction on it
|
|
|
|
_, _, interactor, err := DeployInteractor(auth, sim, "Deploy string")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy interactor contract: %v", err)
|
|
|
|
}
|
|
|
|
if _, err := interactor.Transact(auth, "Transact string"); err != nil {
|
|
|
|
t.Fatalf("Failed to transact with interactor contract: %v", err)
|
|
|
|
}
|
|
|
|
// Commit all pending transactions in the simulator and check the contract state
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
if str, err := interactor.DeployString(nil); err != nil {
|
|
|
|
t.Fatalf("Failed to retrieve deploy string: %v", err)
|
|
|
|
} else if str != "Deploy string" {
|
|
|
|
t.Fatalf("Deploy string mismatch: have '%s', want 'Deploy string'", str)
|
|
|
|
}
|
|
|
|
if str, err := interactor.TransactString(nil); err != nil {
|
|
|
|
t.Fatalf("Failed to retrieve transact string: %v", err)
|
|
|
|
} else if str != "Transact string" {
|
|
|
|
t.Fatalf("Transact string mismatch: have '%s', want 'Transact string'", str)
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-03-21 07:34:49 -05:00
|
|
|
},
|
2016-05-12 08:28:18 -05:00
|
|
|
// Tests that plain values can be properly returned and deserialized
|
|
|
|
{
|
|
|
|
`Getter`,
|
|
|
|
`
|
|
|
|
contract Getter {
|
|
|
|
function getter() constant returns (string, int, bytes32) {
|
|
|
|
return ("Hi", 1, sha3(""));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`606060405260dc8060106000396000f3606060405260e060020a6000350463993a04b78114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3`},
|
|
|
|
[]string{`[{"constant":true,"inputs":[],"name":"getter","outputs":[{"name":"","type":"string"},{"name":"","type":"int256"},{"name":"","type":"bytes32"}],"type":"function"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
2016-05-12 08:28:18 -05:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2016-05-12 08:28:18 -05:00
|
|
|
|
|
|
|
// Deploy a tuple tester contract and execute a structured call on it
|
|
|
|
_, _, getter, err := DeployGetter(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy getter contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
if str, num, _, err := getter.Getter(nil); err != nil {
|
|
|
|
t.Fatalf("Failed to call anonymous field retriever: %v", err)
|
|
|
|
} else if str != "Hi" || num.Cmp(big.NewInt(1)) != 0 {
|
|
|
|
t.Fatalf("Retrieved value mismatch: have %v/%v, want %v/%v", str, num, "Hi", 1)
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-05-12 08:28:18 -05:00
|
|
|
},
|
2016-03-25 08:09:06 -05:00
|
|
|
// Tests that tuples can be properly returned and deserialized
|
|
|
|
{
|
|
|
|
`Tupler`,
|
|
|
|
`
|
|
|
|
contract Tupler {
|
2016-05-12 08:28:18 -05:00
|
|
|
function tuple() constant returns (string a, int b, bytes32 c) {
|
2016-04-01 05:02:43 -05:00
|
|
|
return ("Hi", 1, sha3(""));
|
|
|
|
}
|
2016-03-25 08:09:06 -05:00
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`606060405260dc8060106000396000f3606060405260e060020a60003504633175aae28114601a575b005b600060605260c0604052600260809081527f486900000000000000000000000000000000000000000000000000000000000060a05260017fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060e0829052610100819052606060c0908152600261012081905281906101409060a09080838184600060046012f1505081517fffff000000000000000000000000000000000000000000000000000000000000169091525050604051610160819003945092505050f3`},
|
|
|
|
[]string{`[{"constant":true,"inputs":[],"name":"tuple","outputs":[{"name":"a","type":"string"},{"name":"b","type":"int256"},{"name":"c","type":"bytes32"}],"type":"function"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
2016-03-25 08:09:06 -05:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
2016-03-02 06:57:15 -06:00
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2016-03-25 08:09:06 -05:00
|
|
|
|
|
|
|
// Deploy a tuple tester contract and execute a structured call on it
|
|
|
|
_, _, tupler, err := DeployTupler(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy tupler contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
2016-05-12 08:28:18 -05:00
|
|
|
if res, err := tupler.Tuple(nil); err != nil {
|
2016-03-25 08:09:06 -05:00
|
|
|
t.Fatalf("Failed to call structure retriever: %v", err)
|
2016-05-12 08:28:18 -05:00
|
|
|
} else if res.A != "Hi" || res.B.Cmp(big.NewInt(1)) != 0 {
|
|
|
|
t.Fatalf("Retrieved value mismatch: have %v/%v, want %v/%v", res.A, res.B, "Hi", 1)
|
2016-03-25 08:09:06 -05:00
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-03-25 08:09:06 -05:00
|
|
|
},
|
2016-04-05 10:20:50 -05:00
|
|
|
// Tests that arrays/slices can be properly returned and deserialized.
|
|
|
|
// Only addresses are tested, remainder just compiled to keep the test small.
|
|
|
|
{
|
|
|
|
`Slicer`,
|
|
|
|
`
|
|
|
|
contract Slicer {
|
|
|
|
function echoAddresses(address[] input) constant returns (address[] output) {
|
|
|
|
return input;
|
|
|
|
}
|
|
|
|
function echoInts(int[] input) constant returns (int[] output) {
|
|
|
|
return input;
|
|
|
|
}
|
|
|
|
function echoFancyInts(uint24[23] input) constant returns (uint24[23] output) {
|
|
|
|
return input;
|
|
|
|
}
|
|
|
|
function echoBools(bool[] input) constant returns (bool[] output) {
|
|
|
|
return input;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`606060405261015c806100126000396000f3606060405260e060020a6000350463be1127a3811461003c578063d88becc014610092578063e15a3db71461003c578063f637e5891461003c575b005b604080516020600480358082013583810285810185019096528085526100ee959294602494909392850192829185019084908082843750949650505050505050604080516020810190915260009052805b919050565b604080516102e0818101909252610138916004916102e491839060179083908390808284375090955050505050506102e0604051908101604052806017905b60008152602001906001900390816100d15790505081905061008d565b60405180806020018281038252838181518152602001915080519060200190602002808383829060006004602084601f0104600f02600301f1509050019250505060405180910390f35b60405180826102e0808381846000600461015cf15090500191505060405180910390f3`},
|
|
|
|
[]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"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
"reflect"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
2016-04-05 10:20:50 -05:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
2016-03-02 06:57:15 -06:00
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2016-04-05 10:20:50 -05:00
|
|
|
|
|
|
|
// Deploy a slice tester contract and execute a n array call on it
|
|
|
|
_, _, slicer, err := DeploySlicer(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy slicer contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
2016-03-02 06:57:15 -06:00
|
|
|
if out, err := slicer.EchoAddresses(nil, []common.Address{auth.From, common.Address{}}); err != nil {
|
2016-04-05 10:20:50 -05:00
|
|
|
t.Fatalf("Failed to call slice echoer: %v", err)
|
2016-03-02 06:57:15 -06:00
|
|
|
} else if !reflect.DeepEqual(out, []common.Address{auth.From, common.Address{}}) {
|
|
|
|
t.Fatalf("Slice return mismatch: have %v, want %v", out, []common.Address{auth.From, common.Address{}})
|
2016-04-05 10:20:50 -05:00
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-04-05 10:20:50 -05:00
|
|
|
},
|
2016-04-01 05:02:43 -05:00
|
|
|
// Tests that anonymous default methods can be correctly invoked
|
|
|
|
{
|
|
|
|
`Defaulter`,
|
|
|
|
`
|
|
|
|
contract Defaulter {
|
|
|
|
address public caller;
|
|
|
|
|
|
|
|
function() {
|
|
|
|
caller = msg.sender;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`6060604052606a8060106000396000f360606040523615601d5760e060020a6000350463fc9c8d3981146040575b605e6000805473ffffffffffffffffffffffffffffffffffffffff191633179055565b606060005473ffffffffffffffffffffffffffffffffffffffff1681565b005b6060908152602090f3`},
|
|
|
|
[]string{`[{"constant":true,"inputs":[],"name":"caller","outputs":[{"name":"","type":"address"}],"type":"function"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
2016-04-01 05:02:43 -05:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
2016-03-02 06:57:15 -06:00
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2016-04-01 05:02:43 -05:00
|
|
|
|
|
|
|
// Deploy a default method invoker contract and execute its default method
|
|
|
|
_, _, defaulter, err := DeployDefaulter(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy defaulter contract: %v", err)
|
|
|
|
}
|
|
|
|
if _, err := (&DefaulterRaw{defaulter}).Transfer(auth); err != nil {
|
|
|
|
t.Fatalf("Failed to invoke default method: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
if caller, err := defaulter.Caller(nil); err != nil {
|
|
|
|
t.Fatalf("Failed to call address retriever: %v", err)
|
2016-03-02 06:57:15 -06:00
|
|
|
} else if (caller != auth.From) {
|
|
|
|
t.Fatalf("Address mismatch: have %v, want %v", caller, auth.From)
|
2016-04-01 05:02:43 -05:00
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-04-01 05:02:43 -05:00
|
|
|
},
|
2021-02-10 06:12:13 -06:00
|
|
|
// Tests that structs are correctly unpacked
|
|
|
|
{
|
|
|
|
|
|
|
|
`Structs`,
|
|
|
|
`
|
|
|
|
pragma solidity ^0.6.5;
|
|
|
|
pragma experimental ABIEncoderV2;
|
|
|
|
contract Structs {
|
|
|
|
struct A {
|
|
|
|
bytes32 B;
|
|
|
|
}
|
|
|
|
|
|
|
|
function F() public view returns (A[] memory a, uint256[] memory c, bool[] memory d) {
|
|
|
|
A[] memory a = new A[](2);
|
|
|
|
a[0].B = bytes32(uint256(1234) << 96);
|
|
|
|
uint256[] memory c;
|
|
|
|
bool[] memory d;
|
|
|
|
return (a, c, d);
|
|
|
|
}
|
|
|
|
|
|
|
|
function G() public view returns (A[] memory a) {
|
|
|
|
A[] memory a = new A[](2);
|
|
|
|
a[0].B = bytes32(uint256(1234) << 96);
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]string{`608060405234801561001057600080fd5b50610278806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806328811f591461003b5780636fecb6231461005b575b600080fd5b610043610070565b604051610052939291906101a0565b60405180910390f35b6100636100d6565b6040516100529190610186565b604080516002808252606082810190935282918291829190816020015b610095610131565b81526020019060019003908161008d575050805190915061026960611b9082906000906100be57fe5b60209081029190910101515293606093508392509050565b6040805160028082526060828101909352829190816020015b6100f7610131565b8152602001906001900390816100ef575050805190915061026960611b90829060009061012057fe5b602090810291909101015152905090565b60408051602081019091526000815290565b815260200190565b6000815180845260208085019450808401835b8381101561017b578151518752958201959082019060010161015e565b509495945050505050565b600060208252610199602083018461014b565b9392505050565b6000606082526101b3606083018661014b565b6020838203818501528186516101c98185610239565b91508288019350845b818110156101f3576101e5838651610143565b9484019492506001016101d2565b505084810360408601528551808252908201925081860190845b8181101561022b57825115158552938301939183019160010161020d565b509298975050505050505050565b9081526020019056fea2646970667358221220eb85327e285def14230424c52893aebecec1e387a50bb6b75fc4fdbed647f45f64736f6c63430006050033`},
|
|
|
|
[]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"}]`},
|
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
|
|
|
key, _ := crypto.GenerateKey()
|
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2021-02-10 06:12:13 -06:00
|
|
|
defer sim.Close()
|
|
|
|
|
|
|
|
// Deploy a structs method invoker contract and execute its default method
|
|
|
|
_, _, structs, err := DeployStructs(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy defaulter contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
opts := bind.CallOpts{}
|
|
|
|
if _, err := structs.F(&opts); err != nil {
|
|
|
|
t.Fatalf("Failed to invoke F method: %v", err)
|
|
|
|
}
|
|
|
|
if _, err := structs.G(&opts); err != nil {
|
|
|
|
t.Fatalf("Failed to invoke G method: %v", err)
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
},
|
2016-04-27 08:29:13 -05:00
|
|
|
// Tests that non-existent contracts are reported as such (though only simulator test)
|
|
|
|
{
|
|
|
|
`NonExistent`,
|
|
|
|
`
|
2017-01-20 16:39:16 -06:00
|
|
|
contract NonExistent {
|
|
|
|
function String() constant returns(string) {
|
|
|
|
return "I don't exist";
|
|
|
|
}
|
2016-04-27 08:29:13 -05:00
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`6060604052609f8060106000396000f3606060405260e060020a6000350463f97a60058114601a575b005b600060605260c0604052600d60809081527f4920646f6e27742065786973740000000000000000000000000000000000000060a052602060c0908152600d60e081905281906101009060a09080838184600060046012f15050815172ffffffffffffffffffffffffffffffffffffff1916909152505060405161012081900392509050f3`},
|
|
|
|
[]string{`[{"constant":true,"inputs":[],"name":"String","outputs":[{"name":"","type":"string"}],"type":"function"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2019-07-08 03:27:05 -05:00
|
|
|
"github.com/ethereum/go-ethereum/core"
|
2018-10-05 15:24:54 -05:00
|
|
|
`,
|
2016-04-27 08:29:13 -05:00
|
|
|
`
|
|
|
|
// Create a simulator and wrap a non-deployed contract
|
2019-07-31 03:35:57 -05:00
|
|
|
|
all: on-chain oracle checkpoint syncing (#19543)
* all: implement simple checkpoint syncing
cmd, les, node: remove callback mechanism
cmd, node: remove callback definition
les: simplify the registrar
les: expose checkpoint rpc services in the light client
les, light: don't store untrusted receipt
cmd, contracts, les: discard stale checkpoint
cmd, contracts/registrar: loose restriction of registeration
cmd, contracts: add replay-protection
all: off-chain multi-signature contract
params: deploy checkpoint contract for rinkeby
cmd/registrar: add raw signing mode for registrar
cmd/registrar, contracts/registrar, les: fixed messages
* cmd/registrar, contracts/registrar: fix lints
* accounts/abi/bind, les: address comments
* cmd, contracts, les, light, params: minor checkpoint sync cleanups
* cmd, eth, les, light: move checkpoint config to config file
* cmd, eth, les, params: address comments
* eth, les, params: address comments
* cmd: polish up the checkpoint admin CLI
* cmd, contracts, params: deploy new version contract
* cmd/checkpoint-admin: add another flag for clef mode signing
* cmd, contracts, les: rename and regen checkpoint oracle with abigen
2019-06-28 02:34:02 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{}, uint64(10000000000))
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2016-04-27 08:29:13 -05:00
|
|
|
|
|
|
|
nonexistent, err := NewNonExistent(common.Address{}, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to access non-existent contract: %v", err)
|
|
|
|
}
|
|
|
|
// Ensure that contract calls fail with the appropriate error
|
|
|
|
if res, err := nonexistent.String(nil); err == nil {
|
|
|
|
t.Fatalf("Call succeeded on non-existent contract: %v", res)
|
|
|
|
} else if (err != bind.ErrNoCode) {
|
|
|
|
t.Fatalf("Error mismatch: have %v, want %v", err, bind.ErrNoCode)
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2016-04-27 08:29:13 -05:00
|
|
|
},
|
2020-12-12 03:16:34 -06:00
|
|
|
{
|
|
|
|
`NonExistentStruct`,
|
|
|
|
`
|
|
|
|
contract NonExistentStruct {
|
|
|
|
function Struct() public view returns(uint256 a, uint256 b) {
|
|
|
|
return (10, 10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]string{`6080604052348015600f57600080fd5b5060888061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063d5f6622514602d575b600080fd5b6033604c565b6040805192835260208301919091528051918290030190f35b600a809156fea264697066735822beefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeefbeef64736f6c6343decafe0033`},
|
|
|
|
[]string{`[{"inputs":[],"name":"Struct","outputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"stateMutability":"pure","type":"function"}]`},
|
|
|
|
`
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
// Create a simulator and wrap a non-deployed contract
|
|
|
|
|
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{}, uint64(10000000000))
|
|
|
|
defer sim.Close()
|
|
|
|
|
|
|
|
nonexistent, err := NewNonExistentStruct(common.Address{}, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to access non-existent contract: %v", err)
|
|
|
|
}
|
|
|
|
// Ensure that contract calls fail with the appropriate error
|
|
|
|
if res, err := nonexistent.Struct(nil); err == nil {
|
|
|
|
t.Fatalf("Call succeeded on non-existent contract: %v", res)
|
|
|
|
} else if (err != bind.ErrNoCode) {
|
|
|
|
t.Fatalf("Error mismatch: have %v, want %v", err, bind.ErrNoCode)
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
},
|
2018-03-07 06:34:53 -06:00
|
|
|
// Tests that gas estimation works for contracts with weird gas mechanics too.
|
2017-01-20 16:39:16 -06:00
|
|
|
{
|
|
|
|
`FunkyGasPattern`,
|
|
|
|
`
|
|
|
|
contract FunkyGasPattern {
|
|
|
|
string public field;
|
|
|
|
|
|
|
|
function SetField(string value) {
|
|
|
|
// This check will screw gas estimation! Good, good!
|
|
|
|
if (msg.gas < 100000) {
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
field = value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`606060405261021c806100126000396000f3606060405260e060020a600035046323fcf32a81146100265780634f28bf0e1461007b575b005b6040805160206004803580820135601f8101849004840285018401909552848452610024949193602493909291840191908190840183828082843750949650505050505050620186a05a101561014e57610002565b6100db60008054604080516020601f600260001961010060018816150201909516949094049384018190048102820181019092528281529291908301828280156102145780601f106101e957610100808354040283529160200191610214565b60405180806020018281038252838181518152602001915080519060200190808383829060006004602084601f0104600302600f01f150905090810190601f16801561013b5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b505050565b8060006000509080519060200190828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106101b557805160ff19168380011785555b506101499291505b808211156101e557600081556001016101a1565b82800160010185558215610199579182015b828111156101995782518260005055916020019190600101906101c7565b5090565b820191906000526020600020905b8154815290600101906020018083116101f757829003601f168201915b50505050508156`},
|
|
|
|
[]string{`[{"constant":false,"inputs":[{"name":"value","type":"string"}],"name":"SetField","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"field","outputs":[{"name":"","type":"string"}],"type":"function"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
2017-01-20 16:39:16 -06:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2017-01-20 16:39:16 -06:00
|
|
|
|
|
|
|
// Deploy a funky gas pattern contract
|
|
|
|
_, _, limiter, err := DeployFunkyGasPattern(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy funky contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
// Set the field with automatic estimation and check that it succeeds
|
|
|
|
if _, err := limiter.SetField(auth, "automatic"); err != nil {
|
|
|
|
t.Fatalf("Failed to call automatically gased transaction: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
if field, _ := limiter.Field(nil); field != "automatic" {
|
|
|
|
t.Fatalf("Field mismatch: have %v, want %v", field, "automatic")
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2017-01-20 16:39:16 -06:00
|
|
|
},
|
2017-03-16 06:24:22 -05:00
|
|
|
// Test that constant functions can be called from an (optional) specified address
|
|
|
|
{
|
|
|
|
`CallFrom`,
|
|
|
|
`
|
|
|
|
contract CallFrom {
|
|
|
|
function callFrom() constant returns(address) {
|
|
|
|
return msg.sender;
|
|
|
|
}
|
|
|
|
}
|
2019-07-08 03:27:05 -05:00
|
|
|
`, []string{`6060604052346000575b6086806100176000396000f300606060405263ffffffff60e060020a60003504166349f8e98281146022575b6000565b34600057602c6055565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b335b905600a165627a7a72305820aef6b7685c0fa24ba6027e4870404a57df701473fe4107741805c19f5138417c0029`},
|
|
|
|
[]string{`[{"constant":true,"inputs":[],"name":"callFrom","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
2017-03-16 06:24:22 -05:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2017-03-16 06:24:22 -05:00
|
|
|
|
|
|
|
// Deploy a sender tester contract and execute a structured call on it
|
|
|
|
_, _, callfrom, err := DeployCallFrom(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy sender contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
if res, err := callfrom.CallFrom(nil); err != nil {
|
|
|
|
t.Errorf("Failed to call constant function: %v", err)
|
|
|
|
} else if res != (common.Address{}) {
|
|
|
|
t.Errorf("Invalid address returned, want: %x, got: %x", (common.Address{}), res)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, addr := range []common.Address{common.Address{}, common.Address{1}, common.Address{2}} {
|
|
|
|
if res, err := callfrom.CallFrom(&bind.CallOpts{From: addr}); err != nil {
|
|
|
|
t.Fatalf("Failed to call constant function: %v", err)
|
|
|
|
} else if res != addr {
|
|
|
|
t.Fatalf("Invalid address returned, want: %x, got: %x", addr, res)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2017-03-16 06:24:22 -05:00
|
|
|
},
|
2018-03-07 06:34:53 -06:00
|
|
|
// Tests that methods and returns with underscores inside work correctly.
|
2017-12-29 15:20:02 -06:00
|
|
|
{
|
|
|
|
`Underscorer`,
|
|
|
|
`
|
|
|
|
contract Underscorer {
|
|
|
|
function UnderscoredOutput() constant returns (int _int, string _string) {
|
|
|
|
return (314, "pi");
|
|
|
|
}
|
|
|
|
function LowerLowerCollision() constant returns (int _res, int res) {
|
|
|
|
return (1, 2);
|
|
|
|
}
|
|
|
|
function LowerUpperCollision() constant returns (int _res, int Res) {
|
|
|
|
return (1, 2);
|
2018-03-07 06:34:53 -06:00
|
|
|
}
|
2017-12-29 15:20:02 -06:00
|
|
|
function UpperLowerCollision() constant returns (int _Res, int res) {
|
|
|
|
return (1, 2);
|
|
|
|
}
|
|
|
|
function UpperUpperCollision() constant returns (int _Res, int Res) {
|
|
|
|
return (1, 2);
|
|
|
|
}
|
|
|
|
function PurelyUnderscoredOutput() constant returns (int _, int res) {
|
|
|
|
return (1, 2);
|
|
|
|
}
|
|
|
|
function AllPurelyUnderscoredOutput() constant returns (int _, int __) {
|
|
|
|
return (1, 2);
|
|
|
|
}
|
2018-03-07 06:34:53 -06:00
|
|
|
function _under_scored_func() constant returns (int _int) {
|
|
|
|
return 0;
|
|
|
|
}
|
2017-12-29 15:20:02 -06:00
|
|
|
}
|
2019-07-08 03:27:05 -05:00
|
|
|
`, []string{`6060604052341561000f57600080fd5b6103858061001e6000396000f30060606040526004361061008e576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806303a592131461009357806346546dbe146100c357806367e6633d146100ec5780639df4848514610181578063af7486ab146101b1578063b564b34d146101e1578063e02ab24d14610211578063e409ca4514610241575b600080fd5b341561009e57600080fd5b6100a6610271565b604051808381526020018281526020019250505060405180910390f35b34156100ce57600080fd5b6100d6610286565b6040518082815260200191505060405180910390f35b34156100f757600080fd5b6100ff61028e565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561014557808201518184015260208101905061012a565b50505050905090810190601f1680156101725780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561018c57600080fd5b6101946102dc565b604051808381526020018281526020019250505060405180910390f35b34156101bc57600080fd5b6101c46102f1565b604051808381526020018281526020019250505060405180910390f35b34156101ec57600080fd5b6101f4610306565b604051808381526020018281526020019250505060405180910390f35b341561021c57600080fd5b61022461031b565b604051808381526020018281526020019250505060405180910390f35b341561024c57600080fd5b610254610330565b604051808381526020018281526020019250505060405180910390f35b60008060016002819150809050915091509091565b600080905090565b6000610298610345565b61013a8090506040805190810160405280600281526020017f7069000000000000000000000000000000000000000000000000000000000000815250915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b6020604051908101604052806000815250905600a165627a7a72305820d1a53d9de9d1e3d55cb3dc591900b63c4f1ded79114f7b79b332684840e186a40029`},
|
|
|
|
[]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"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"fmt"
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
2017-12-29 15:20:02 -06:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2017-12-29 15:20:02 -06:00
|
|
|
|
|
|
|
// Deploy a underscorer tester contract and execute a structured call on it
|
|
|
|
_, _, underscorer, err := DeployUnderscorer(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy underscorer contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
// Verify that underscored return values correctly parse into structs
|
|
|
|
if res, err := underscorer.UnderscoredOutput(nil); err != nil {
|
|
|
|
t.Errorf("Failed to call constant function: %v", err)
|
|
|
|
} else if res.Int.Cmp(big.NewInt(314)) != 0 || res.String != "pi" {
|
|
|
|
t.Errorf("Invalid result, want: {314, \"pi\"}, got: %+v", res)
|
|
|
|
}
|
|
|
|
// Verify that underscored and non-underscored name collisions force tuple outputs
|
|
|
|
var a, b *big.Int
|
|
|
|
|
|
|
|
a, b, _ = underscorer.LowerLowerCollision(nil)
|
|
|
|
a, b, _ = underscorer.LowerUpperCollision(nil)
|
|
|
|
a, b, _ = underscorer.UpperLowerCollision(nil)
|
|
|
|
a, b, _ = underscorer.UpperUpperCollision(nil)
|
|
|
|
a, b, _ = underscorer.PurelyUnderscoredOutput(nil)
|
|
|
|
a, b, _ = underscorer.AllPurelyUnderscoredOutput(nil)
|
2018-03-07 06:34:53 -06:00
|
|
|
a, _ = underscorer.UnderScoredFunc(nil)
|
2017-12-29 15:20:02 -06:00
|
|
|
|
|
|
|
fmt.Println(a, b, err)
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2017-12-29 15:20:02 -06:00
|
|
|
},
|
2018-01-05 04:39:24 -06:00
|
|
|
// Tests that logs can be successfully filtered and decoded.
|
|
|
|
{
|
|
|
|
`Eventer`,
|
|
|
|
`
|
|
|
|
contract Eventer {
|
2019-03-14 05:47:22 -05:00
|
|
|
event SimpleEvent (
|
2018-01-05 04:39:24 -06:00
|
|
|
address indexed Addr,
|
|
|
|
bytes32 indexed Id,
|
|
|
|
bool indexed Flag,
|
|
|
|
uint Value
|
|
|
|
);
|
|
|
|
function raiseSimpleEvent(address addr, bytes32 id, bool flag, uint value) {
|
|
|
|
SimpleEvent(addr, id, flag, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
event NodataEvent (
|
|
|
|
uint indexed Number,
|
|
|
|
int16 indexed Short,
|
|
|
|
uint32 indexed Long
|
|
|
|
);
|
|
|
|
function raiseNodataEvent(uint number, int16 short, uint32 long) {
|
|
|
|
NodataEvent(number, short, long);
|
|
|
|
}
|
|
|
|
|
|
|
|
event DynamicEvent (
|
|
|
|
string indexed IndexedString,
|
|
|
|
bytes indexed IndexedBytes,
|
|
|
|
string NonIndexedString,
|
|
|
|
bytes NonIndexedBytes
|
|
|
|
);
|
|
|
|
function raiseDynamicEvent(string str, bytes blob) {
|
|
|
|
DynamicEvent(str, blob, str, blob);
|
|
|
|
}
|
2019-03-14 05:47:22 -05:00
|
|
|
|
|
|
|
event FixedBytesEvent (
|
|
|
|
bytes24 indexed IndexedBytes,
|
|
|
|
bytes24 NonIndexedBytes
|
|
|
|
);
|
|
|
|
function raiseFixedBytesEvent(bytes24 blob) {
|
|
|
|
FixedBytesEvent(blob, blob);
|
|
|
|
}
|
2018-01-05 04:39:24 -06:00
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`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`},
|
|
|
|
[]string{`[{"constant":false,"inputs":[{"name":"str","type":"string"},{"name":"blob","type":"bytes"}],"name":"raiseDynamicEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"},{"name":"id","type":"bytes32"},{"name":"flag","type":"bool"},{"name":"value","type":"uint256"}],"name":"raiseSimpleEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"blob","type":"bytes24"}],"name":"raiseFixedBytesEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"number","type":"uint256"},{"name":"short","type":"int16"},{"name":"long","type":"uint32"}],"name":"raiseNodataEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"anonymous":false,"inputs":[{"indexed":true,"name":"Addr","type":"address"},{"indexed":true,"name":"Id","type":"bytes32"},{"indexed":true,"name":"Flag","type":"bool"},{"indexed":false,"name":"Value","type":"uint256"}],"name":"SimpleEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"Number","type":"uint256"},{"indexed":true,"name":"Short","type":"int16"},{"indexed":true,"name":"Long","type":"uint32"}],"name":"NodataEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"IndexedString","type":"string"},{"indexed":true,"name":"IndexedBytes","type":"bytes"},{"indexed":false,"name":"NonIndexedString","type":"string"},{"indexed":false,"name":"NonIndexedBytes","type":"bytes"}],"name":"DynamicEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"IndexedBytes","type":"bytes24"},{"indexed":false,"name":"NonIndexedBytes","type":"bytes24"}],"name":"FixedBytesEvent","type":"event"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
2018-01-05 04:39:24 -06:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2018-01-05 04:39:24 -06:00
|
|
|
|
|
|
|
// Deploy an eventer contract
|
|
|
|
_, _, eventer, err := DeployEventer(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy eventer contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
// Inject a few events into the contract, gradually more in each block
|
|
|
|
for i := 1; i <= 3; i++ {
|
|
|
|
for j := 1; j <= i; j++ {
|
|
|
|
if _, err := eventer.RaiseSimpleEvent(auth, common.Address{byte(j)}, [32]byte{byte(j)}, true, big.NewInt(int64(10*i+j))); err != nil {
|
|
|
|
t.Fatalf("block %d, event %d: raise failed: %v", i, j, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
}
|
|
|
|
// Test filtering for certain events and ensure they can be found
|
|
|
|
sit, err := eventer.FilterSimpleEvent(nil, []common.Address{common.Address{1}, common.Address{3}}, [][32]byte{{byte(1)}, {byte(2)}, {byte(3)}}, []bool{true})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to filter for simple events: %v", err)
|
|
|
|
}
|
|
|
|
defer sit.Close()
|
|
|
|
|
|
|
|
sit.Next()
|
|
|
|
if sit.Event.Value.Uint64() != 11 || !sit.Event.Flag {
|
|
|
|
t.Errorf("simple log content mismatch: have %v, want {11, true}", sit.Event)
|
|
|
|
}
|
|
|
|
sit.Next()
|
|
|
|
if sit.Event.Value.Uint64() != 21 || !sit.Event.Flag {
|
|
|
|
t.Errorf("simple log content mismatch: have %v, want {21, true}", sit.Event)
|
|
|
|
}
|
|
|
|
sit.Next()
|
|
|
|
if sit.Event.Value.Uint64() != 31 || !sit.Event.Flag {
|
|
|
|
t.Errorf("simple log content mismatch: have %v, want {31, true}", sit.Event)
|
|
|
|
}
|
|
|
|
sit.Next()
|
|
|
|
if sit.Event.Value.Uint64() != 33 || !sit.Event.Flag {
|
|
|
|
t.Errorf("simple log content mismatch: have %v, want {33, true}", sit.Event)
|
|
|
|
}
|
|
|
|
|
|
|
|
if sit.Next() {
|
|
|
|
t.Errorf("unexpected simple event found: %+v", sit.Event)
|
|
|
|
}
|
|
|
|
if err = sit.Error(); err != nil {
|
|
|
|
t.Fatalf("simple event iteration failed: %v", err)
|
|
|
|
}
|
|
|
|
// Test raising and filtering for an event with no data component
|
|
|
|
if _, err := eventer.RaiseNodataEvent(auth, big.NewInt(314), 141, 271); err != nil {
|
|
|
|
t.Fatalf("failed to raise nodata event: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
nit, err := eventer.FilterNodataEvent(nil, []*big.Int{big.NewInt(314)}, []int16{140, 141, 142}, []uint32{271})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to filter for nodata events: %v", err)
|
|
|
|
}
|
|
|
|
defer nit.Close()
|
|
|
|
|
|
|
|
if !nit.Next() {
|
|
|
|
t.Fatalf("nodata log not found: %v", nit.Error())
|
|
|
|
}
|
|
|
|
if nit.Event.Number.Uint64() != 314 {
|
|
|
|
t.Errorf("nodata log content mismatch: have %v, want 314", nit.Event.Number)
|
|
|
|
}
|
|
|
|
if nit.Next() {
|
|
|
|
t.Errorf("unexpected nodata event found: %+v", nit.Event)
|
|
|
|
}
|
|
|
|
if err = nit.Error(); err != nil {
|
|
|
|
t.Fatalf("nodata event iteration failed: %v", err)
|
|
|
|
}
|
|
|
|
// Test raising and filtering for events with dynamic indexed components
|
|
|
|
if _, err := eventer.RaiseDynamicEvent(auth, "Hello", []byte("World")); err != nil {
|
|
|
|
t.Fatalf("failed to raise dynamic event: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
dit, err := eventer.FilterDynamicEvent(nil, []string{"Hi", "Hello", "Bye"}, [][]byte{[]byte("World")})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to filter for dynamic events: %v", err)
|
|
|
|
}
|
|
|
|
defer dit.Close()
|
|
|
|
|
|
|
|
if !dit.Next() {
|
|
|
|
t.Fatalf("dynamic log not found: %v", dit.Error())
|
|
|
|
}
|
|
|
|
if dit.Event.NonIndexedString != "Hello" || string(dit.Event.NonIndexedBytes) != "World" || dit.Event.IndexedString != common.HexToHash("0x06b3dfaec148fb1bb2b066f10ec285e7c9bf402ab32aa78a5d38e34566810cd2") || dit.Event.IndexedBytes != common.HexToHash("0xf2208c967df089f60420785795c0a9ba8896b0f6f1867fa7f1f12ad6f79c1a18") {
|
|
|
|
t.Errorf("dynamic log content mismatch: have %v, want {'0x06b3dfaec148fb1bb2b066f10ec285e7c9bf402ab32aa78a5d38e34566810cd2, '0xf2208c967df089f60420785795c0a9ba8896b0f6f1867fa7f1f12ad6f79c1a18', 'Hello', 'World'}", dit.Event)
|
|
|
|
}
|
|
|
|
if dit.Next() {
|
|
|
|
t.Errorf("unexpected dynamic event found: %+v", dit.Event)
|
|
|
|
}
|
|
|
|
if err = dit.Error(); err != nil {
|
|
|
|
t.Fatalf("dynamic event iteration failed: %v", err)
|
|
|
|
}
|
2019-03-14 05:47:22 -05:00
|
|
|
// Test raising and filtering for events with fixed bytes components
|
|
|
|
var fblob [24]byte
|
|
|
|
copy(fblob[:], []byte("Fixed Bytes"))
|
|
|
|
|
|
|
|
if _, err := eventer.RaiseFixedBytesEvent(auth, fblob); err != nil {
|
|
|
|
t.Fatalf("failed to raise fixed bytes event: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
fit, err := eventer.FilterFixedBytesEvent(nil, [][24]byte{fblob})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to filter for fixed bytes events: %v", err)
|
|
|
|
}
|
|
|
|
defer fit.Close()
|
|
|
|
|
|
|
|
if !fit.Next() {
|
|
|
|
t.Fatalf("fixed bytes log not found: %v", fit.Error())
|
|
|
|
}
|
|
|
|
if fit.Event.NonIndexedBytes != fblob || fit.Event.IndexedBytes != fblob {
|
|
|
|
t.Errorf("fixed bytes log content mismatch: have %v, want {'%x', '%x'}", fit.Event, fblob, fblob)
|
|
|
|
}
|
|
|
|
if fit.Next() {
|
|
|
|
t.Errorf("unexpected fixed bytes event found: %+v", fit.Event)
|
|
|
|
}
|
|
|
|
if err = fit.Error(); err != nil {
|
|
|
|
t.Fatalf("fixed bytes event iteration failed: %v", err)
|
|
|
|
}
|
2018-01-05 04:39:24 -06:00
|
|
|
// Test subscribing to an event and raising it afterwards
|
|
|
|
ch := make(chan *EventerSimpleEvent, 16)
|
|
|
|
sub, err := eventer.WatchSimpleEvent(nil, ch, nil, nil, nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to subscribe to simple events: %v", err)
|
|
|
|
}
|
|
|
|
if _, err := eventer.RaiseSimpleEvent(auth, common.Address{255}, [32]byte{255}, true, big.NewInt(255)); err != nil {
|
|
|
|
t.Fatalf("failed to raise subscribed simple event: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case event := <-ch:
|
|
|
|
if event.Value.Uint64() != 255 {
|
|
|
|
t.Errorf("simple log content mismatch: have %v, want 255", event)
|
|
|
|
}
|
|
|
|
case <-time.After(250 * time.Millisecond):
|
|
|
|
t.Fatalf("subscribed simple event didn't arrive")
|
|
|
|
}
|
|
|
|
// Unsubscribe from the event and make sure we're not delivered more
|
|
|
|
sub.Unsubscribe()
|
|
|
|
|
|
|
|
if _, err := eventer.RaiseSimpleEvent(auth, common.Address{254}, [32]byte{254}, true, big.NewInt(254)); err != nil {
|
|
|
|
t.Fatalf("failed to raise subscribed simple event: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case event := <-ch:
|
|
|
|
t.Fatalf("unsubscribed simple event arrived: %v", event)
|
|
|
|
case <-time.After(250 * time.Millisecond):
|
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2018-01-05 04:39:24 -06:00
|
|
|
},
|
accounts/abi: Abi binding support for nested arrays, fixes #15648, including nested array unpack fix (#15676)
* accounts/abi/bind: support for multi-dim arrays
Also:
- reduce usage of regexes a bit.
- fix minor Java syntax problems
Fixes #15648
* accounts/abi/bind: Add some more documentation
* accounts/abi/bind: Improve code readability
* accounts/abi: bugfix for unpacking nested arrays
The code previously assumed the arrays/slices were always 1 level
deep. While the packing supports nested arrays (!!!).
The current code for unpacking doesn't return the "consumed" length, so
this fix had to work around that by calculating it (i.e. packing and
getting resulting length) after the unpacking of the array element.
It's far from ideal, but unpacking behaviour is fixed now.
* accounts/abi: Fix unpacking of nested arrays
Removed the temporary workaround of packing to calculate size, which was
incorrect for slice-like types anyway.
Full size of nested arrays is used now.
* accounts/abi: deeply nested array unpack test
Test unpacking of an array nested more than one level.
* accounts/abi: Add deeply nested array pack test
Same as the deep nested array unpack test, but the other way around.
* accounts/abi/bind: deeply nested arrays bind test
Test the usage of bindings that were generated
for methods with multi-dimensional (and not
just a single extra dimension, like foo[2][3])
array arguments and returns.
edit: trigger rebuild, CI failed to fetch linter module.
* accounts/abi/bind: improve array binding
wrapArray uses a regex now, and arrayBindingJava is improved.
* accounts/abi: Improve naming of element size func
The full step size for unpacking an array
is now retrieved with "getFullElemSize".
* accounts/abi: support nested nested array args
Previously, the code only considered the outer-size of the array,
ignoring the size of the contents. This was fine for most types,
but nested arrays are packed directly into it, and count towards
the total size. This resulted in arguments following a nested
array to replicate some of the binary contents of the array.
The fix: for arrays, calculate their complete contents size:
count the arg.Type.Elem.Size when Elem is an Array, and
repeat when their child is an array too, etc.
The count is the number of 32 byte elements, similar to how it
previously counted, but nested.
* accounts/abi: Test deep nested arr multi-arguments
Arguments with a deeply nested array should not cause the next arguments
to be read from the wrong position.
2018-03-04 16:24:17 -06:00
|
|
|
{
|
|
|
|
`DeeplyNestedArray`,
|
|
|
|
`
|
|
|
|
contract DeeplyNestedArray {
|
|
|
|
uint64[3][4][5] public deepUint64Array;
|
|
|
|
function storeDeepUintArray(uint64[3][4][5] arr) public {
|
|
|
|
deepUint64Array = arr;
|
|
|
|
}
|
|
|
|
function retrieveDeepArray() public view returns (uint64[3][4][5]) {
|
|
|
|
return deepUint64Array;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`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`},
|
|
|
|
[]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"}]`},
|
2018-10-05 15:24:54 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
accounts/abi: Abi binding support for nested arrays, fixes #15648, including nested array unpack fix (#15676)
* accounts/abi/bind: support for multi-dim arrays
Also:
- reduce usage of regexes a bit.
- fix minor Java syntax problems
Fixes #15648
* accounts/abi/bind: Add some more documentation
* accounts/abi/bind: Improve code readability
* accounts/abi: bugfix for unpacking nested arrays
The code previously assumed the arrays/slices were always 1 level
deep. While the packing supports nested arrays (!!!).
The current code for unpacking doesn't return the "consumed" length, so
this fix had to work around that by calculating it (i.e. packing and
getting resulting length) after the unpacking of the array element.
It's far from ideal, but unpacking behaviour is fixed now.
* accounts/abi: Fix unpacking of nested arrays
Removed the temporary workaround of packing to calculate size, which was
incorrect for slice-like types anyway.
Full size of nested arrays is used now.
* accounts/abi: deeply nested array unpack test
Test unpacking of an array nested more than one level.
* accounts/abi: Add deeply nested array pack test
Same as the deep nested array unpack test, but the other way around.
* accounts/abi/bind: deeply nested arrays bind test
Test the usage of bindings that were generated
for methods with multi-dimensional (and not
just a single extra dimension, like foo[2][3])
array arguments and returns.
edit: trigger rebuild, CI failed to fetch linter module.
* accounts/abi/bind: improve array binding
wrapArray uses a regex now, and arrayBindingJava is improved.
* accounts/abi: Improve naming of element size func
The full step size for unpacking an array
is now retrieved with "getFullElemSize".
* accounts/abi: support nested nested array args
Previously, the code only considered the outer-size of the array,
ignoring the size of the contents. This was fine for most types,
but nested arrays are packed directly into it, and count towards
the total size. This resulted in arguments following a nested
array to replicate some of the binary contents of the array.
The fix: for arrays, calculate their complete contents size:
count the arg.Type.Elem.Size when Elem is an Array, and
repeat when their child is an array too, etc.
The count is the number of 32 byte elements, similar to how it
previously counted, but nested.
* accounts/abi: Test deep nested arr multi-arguments
Arguments with a deeply nested array should not cause the next arguments
to be read from the wrong position.
2018-03-04 16:24:17 -06:00
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
accounts/abi: Abi binding support for nested arrays, fixes #15648, including nested array unpack fix (#15676)
* accounts/abi/bind: support for multi-dim arrays
Also:
- reduce usage of regexes a bit.
- fix minor Java syntax problems
Fixes #15648
* accounts/abi/bind: Add some more documentation
* accounts/abi/bind: Improve code readability
* accounts/abi: bugfix for unpacking nested arrays
The code previously assumed the arrays/slices were always 1 level
deep. While the packing supports nested arrays (!!!).
The current code for unpacking doesn't return the "consumed" length, so
this fix had to work around that by calculating it (i.e. packing and
getting resulting length) after the unpacking of the array element.
It's far from ideal, but unpacking behaviour is fixed now.
* accounts/abi: Fix unpacking of nested arrays
Removed the temporary workaround of packing to calculate size, which was
incorrect for slice-like types anyway.
Full size of nested arrays is used now.
* accounts/abi: deeply nested array unpack test
Test unpacking of an array nested more than one level.
* accounts/abi: Add deeply nested array pack test
Same as the deep nested array unpack test, but the other way around.
* accounts/abi/bind: deeply nested arrays bind test
Test the usage of bindings that were generated
for methods with multi-dimensional (and not
just a single extra dimension, like foo[2][3])
array arguments and returns.
edit: trigger rebuild, CI failed to fetch linter module.
* accounts/abi/bind: improve array binding
wrapArray uses a regex now, and arrayBindingJava is improved.
* accounts/abi: Improve naming of element size func
The full step size for unpacking an array
is now retrieved with "getFullElemSize".
* accounts/abi: support nested nested array args
Previously, the code only considered the outer-size of the array,
ignoring the size of the contents. This was fine for most types,
but nested arrays are packed directly into it, and count towards
the total size. This resulted in arguments following a nested
array to replicate some of the binary contents of the array.
The fix: for arrays, calculate their complete contents size:
count the arg.Type.Elem.Size when Elem is an Array, and
repeat when their child is an array too, etc.
The count is the number of 32 byte elements, similar to how it
previously counted, but nested.
* accounts/abi: Test deep nested arr multi-arguments
Arguments with a deeply nested array should not cause the next arguments
to be read from the wrong position.
2018-03-04 16:24:17 -06:00
|
|
|
|
|
|
|
//deploy the test contract
|
|
|
|
_, _, testContract, err := DeployDeeplyNestedArray(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy test contract: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finish deploy.
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
//Create coordinate-filled array, for testing purposes.
|
|
|
|
testArr := [5][4][3]uint64{}
|
|
|
|
for i := 0; i < 5; i++ {
|
|
|
|
testArr[i] = [4][3]uint64{}
|
|
|
|
for j := 0; j < 4; j++ {
|
|
|
|
testArr[i][j] = [3]uint64{}
|
|
|
|
for k := 0; k < 3; k++ {
|
|
|
|
//pack the coordinates, each array value will be unique, and can be validated easily.
|
|
|
|
testArr[i][j][k] = uint64(i) << 16 | uint64(j) << 8 | uint64(k)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err := testContract.StoreDeepUintArray(&bind.TransactOpts{
|
|
|
|
From: auth.From,
|
|
|
|
Signer: auth.Signer,
|
|
|
|
}, testArr); err != nil {
|
|
|
|
t.Fatalf("Failed to store nested array in test contract: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
retrievedArr, err := testContract.RetrieveDeepArray(&bind.CallOpts{
|
|
|
|
From: auth.From,
|
|
|
|
Pending: false,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to retrieve nested array from test contract: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
//quick check to see if contents were copied
|
|
|
|
// (See accounts/abi/unpack_test.go for more extensive testing)
|
|
|
|
if retrievedArr[4][3][2] != testArr[4][3][2] {
|
|
|
|
t.Fatalf("Retrieved value does not match expected value! got: %d, expected: %d. %v", retrievedArr[4][3][2], testArr[4][3][2], err)
|
2018-03-07 06:34:53 -06:00
|
|
|
}
|
|
|
|
`,
|
2019-07-02 02:52:58 -05:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2019-07-02 02:52:58 -05:00
|
|
|
},
|
|
|
|
{
|
|
|
|
`CallbackParam`,
|
|
|
|
`
|
|
|
|
contract FunctionPointerTest {
|
|
|
|
function test(function(uint256) external callback) external {
|
|
|
|
callback(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`608060405234801561001057600080fd5b5061015e806100206000396000f3fe60806040526004361061003b576000357c010000000000000000000000000000000000000000000000000000000090048063d7a5aba214610040575b600080fd5b34801561004c57600080fd5b506100be6004803603602081101561006357600080fd5b810190808035806c0100000000000000000000000090049068010000000000000000900463ffffffff1677ffffffffffffffffffffffffffffffffffffffffffffffff169091602001919093929190939291905050506100c0565b005b818160016040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15801561011657600080fd5b505af115801561012a573d6000803e3d6000fd5b50505050505056fea165627a7a7230582062f87455ff84be90896dbb0c4e4ddb505c600d23089f8e80a512548440d7e2580029`},
|
|
|
|
[]string{`[
|
2019-07-02 02:52:58 -05:00
|
|
|
{
|
|
|
|
"constant": false,
|
|
|
|
"inputs": [
|
|
|
|
{
|
|
|
|
"name": "callback",
|
|
|
|
"type": "function"
|
|
|
|
}
|
|
|
|
],
|
|
|
|
"name": "test",
|
|
|
|
"outputs": [],
|
|
|
|
"payable": false,
|
|
|
|
"stateMutability": "nonpayable",
|
|
|
|
"type": "function"
|
|
|
|
}
|
2019-07-08 03:27:05 -05:00
|
|
|
]`}, `
|
2019-07-02 02:52:58 -05:00
|
|
|
"strings"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
if strings.Compare("test(function)", CallbackParamFuncSigs["d7a5aba2"]) != 0 {
|
|
|
|
t.Fatalf("")
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]map[string]string{
|
|
|
|
{
|
|
|
|
"test(function)": "d7a5aba2",
|
|
|
|
},
|
|
|
|
},
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2019-07-03 05:17:43 -05:00
|
|
|
}, {
|
|
|
|
`Tuple`,
|
|
|
|
`
|
|
|
|
pragma solidity >=0.4.19 <0.6.0;
|
|
|
|
pragma experimental ABIEncoderV2;
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2019-07-03 05:17:43 -05:00
|
|
|
contract Tuple {
|
|
|
|
struct S { uint a; uint[] b; T[] c; }
|
|
|
|
struct T { uint x; uint y; }
|
2019-10-31 08:17:51 -05:00
|
|
|
struct P { uint8 x; uint8 y; }
|
|
|
|
struct Q { uint16 x; uint16 y; }
|
2019-07-03 05:17:43 -05:00
|
|
|
event TupleEvent(S a, T[2][] b, T[][2] c, S[] d, uint[] e);
|
2019-10-31 08:17:51 -05:00
|
|
|
event TupleEvent2(P[]);
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2019-07-03 05:17:43 -05:00
|
|
|
function func1(S memory a, T[2][] memory b, T[][2] memory c, S[] memory d, uint[] memory e) public pure returns (S memory, T[2][] memory, T[][2] memory, S[] memory, uint[] memory) {
|
|
|
|
return (a, b, c, d, e);
|
|
|
|
}
|
|
|
|
function func2(S memory a, T[2][] memory b, T[][2] memory c, S[] memory d, uint[] memory e) public {
|
|
|
|
emit TupleEvent(a, b, c, d, e);
|
|
|
|
}
|
2019-10-31 08:17:51 -05:00
|
|
|
function func3(Q[] memory) public pure {} // call function, nothing to return
|
2019-07-03 05:17:43 -05:00
|
|
|
}
|
|
|
|
`,
|
2019-10-31 08:17:51 -05:00
|
|
|
[]string{`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
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{`
|
2019-10-31 08:17:51 -05:00
|
|
|
[{"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
|
2019-07-08 03:27:05 -05:00
|
|
|
`},
|
2019-07-03 05:17:43 -05:00
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
"reflect"
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2019-07-03 05:17:43 -05:00
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
|
|
|
|
|
|
|
`
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-03 05:17:43 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
|
|
|
|
|
|
|
_, _, contract, err := DeployTuple(auth, sim)
|
2019-07-03 05:17:43 -05:00
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("deploy contract failed %v", err)
|
|
|
|
}
|
2019-07-31 03:35:57 -05:00
|
|
|
sim.Commit()
|
2019-07-03 05:17:43 -05:00
|
|
|
|
|
|
|
check := func(a, b interface{}, errMsg string) {
|
|
|
|
if !reflect.DeepEqual(a, b) {
|
|
|
|
t.Fatal(errMsg)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-31 08:17:51 -05:00
|
|
|
a := TupleS{
|
2019-07-03 05:17:43 -05:00
|
|
|
A: big.NewInt(1),
|
|
|
|
B: []*big.Int{big.NewInt(2), big.NewInt(3)},
|
2019-10-31 08:17:51 -05:00
|
|
|
C: []TupleT{
|
2019-07-03 05:17:43 -05:00
|
|
|
{
|
|
|
|
X: big.NewInt(4),
|
|
|
|
Y: big.NewInt(5),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
X: big.NewInt(6),
|
|
|
|
Y: big.NewInt(7),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2019-10-31 08:17:51 -05:00
|
|
|
b := [][2]TupleT{
|
2019-07-03 05:17:43 -05:00
|
|
|
{
|
|
|
|
{
|
|
|
|
X: big.NewInt(8),
|
|
|
|
Y: big.NewInt(9),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
X: big.NewInt(10),
|
|
|
|
Y: big.NewInt(11),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2019-10-31 08:17:51 -05:00
|
|
|
c := [2][]TupleT{
|
2019-07-03 05:17:43 -05:00
|
|
|
{
|
|
|
|
{
|
|
|
|
X: big.NewInt(12),
|
|
|
|
Y: big.NewInt(13),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
X: big.NewInt(14),
|
|
|
|
Y: big.NewInt(15),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
{
|
|
|
|
X: big.NewInt(16),
|
|
|
|
Y: big.NewInt(17),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2019-10-31 08:17:51 -05:00
|
|
|
d := []TupleS{a}
|
2019-07-03 05:17:43 -05:00
|
|
|
|
|
|
|
e := []*big.Int{big.NewInt(18), big.NewInt(19)}
|
|
|
|
ret1, ret2, ret3, ret4, ret5, err := contract.Func1(nil, a, b, c, d, e)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("invoke contract failed, err %v", err)
|
|
|
|
}
|
|
|
|
check(ret1, a, "ret1 mismatch")
|
|
|
|
check(ret2, b, "ret2 mismatch")
|
|
|
|
check(ret3, c, "ret3 mismatch")
|
|
|
|
check(ret4, d, "ret4 mismatch")
|
|
|
|
check(ret5, e, "ret5 mismatch")
|
|
|
|
|
|
|
|
_, err = contract.Func2(auth, a, b, c, d, e)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("invoke contract failed, err %v", err)
|
|
|
|
}
|
2019-07-31 03:35:57 -05:00
|
|
|
sim.Commit()
|
2019-07-03 05:17:43 -05:00
|
|
|
|
|
|
|
iter, err := contract.FilterTupleEvent(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to create event filter, err %v", err)
|
|
|
|
}
|
|
|
|
defer iter.Close()
|
|
|
|
|
|
|
|
iter.Next()
|
|
|
|
check(iter.Event.A, a, "field1 mismatch")
|
|
|
|
check(iter.Event.B, b, "field2 mismatch")
|
|
|
|
check(iter.Event.C, c, "field3 mismatch")
|
|
|
|
check(iter.Event.D, d, "field4 mismatch")
|
|
|
|
check(iter.Event.E, e, "field5 mismatch")
|
2019-10-31 08:17:51 -05:00
|
|
|
|
|
|
|
err = contract.Func3(nil, nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to call function which has no return, err %v", err)
|
|
|
|
}
|
2019-07-03 05:17:43 -05:00
|
|
|
`,
|
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
},
|
|
|
|
{
|
|
|
|
`UseLibrary`,
|
|
|
|
`
|
|
|
|
library Math {
|
|
|
|
function add(uint a, uint b) public view returns(uint) {
|
|
|
|
return a + b;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
contract UseLibrary {
|
|
|
|
function add (uint c, uint d) public view returns(uint) {
|
|
|
|
return Math.add(c,d);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]string{
|
|
|
|
// Bytecode for the UseLibrary contract
|
|
|
|
`608060405234801561001057600080fd5b5061011d806100206000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063771602f714602d575b600080fd5b604d60048036036040811015604157600080fd5b5080359060200135605f565b60408051918252519081900360200190f35b600073__$b98c933f0a6ececcd167bd4f9d3299b1a0$__63771602f784846040518363ffffffff1660e01b8152600401808381526020018281526020019250505060206040518083038186803b15801560b757600080fd5b505af415801560ca573d6000803e3d6000fd5b505050506040513d602081101560df57600080fd5b5051939250505056fea265627a7a72305820eb5c38f42445604cfa43d85e3aa5ecc48b0a646456c902dd48420ae7241d06f664736f6c63430005090032`,
|
|
|
|
// Bytecode for the Math contract
|
|
|
|
`60a3610024600b82828239805160001a607314601757fe5b30600052607381538281f3fe730000000000000000000000000000000000000000301460806040526004361060335760003560e01c8063771602f7146038575b600080fd5b605860048036036040811015604c57600080fd5b5080359060200135606a565b60408051918252519081900360200190f35b019056fea265627a7a723058206fc6c05f3078327f9c763edffdb5ab5f8bd212e293a1306c7d0ad05af3ad35f464736f6c63430005090032`,
|
|
|
|
},
|
|
|
|
[]string{
|
|
|
|
`[{"constant":true,"inputs":[{"name":"c","type":"uint256"},{"name":"d","type":"uint256"}],"name":"add","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]`,
|
|
|
|
`[{"constant":true,"inputs":[{"name":"a","type":"uint256"},{"name":"b","type":"uint256"}],"name":"add","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]`,
|
|
|
|
},
|
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-07-31 03:35:57 -05:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-07-31 03:35:57 -05:00
|
|
|
defer sim.Close()
|
2019-07-08 03:27:05 -05:00
|
|
|
|
|
|
|
//deploy the test contract
|
|
|
|
_, _, testContract, err := DeployUseLibrary(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy test contract: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finish deploy.
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
// Check that the library contract has been deployed
|
|
|
|
// by calling the contract's add function.
|
|
|
|
res, err := testContract.Add(&bind.CallOpts{
|
|
|
|
From: auth.From,
|
|
|
|
Pending: false,
|
|
|
|
}, big.NewInt(1), big.NewInt(2))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to call linked contract: %v", err)
|
|
|
|
}
|
|
|
|
if res.Cmp(big.NewInt(3)) != 0 {
|
|
|
|
t.Fatalf("Add did not return the correct result: %d != %d", res, 3)
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
map[string]string{
|
|
|
|
"b98c933f0a6ececcd167bd4f9d3299b1a0": "Math",
|
|
|
|
},
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
2019-07-08 03:27:05 -05:00
|
|
|
[]string{"UseLibrary", "Math"},
|
2019-08-02 02:20:46 -05:00
|
|
|
}, {
|
|
|
|
"Overload",
|
|
|
|
`
|
|
|
|
pragma solidity ^0.5.10;
|
|
|
|
|
|
|
|
contract overload {
|
|
|
|
mapping(address => uint256) balances;
|
|
|
|
|
|
|
|
event bar(uint256 i);
|
|
|
|
event bar(uint256 i, uint256 j);
|
2019-11-18 07:39:39 -06:00
|
|
|
|
2019-08-02 02:20:46 -05:00
|
|
|
function foo(uint256 i) public {
|
|
|
|
emit bar(i);
|
|
|
|
}
|
|
|
|
function foo(uint256 i, uint256 j) public {
|
|
|
|
emit bar(i, j);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]string{`608060405234801561001057600080fd5b50610153806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806304bc52f81461003b5780632fbebd3814610073575b600080fd5b6100716004803603604081101561005157600080fd5b8101908080359060200190929190803590602001909291905050506100a1565b005b61009f6004803603602081101561008957600080fd5b81019080803590602001909291905050506100e4565b005b7fae42e9514233792a47a1e4554624e83fe852228e1503f63cd383e8a431f4f46d8282604051808381526020018281526020019250505060405180910390a15050565b7f0423a1321222a0a8716c22b92fac42d85a45a612b696a461784d9fa537c81e5c816040518082815260200191505060405180910390a15056fea265627a7a72305820e22b049858b33291cbe67eeaece0c5f64333e439d27032ea8337d08b1de18fe864736f6c634300050a0032`},
|
|
|
|
[]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"}]`},
|
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
// Initialize test accounts
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-08-02 02:20:46 -05:00
|
|
|
defer sim.Close()
|
|
|
|
|
|
|
|
// deploy the test contract
|
|
|
|
_, _, contract, err := DeployOverload(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy contract: %v", err)
|
|
|
|
}
|
|
|
|
// Finish deploy.
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
resCh, stopCh := make(chan uint64), make(chan struct{})
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
barSink := make(chan *OverloadBar)
|
|
|
|
sub, _ := contract.WatchBar(nil, barSink)
|
|
|
|
defer sub.Unsubscribe()
|
|
|
|
|
|
|
|
bar0Sink := make(chan *OverloadBar0)
|
|
|
|
sub0, _ := contract.WatchBar0(nil, bar0Sink)
|
|
|
|
defer sub0.Unsubscribe()
|
|
|
|
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case ev := <-barSink:
|
|
|
|
resCh <- ev.I.Uint64()
|
|
|
|
case ev := <-bar0Sink:
|
|
|
|
resCh <- ev.I.Uint64() + ev.J.Uint64()
|
|
|
|
case <-stopCh:
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
contract.Foo(auth, big.NewInt(1), big.NewInt(2))
|
|
|
|
sim.Commit()
|
|
|
|
select {
|
|
|
|
case n := <-resCh:
|
|
|
|
if n != 3 {
|
|
|
|
t.Fatalf("Invalid bar0 event")
|
|
|
|
}
|
2020-02-20 06:05:54 -06:00
|
|
|
case <-time.NewTimer(3 * time.Second).C:
|
2019-08-02 02:20:46 -05:00
|
|
|
t.Fatalf("Wait bar0 event timeout")
|
|
|
|
}
|
|
|
|
|
|
|
|
contract.Foo0(auth, big.NewInt(1))
|
|
|
|
sim.Commit()
|
|
|
|
select {
|
|
|
|
case n := <-resCh:
|
|
|
|
if n != 1 {
|
|
|
|
t.Fatalf("Invalid bar event")
|
|
|
|
}
|
2020-02-20 06:05:54 -06:00
|
|
|
case <-time.NewTimer(3 * time.Second).C:
|
2019-08-02 02:20:46 -05:00
|
|
|
t.Fatalf("Wait bar event timeout")
|
|
|
|
}
|
|
|
|
close(stopCh)
|
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
2019-11-14 01:26:10 -06:00
|
|
|
nil,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"IdentifierCollision",
|
|
|
|
`
|
|
|
|
pragma solidity >=0.4.19 <0.6.0;
|
|
|
|
|
|
|
|
contract IdentifierCollision {
|
|
|
|
uint public _myVar;
|
|
|
|
|
|
|
|
function MyVar() public view returns (uint) {
|
|
|
|
return _myVar;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]string{"60806040523480156100115760006000fd5b50610017565b60c3806100256000396000f3fe608060405234801560105760006000fd5b506004361060365760003560e01c806301ad4d8714603c5780634ef1f0ad146058576036565b60006000fd5b60426074565b6040518082815260200191505060405180910390f35b605e607d565b6040518082815260200191505060405180910390f35b60006000505481565b60006000600050549050608b565b9056fea265627a7a7231582067c8d84688b01c4754ba40a2a871cede94ea1f28b5981593ab2a45b46ac43af664736f6c634300050c0032"},
|
|
|
|
[]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"}]`},
|
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
// Initialize test accounts
|
|
|
|
key, _ := crypto.GenerateKey()
|
|
|
|
addr := crypto.PubkeyToAddress(key.PublicKey)
|
|
|
|
|
|
|
|
// Deploy registrar contract
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-11-14 01:26:10 -06:00
|
|
|
defer sim.Close()
|
|
|
|
|
2020-12-08 07:44:56 -06:00
|
|
|
transactOpts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-11-14 01:26:10 -06:00
|
|
|
_, _, _, err := DeployIdentifierCollision(transactOpts, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed to deploy contract: %v", err)
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
map[string]string{"_myVar": "pubVar"}, // alias MyVar to PubVar
|
|
|
|
nil,
|
accounts/abi: Abi binding support for nested arrays, fixes #15648, including nested array unpack fix (#15676)
* accounts/abi/bind: support for multi-dim arrays
Also:
- reduce usage of regexes a bit.
- fix minor Java syntax problems
Fixes #15648
* accounts/abi/bind: Add some more documentation
* accounts/abi/bind: Improve code readability
* accounts/abi: bugfix for unpacking nested arrays
The code previously assumed the arrays/slices were always 1 level
deep. While the packing supports nested arrays (!!!).
The current code for unpacking doesn't return the "consumed" length, so
this fix had to work around that by calculating it (i.e. packing and
getting resulting length) after the unpacking of the array element.
It's far from ideal, but unpacking behaviour is fixed now.
* accounts/abi: Fix unpacking of nested arrays
Removed the temporary workaround of packing to calculate size, which was
incorrect for slice-like types anyway.
Full size of nested arrays is used now.
* accounts/abi: deeply nested array unpack test
Test unpacking of an array nested more than one level.
* accounts/abi: Add deeply nested array pack test
Same as the deep nested array unpack test, but the other way around.
* accounts/abi/bind: deeply nested arrays bind test
Test the usage of bindings that were generated
for methods with multi-dimensional (and not
just a single extra dimension, like foo[2][3])
array arguments and returns.
edit: trigger rebuild, CI failed to fetch linter module.
* accounts/abi/bind: improve array binding
wrapArray uses a regex now, and arrayBindingJava is improved.
* accounts/abi: Improve naming of element size func
The full step size for unpacking an array
is now retrieved with "getFullElemSize".
* accounts/abi: support nested nested array args
Previously, the code only considered the outer-size of the array,
ignoring the size of the contents. This was fine for most types,
but nested arrays are packed directly into it, and count towards
the total size. This resulted in arguments following a nested
array to replicate some of the binary contents of the array.
The fix: for arrays, calculate their complete contents size:
count the arg.Type.Elem.Size when Elem is an Array, and
repeat when their child is an array too, etc.
The count is the number of 32 byte elements, similar to how it
previously counted, but nested.
* accounts/abi: Test deep nested arr multi-arguments
Arguments with a deeply nested array should not cause the next arguments
to be read from the wrong position.
2018-03-04 16:24:17 -06:00
|
|
|
},
|
2019-11-25 07:03:22 -06:00
|
|
|
{
|
|
|
|
"MultiContracts",
|
|
|
|
`
|
|
|
|
pragma solidity ^0.5.11;
|
|
|
|
pragma experimental ABIEncoderV2;
|
|
|
|
|
|
|
|
library ExternalLib {
|
|
|
|
struct SharedStruct{
|
|
|
|
uint256 f1;
|
|
|
|
bytes32 f2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
contract ContractOne {
|
|
|
|
function foo(ExternalLib.SharedStruct memory s) pure public {
|
|
|
|
// Do stuff
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
contract ContractTwo {
|
|
|
|
function bar(ExternalLib.SharedStruct memory s) pure public {
|
|
|
|
// Do stuff
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]string{
|
|
|
|
`60806040523480156100115760006000fd5b50610017565b6101b5806100266000396000f3fe60806040523480156100115760006000fd5b50600436106100305760003560e01c80639d8a8ba81461003657610030565b60006000fd5b610050600480360361004b91908101906100d1565b610052565b005b5b5056610171565b6000813590506100698161013d565b92915050565b6000604082840312156100825760006000fd5b61008c60406100fb565b9050600061009c848285016100bc565b60008301525060206100b08482850161005a565b60208301525092915050565b6000813590506100cb81610157565b92915050565b6000604082840312156100e45760006000fd5b60006100f28482850161006f565b91505092915050565b6000604051905081810181811067ffffffffffffffff8211171561011f5760006000fd5b8060405250919050565b6000819050919050565b6000819050919050565b61014681610129565b811415156101545760006000fd5b50565b61016081610133565b8114151561016e5760006000fd5b50565bfea365627a7a72315820749274eb7f6c01010d5322af4e1668b0a154409eb7968bd6cae5524c7ed669bb6c6578706572696d656e74616cf564736f6c634300050c0040`,
|
|
|
|
`60806040523480156100115760006000fd5b50610017565b6101b5806100266000396000f3fe60806040523480156100115760006000fd5b50600436106100305760003560e01c8063db8ba08c1461003657610030565b60006000fd5b610050600480360361004b91908101906100d1565b610052565b005b5b5056610171565b6000813590506100698161013d565b92915050565b6000604082840312156100825760006000fd5b61008c60406100fb565b9050600061009c848285016100bc565b60008301525060206100b08482850161005a565b60208301525092915050565b6000813590506100cb81610157565b92915050565b6000604082840312156100e45760006000fd5b60006100f28482850161006f565b91505092915050565b6000604051905081810181811067ffffffffffffffff8211171561011f5760006000fd5b8060405250919050565b6000819050919050565b6000819050919050565b61014681610129565b811415156101545760006000fd5b50565b61016081610133565b8114151561016e5760006000fd5b50565bfea365627a7a723158209bc28ee7ea97c131a13330d77ec73b4493b5c59c648352da81dd288b021192596c6578706572696d656e74616cf564736f6c634300050c0040`,
|
|
|
|
`606c6026600b82828239805160001a6073141515601857fe5b30600052607381538281f350fe73000000000000000000000000000000000000000030146080604052600436106023575b60006000fdfea365627a7a72315820518f0110144f5b3de95697d05e456a064656890d08e6f9cff47f3be710cc46a36c6578706572696d656e74616cf564736f6c634300050c0040`,
|
|
|
|
},
|
|
|
|
[]string{
|
|
|
|
`[{"constant":true,"inputs":[{"components":[{"internalType":"uint256","name":"f1","type":"uint256"},{"internalType":"bytes32","name":"f2","type":"bytes32"}],"internalType":"struct ExternalLib.SharedStruct","name":"s","type":"tuple"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"pure","type":"function"}]`,
|
|
|
|
`[{"constant":true,"inputs":[{"components":[{"internalType":"uint256","name":"f1","type":"uint256"},{"internalType":"bytes32","name":"f2","type":"bytes32"}],"internalType":"struct ExternalLib.SharedStruct","name":"s","type":"tuple"}],"name":"bar","outputs":[],"payable":false,"stateMutability":"pure","type":"function"}]`,
|
|
|
|
`[]`,
|
|
|
|
},
|
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
key, _ := crypto.GenerateKey()
|
|
|
|
addr := crypto.PubkeyToAddress(key.PublicKey)
|
|
|
|
|
|
|
|
// Deploy registrar contract
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2019-11-25 07:03:22 -06:00
|
|
|
defer sim.Close()
|
|
|
|
|
2020-12-08 07:44:56 -06:00
|
|
|
transactOpts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2019-11-25 07:03:22 -06:00
|
|
|
_, _, c1, err := DeployContractOne(transactOpts, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("Failed to deploy contract")
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
err = c1.Foo(nil, ExternalLibSharedStruct{
|
|
|
|
F1: big.NewInt(100),
|
|
|
|
F2: [32]byte{0x01, 0x02, 0x03},
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("Failed to invoke function")
|
|
|
|
}
|
|
|
|
_, _, c2, err := DeployContractTwo(transactOpts, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("Failed to deploy contract")
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
err = c2.Bar(nil, ExternalLibSharedStruct{
|
|
|
|
F1: big.NewInt(100),
|
|
|
|
F2: [32]byte{0x01, 0x02, 0x03},
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal("Failed to invoke function")
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
[]string{"ContractOne", "ContractTwo", "ExternalLib"},
|
|
|
|
},
|
2020-01-06 05:03:26 -06:00
|
|
|
// Test the existence of the free retrieval calls
|
|
|
|
{
|
|
|
|
`PureAndView`,
|
|
|
|
`pragma solidity >=0.6.0;
|
|
|
|
contract PureAndView {
|
|
|
|
function PureFunc() public pure returns (uint) {
|
|
|
|
return 42;
|
|
|
|
}
|
|
|
|
function ViewFunc() public view returns (uint) {
|
|
|
|
return block.number;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]string{`608060405234801561001057600080fd5b5060b68061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806376b5686a146037578063bb38c66c146053575b600080fd5b603d606f565b6040518082815260200191505060405180910390f35b60596077565b6040518082815260200191505060405180910390f35b600043905090565b6000602a90509056fea2646970667358221220d158c2ab7fdfce366a7998ec79ab84edd43b9815630bbaede2c760ea77f29f7f64736f6c63430006000033`},
|
|
|
|
[]string{`[{"inputs": [],"name": "PureFunc","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "pure","type": "function"},{"inputs": [],"name": "ViewFunc","outputs": [{"internalType": "uint256","name": "","type": "uint256"}],"stateMutability": "view","type": "function"}]`},
|
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
// Generate a new random account and a funded simulator
|
|
|
|
key, _ := crypto.GenerateKey()
|
2020-12-08 07:44:56 -06:00
|
|
|
auth, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2020-01-06 05:03:26 -06:00
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000000000)}}, 10000000)
|
2020-01-06 05:03:26 -06:00
|
|
|
defer sim.Close()
|
|
|
|
|
|
|
|
// Deploy a tester contract and execute a structured call on it
|
|
|
|
_, _, pav, err := DeployPureAndView(auth, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy PureAndView contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
2023-12-04 03:53:42 -06:00
|
|
|
// This test the existence of the free retriever call for view and pure functions
|
2020-01-06 05:03:26 -06:00
|
|
|
if num, err := pav.PureFunc(nil); err != nil {
|
|
|
|
t.Fatalf("Failed to call anonymous field retriever: %v", err)
|
|
|
|
} else if num.Cmp(big.NewInt(42)) != 0 {
|
|
|
|
t.Fatalf("Retrieved value mismatch: have %v, want %v", num, 42)
|
|
|
|
}
|
|
|
|
if num, err := pav.ViewFunc(nil); err != nil {
|
|
|
|
t.Fatalf("Failed to call anonymous field retriever: %v", err)
|
|
|
|
} else if num.Cmp(big.NewInt(1)) != 0 {
|
|
|
|
t.Fatalf("Retrieved value mismatch: have %v, want %v", num, 1)
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
},
|
2020-04-15 02:23:58 -05:00
|
|
|
// Test fallback separation introduced in v0.6.0
|
|
|
|
{
|
|
|
|
`NewFallbacks`,
|
|
|
|
`
|
|
|
|
pragma solidity >=0.6.0 <0.7.0;
|
|
|
|
|
|
|
|
contract NewFallbacks {
|
|
|
|
event Fallback(bytes data);
|
|
|
|
fallback() external {
|
2020-12-30 06:10:11 -06:00
|
|
|
emit Fallback(msg.data);
|
2020-04-15 02:23:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
event Received(address addr, uint value);
|
|
|
|
receive() external payable {
|
|
|
|
emit Received(msg.sender, msg.value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2020-12-30 06:10:11 -06:00
|
|
|
[]string{"6080604052348015600f57600080fd5b506101078061001f6000396000f3fe608060405236605f577f88a5966d370b9919b20f3e2c13ff65706f196a4e32cc2c12bf57088f885258743334604051808373ffffffffffffffffffffffffffffffffffffffff1681526020018281526020019250505060405180910390a1005b348015606a57600080fd5b507f9043988963722edecc2099c75b0af0ff76af14ffca42ed6bce059a20a2a9f98660003660405180806020018281038252848482818152602001925080828437600081840152601f19601f820116905080830192505050935050505060405180910390a100fea26469706673582212201f994dcfbc53bf610b19176f9a361eafa77b447fd9c796fa2c615dfd0aaf3b8b64736f6c634300060c0033"},
|
2020-04-15 02:23:58 -05:00
|
|
|
[]string{`[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Fallback","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Received","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]`},
|
|
|
|
`
|
|
|
|
"bytes"
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
key, _ := crypto.GenerateKey()
|
|
|
|
addr := crypto.PubkeyToAddress(key.PublicKey)
|
|
|
|
|
2021-06-15 05:56:14 -05:00
|
|
|
sim := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10000000000000000)}}, 1000000)
|
2020-04-15 02:23:58 -05:00
|
|
|
defer sim.Close()
|
|
|
|
|
2020-12-08 07:44:56 -06:00
|
|
|
opts, _ := bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
2020-04-15 02:23:58 -05:00
|
|
|
_, _, c, err := DeployNewFallbacks(opts, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
// Test receive function
|
|
|
|
opts.Value = big.NewInt(100)
|
|
|
|
c.Receive(opts)
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
var gotEvent bool
|
|
|
|
iter, _ := c.FilterReceived(nil)
|
|
|
|
defer iter.Close()
|
|
|
|
for iter.Next() {
|
|
|
|
if iter.Event.Addr != addr {
|
|
|
|
t.Fatal("Msg.sender mismatch")
|
|
|
|
}
|
|
|
|
if iter.Event.Value.Uint64() != 100 {
|
|
|
|
t.Fatal("Msg.value mismatch")
|
|
|
|
}
|
|
|
|
gotEvent = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
if !gotEvent {
|
|
|
|
t.Fatal("Expect to receive event emitted by receive")
|
|
|
|
}
|
|
|
|
|
|
|
|
// Test fallback function
|
2020-12-30 06:10:11 -06:00
|
|
|
gotEvent = false
|
2020-04-15 02:23:58 -05:00
|
|
|
opts.Value = nil
|
|
|
|
calldata := []byte{0x01, 0x02, 0x03}
|
|
|
|
c.Fallback(opts, calldata)
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
iter2, _ := c.FilterFallback(nil)
|
|
|
|
defer iter2.Close()
|
|
|
|
for iter2.Next() {
|
|
|
|
if !bytes.Equal(iter2.Event.Data, calldata) {
|
|
|
|
t.Fatal("calldata mismatch")
|
|
|
|
}
|
|
|
|
gotEvent = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
if !gotEvent {
|
|
|
|
t.Fatal("Expect to receive event emitted by fallback")
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
},
|
2021-09-22 03:18:18 -05:00
|
|
|
// Test resolving single struct argument
|
|
|
|
{
|
|
|
|
`NewSingleStructArgument`,
|
|
|
|
`
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
|
|
|
|
contract NewSingleStructArgument {
|
|
|
|
struct MyStruct{
|
|
|
|
uint256 a;
|
|
|
|
uint256 b;
|
|
|
|
}
|
|
|
|
event StructEvent(MyStruct s);
|
|
|
|
function TestEvent() public {
|
|
|
|
emit StructEvent(MyStruct({a: 1, b: 2}));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]string{"608060405234801561001057600080fd5b50610113806100206000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c806324ec1d3f14602d575b600080fd5b60336035565b005b7fb4b2ff75e30cb4317eaae16dd8a187dd89978df17565104caa6c2797caae27d460405180604001604052806001815260200160028152506040516078919060ba565b60405180910390a1565b6040820160008201516096600085018260ad565b50602082015160a7602085018260ad565b50505050565b60b48160d3565b82525050565b600060408201905060cd60008301846082565b92915050565b600081905091905056fea26469706673582212208823628796125bf9941ce4eda18da1be3cf2931b231708ab848e1bd7151c0c9a64736f6c63430008070033"},
|
|
|
|
[]string{`[{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"indexed":false,"internalType":"struct Test.MyStruct","name":"s","type":"tuple"}],"name":"StructEvent","type":"event"},{"inputs":[],"name":"TestEvent","outputs":[],"stateMutability":"nonpayable","type":"function"}]`},
|
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/ethconfig"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
var (
|
|
|
|
key, _ = crypto.GenerateKey()
|
|
|
|
user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
|
|
|
sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
|
|
|
|
)
|
|
|
|
defer sim.Close()
|
|
|
|
|
|
|
|
_, _, d, err := DeployNewSingleStructArgument(user, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to deploy contract %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
_, err = d.TestEvent(user)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to call contract %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
it, err := d.FilterStructEvent(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Failed to filter contract event %v", err)
|
|
|
|
}
|
|
|
|
var count int
|
|
|
|
for it.Next() {
|
|
|
|
if it.Event.S.A.Cmp(big.NewInt(1)) != 0 {
|
|
|
|
t.Fatal("Unexpected contract event")
|
|
|
|
}
|
|
|
|
if it.Event.S.B.Cmp(big.NewInt(2)) != 0 {
|
|
|
|
t.Fatal("Unexpected contract event")
|
|
|
|
}
|
|
|
|
count += 1
|
|
|
|
}
|
|
|
|
if count != 1 {
|
|
|
|
t.Fatal("Unexpected contract event number")
|
|
|
|
}
|
2021-10-14 06:33:28 -05:00
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
},
|
|
|
|
// Test errors introduced in v0.8.4
|
|
|
|
{
|
|
|
|
`NewErrors`,
|
|
|
|
`
|
|
|
|
pragma solidity >0.8.4;
|
|
|
|
|
|
|
|
contract NewErrors {
|
|
|
|
error MyError(uint256);
|
|
|
|
error MyError1(uint256);
|
|
|
|
error MyError2(uint256, uint256);
|
|
|
|
error MyError3(uint256 a, uint256 b, uint256 c);
|
|
|
|
function Error() public pure {
|
|
|
|
revert MyError3(1,2,3);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
[]string{"0x6080604052348015600f57600080fd5b5060998061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063726c638214602d575b600080fd5b60336035565b005b60405163024876cd60e61b815260016004820152600260248201526003604482015260640160405180910390fdfea264697066735822122093f786a1bc60216540cd999fbb4a6109e0fef20abcff6e9107fb2817ca968f3c64736f6c63430008070033"},
|
|
|
|
[]string{`[{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError","type":"error"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError1","type":"error"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError2","type":"error"},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"},{"internalType":"uint256","name":"c","type":"uint256"}],"name":"MyError3","type":"error"},{"inputs":[],"name":"Error","outputs":[],"stateMutability":"pure","type":"function"}]`},
|
|
|
|
`
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/ethconfig"
|
|
|
|
`,
|
|
|
|
`
|
|
|
|
var (
|
|
|
|
key, _ = crypto.GenerateKey()
|
|
|
|
user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
|
|
|
sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
|
|
|
|
)
|
|
|
|
defer sim.Close()
|
|
|
|
|
|
|
|
_, tx, contract, err := DeployNewErrors(user, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
_, err = bind.WaitDeployed(nil, sim, tx)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
if err := contract.Error(new(bind.CallOpts)); err == nil {
|
|
|
|
t.Fatalf("expected contract to throw error")
|
|
|
|
}
|
|
|
|
// TODO (MariusVanDerWijden unpack error using abigen
|
|
|
|
// once that is implemented
|
2021-09-22 03:18:18 -05:00
|
|
|
`,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
nil,
|
|
|
|
},
|
2021-12-02 06:53:10 -06:00
|
|
|
{
|
|
|
|
name: `ConstructorWithStructParam`,
|
|
|
|
contract: `
|
|
|
|
pragma solidity >=0.8.0 <0.9.0;
|
|
|
|
|
|
|
|
contract ConstructorWithStructParam {
|
|
|
|
struct StructType {
|
|
|
|
uint256 field;
|
|
|
|
}
|
|
|
|
|
|
|
|
constructor(StructType memory st) {}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
bytecode: []string{`0x608060405234801561001057600080fd5b506040516101c43803806101c48339818101604052810190610032919061014a565b50610177565b6000604051905090565b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6100958261004c565b810181811067ffffffffffffffff821117156100b4576100b361005d565b5b80604052505050565b60006100c7610038565b90506100d3828261008c565b919050565b6000819050919050565b6100eb816100d8565b81146100f657600080fd5b50565b600081519050610108816100e2565b92915050565b60006020828403121561012457610123610047565b5b61012e60206100bd565b9050600061013e848285016100f9565b60008301525092915050565b6000602082840312156101605761015f610042565b5b600061016e8482850161010e565b91505092915050565b603f806101856000396000f3fe6080604052600080fdfea2646970667358221220cdffa667affecefac5561f65f4a4ba914204a8d4eb859d8cd426fb306e5c12a364736f6c634300080a0033`},
|
|
|
|
abi: []string{`[{"inputs":[{"components":[{"internalType":"uint256","name":"field","type":"uint256"}],"internalType":"struct ConstructorWithStructParam.StructType","name":"st","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"}]`},
|
|
|
|
imports: `
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/ethconfig"
|
|
|
|
`,
|
|
|
|
tester: `
|
|
|
|
var (
|
|
|
|
key, _ = crypto.GenerateKey()
|
|
|
|
user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
|
|
|
sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
|
|
|
|
)
|
|
|
|
defer sim.Close()
|
|
|
|
|
|
|
|
_, tx, _, err := DeployConstructorWithStructParam(user, sim, ConstructorWithStructParamStructType{Field: big.NewInt(42)})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("DeployConstructorWithStructParam() got err %v; want nil err", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
2022-06-07 01:38:54 -05:00
|
|
|
if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
|
|
|
|
t.Logf("Deployment tx: %+v", tx)
|
|
|
|
t.Errorf("bind.WaitDeployed(nil, %T, <deployment tx>) got err %v; want nil err", sim, err)
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: `NameConflict`,
|
|
|
|
contract: `
|
|
|
|
// SPDX-License-Identifier: GPL-3.0
|
|
|
|
pragma solidity >=0.4.22 <0.9.0;
|
|
|
|
contract oracle {
|
|
|
|
struct request {
|
|
|
|
bytes data;
|
|
|
|
bytes _data;
|
|
|
|
}
|
|
|
|
event log (int msg, int _msg);
|
|
|
|
function addRequest(request memory req) public pure {}
|
|
|
|
function getRequest() pure public returns (request memory) {
|
|
|
|
return request("", "");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
`,
|
2022-07-19 04:44:48 -05:00
|
|
|
bytecode: []string{"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"},
|
2022-06-07 01:38:54 -05:00
|
|
|
abi: []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" } ]`},
|
|
|
|
imports: `
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/ethconfig"
|
|
|
|
`,
|
|
|
|
tester: `
|
|
|
|
var (
|
|
|
|
key, _ = crypto.GenerateKey()
|
|
|
|
user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
|
|
|
sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
|
|
|
|
)
|
|
|
|
defer sim.Close()
|
|
|
|
|
|
|
|
_, tx, _, err := DeployNameConflict(user, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("DeployNameConflict() got err %v; want nil err", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
2021-12-02 06:53:10 -06:00
|
|
|
if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
|
|
|
|
t.Logf("Deployment tx: %+v", tx)
|
|
|
|
t.Errorf("bind.WaitDeployed(nil, %T, <deployment tx>) got err %v; want nil err", sim, err)
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
},
|
2022-07-19 04:44:48 -05:00
|
|
|
{
|
|
|
|
name: "RangeKeyword",
|
|
|
|
contract: `
|
|
|
|
// SPDX-License-Identifier: GPL-3.0
|
|
|
|
pragma solidity >=0.4.22 <0.9.0;
|
|
|
|
contract keywordcontract {
|
|
|
|
function functionWithKeywordParameter(range uint256) public pure {}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
bytecode: []string{"0x608060405234801561001057600080fd5b5060dc8061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063527a119f14602d575b600080fd5b60436004803603810190603f9190605b565b6045565b005b50565b6000813590506055816092565b92915050565b600060208284031215606e57606d608d565b5b6000607a848285016048565b91505092915050565b6000819050919050565b600080fd5b6099816083565b811460a357600080fd5b5056fea2646970667358221220d4f4525e2615516394055d369fb17df41c359e5e962734f27fd683ea81fd9db164736f6c63430008070033"},
|
|
|
|
abi: []string{`[{"inputs":[{"internalType":"uint256","name":"range","type":"uint256"}],"name":"functionWithKeywordParameter","outputs":[],"stateMutability":"pure","type":"function"}]`},
|
|
|
|
imports: `
|
|
|
|
"math/big"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
|
|
|
|
"github.com/ethereum/go-ethereum/core"
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
"github.com/ethereum/go-ethereum/eth/ethconfig"
|
|
|
|
`,
|
|
|
|
tester: `
|
|
|
|
var (
|
|
|
|
key, _ = crypto.GenerateKey()
|
|
|
|
user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
|
|
|
|
sim = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
|
|
|
|
)
|
|
|
|
_, tx, _, err := DeployRangeKeyword(user, sim)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("error deploying contract: %v", err)
|
|
|
|
}
|
|
|
|
sim.Commit()
|
|
|
|
|
|
|
|
if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
|
|
|
|
t.Errorf("error deploying the contract: %v", err)
|
|
|
|
}
|
|
|
|
`,
|
2023-05-02 07:27:37 -05:00
|
|
|
}, {
|
|
|
|
name: "NumericMethodName",
|
|
|
|
contract: `
|
|
|
|
// SPDX-License-Identifier: GPL-3.0
|
|
|
|
pragma solidity >=0.4.22 <0.9.0;
|
|
|
|
|
|
|
|
contract NumericMethodName {
|
|
|
|
event _1TestEvent(address _param);
|
|
|
|
function _1test() public pure {}
|
|
|
|
function __1test() public pure {}
|
|
|
|
function __2test() public pure {}
|
|
|
|
}
|
|
|
|
`,
|
|
|
|
bytecode: []string{"0x6080604052348015600f57600080fd5b5060958061001e6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80639d993132146041578063d02767c7146049578063ffa02795146051575b600080fd5b60476059565b005b604f605b565b005b6057605d565b005b565b565b56fea26469706673582212200382ca602dff96a7e2ba54657985e2b4ac423a56abe4a1f0667bc635c4d4371f64736f6c63430008110033"},
|
|
|
|
abi: []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"}]`},
|
|
|
|
imports: `
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
`,
|
|
|
|
tester: `
|
|
|
|
if b, err := NewNumericMethodName(common.Address{}, nil); b == nil || err != nil {
|
|
|
|
t.Fatalf("combined binding (%v) nil or error (%v) not nil", b, nil)
|
|
|
|
}
|
|
|
|
`,
|
2022-07-19 04:44:48 -05:00
|
|
|
},
|
2016-03-16 05:48:33 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Tests that packages generated by the binder can be successfully compiled and
|
|
|
|
// the requested tester run against it.
|
2019-06-27 03:48:13 -05:00
|
|
|
func TestGolangBindings(t *testing.T) {
|
2016-03-16 05:48:33 -05:00
|
|
|
// Skip the test if no Go command can be found
|
|
|
|
gocmd := runtime.GOROOT() + "/bin/go"
|
|
|
|
if !common.FileExist(gocmd) {
|
|
|
|
t.Skip("go sdk not found for testing")
|
|
|
|
}
|
2016-03-31 04:45:50 -05:00
|
|
|
// Create a temporary workspace for the test suite
|
2022-04-08 08:44:55 -05:00
|
|
|
ws := t.TempDir()
|
2017-11-08 04:45:52 -06:00
|
|
|
|
2016-03-31 04:45:50 -05:00
|
|
|
pkg := filepath.Join(ws, "bindtest")
|
2022-04-08 08:44:55 -05:00
|
|
|
if err := os.MkdirAll(pkg, 0700); err != nil {
|
2016-03-31 04:45:50 -05:00
|
|
|
t.Fatalf("failed to create package: %v", err)
|
|
|
|
}
|
|
|
|
// Generate the test suite for all the contracts
|
|
|
|
for i, tt := range bindTests {
|
2021-12-02 06:53:10 -06:00
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
var types []string
|
|
|
|
if tt.types != nil {
|
|
|
|
types = tt.types
|
|
|
|
} else {
|
|
|
|
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)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("test %d: failed to generate binding: %v", i, err)
|
|
|
|
}
|
2022-05-17 07:27:04 -05:00
|
|
|
if err = os.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+".go"), []byte(bind), 0600); err != nil {
|
2021-12-02 06:53:10 -06:00
|
|
|
t.Fatalf("test %d: failed to write binding: %v", i, err)
|
|
|
|
}
|
|
|
|
// Generate the test file with the injected test code
|
|
|
|
code := fmt.Sprintf(`
|
2018-10-05 15:24:54 -05:00
|
|
|
package bindtest
|
|
|
|
|
|
|
|
import (
|
|
|
|
"testing"
|
|
|
|
%s
|
|
|
|
)
|
|
|
|
|
|
|
|
func Test%s(t *testing.T) {
|
|
|
|
%s
|
|
|
|
}
|
|
|
|
`, tt.imports, tt.name, tt.tester)
|
2022-05-17 07:27:04 -05:00
|
|
|
if err := os.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+"_test.go"), []byte(code), 0600); err != nil {
|
2021-12-02 06:53:10 -06:00
|
|
|
t.Fatalf("test %d: failed to write tests: %v", i, err)
|
|
|
|
}
|
|
|
|
})
|
2016-03-31 04:45:50 -05:00
|
|
|
}
|
2019-11-18 07:39:39 -06:00
|
|
|
// Convert the package to go modules and use the current source for go-ethereum
|
|
|
|
moder := exec.Command(gocmd, "mod", "init", "bindtest")
|
|
|
|
moder.Dir = pkg
|
|
|
|
if out, err := moder.CombinedOutput(); err != nil {
|
|
|
|
t.Fatalf("failed to convert binding test to modules: %v\n%s", err, out)
|
|
|
|
}
|
|
|
|
pwd, _ := os.Getwd()
|
2021-02-23 10:12:25 -06:00
|
|
|
replacer := exec.Command(gocmd, "mod", "edit", "-x", "-require", "github.com/ethereum/go-ethereum@v0.0.0", "-replace", "github.com/ethereum/go-ethereum="+filepath.Join(pwd, "..", "..", "..")) // Repo root
|
2019-11-18 07:39:39 -06:00
|
|
|
replacer.Dir = pkg
|
|
|
|
if out, err := replacer.CombinedOutput(); err != nil {
|
|
|
|
t.Fatalf("failed to replace binding test dependency to current source tree: %v\n%s", err, out)
|
|
|
|
}
|
2021-02-23 10:12:25 -06:00
|
|
|
tidier := exec.Command(gocmd, "mod", "tidy")
|
|
|
|
tidier.Dir = pkg
|
|
|
|
if out, err := tidier.CombinedOutput(); err != nil {
|
|
|
|
t.Fatalf("failed to tidy Go module file: %v\n%s", err, out)
|
|
|
|
}
|
2016-03-31 04:45:50 -05:00
|
|
|
// Test the entire package and report any failures
|
2018-01-05 04:39:24 -06:00
|
|
|
cmd := exec.Command(gocmd, "test", "-v", "-count", "1")
|
2016-03-31 04:45:50 -05:00
|
|
|
cmd.Dir = pkg
|
|
|
|
if out, err := cmd.CombinedOutput(); err != nil {
|
|
|
|
t.Fatalf("failed to run binding test: %v\n%s", err, out)
|
2016-03-16 05:48:33 -05:00
|
|
|
}
|
|
|
|
}
|