From 92f6ec13f2c8630b87e829417dca4523f070d571 Mon Sep 17 00:00:00 2001 From: Felix Lange Date: Thu, 23 Jan 2025 13:57:53 +0100 Subject: [PATCH] accounts/abi/abigen: update test bindings --- .../abigen/testdata/v2/callbackparam.go.txt | 8 +- .../abi/abigen/testdata/v2/crowdsale.go.txt | 71 +++++++--- accounts/abi/abigen/testdata/v2/dao.go.txt | 127 +++++++++++++----- .../testdata/v2/deeplynestedarray.go.txt | 24 +++- accounts/abi/abigen/testdata/v2/getter.go.txt | 8 +- .../testdata/v2/identifiercollision.go.txt | 16 ++- .../abigen/testdata/v2/inputchecker.go.txt | 48 +++++-- .../abi/abigen/testdata/v2/interactor.go.txt | 31 +++-- .../abigen/testdata/v2/nameconflict.go.txt | 16 ++- .../testdata/v2/numericmethodname.go.txt | 24 +++- .../abigen/testdata/v2/outputchecker.go.txt | 56 ++++++-- .../abi/abigen/testdata/v2/overload.go.txt | 16 ++- .../abigen/testdata/v2/rangekeyword.go.txt | 8 +- accounts/abi/abigen/testdata/v2/slicer.go.txt | 32 +++-- .../abi/abigen/testdata/v2/structs.go.txt | 16 ++- accounts/abi/abigen/testdata/v2/token.go.txt | 79 ++++++++--- accounts/abi/abigen/testdata/v2/tuple.go.txt | 24 +++- accounts/abi/abigen/testdata/v2/tupler.go.txt | 8 +- .../abi/abigen/testdata/v2/underscorer.go.txt | 64 ++++++--- .../bind/v2/internal/contracts/db/bindings.go | 40 ++++-- .../v2/internal/contracts/events/bindings.go | 32 +++-- .../contracts/nested_libraries/bindings.go | 78 ++++++++--- .../contracts/solc_errors/bindings.go | 24 +++- .../contracts/uint256arrayreturn/bindings.go | 8 +- 24 files changed, 642 insertions(+), 216 deletions(-) diff --git a/accounts/abi/abigen/testdata/v2/callbackparam.go.txt b/accounts/abi/abigen/testdata/v2/callbackparam.go.txt index 476a65a5a5..30dc5599ef 100644 --- a/accounts/abi/abigen/testdata/v2/callbackparam.go.txt +++ b/accounts/abi/abigen/testdata/v2/callbackparam.go.txt @@ -52,6 +52,10 @@ func (c *CallbackParam) Instance(backend bind.ContractBackend, addr common.Addre // Test is a free data retrieval call binding the contract method 0xd7a5aba2. // // Solidity: function test(function callback) returns() -func (callbackParam *CallbackParam) PackTest(Callback [24]byte) ([]byte, error) { - return callbackParam.abi.Pack("test", Callback) +func (callbackParam *CallbackParam) PackTest(Callback [24]byte) []byte { + enc, err := callbackParam.abi.Pack("test", Callback) + if err != nil { + panic(err) + } + return enc } diff --git a/accounts/abi/abigen/testdata/v2/crowdsale.go.txt b/accounts/abi/abigen/testdata/v2/crowdsale.go.txt index 3f059a3eb8..c2409c1559 100644 --- a/accounts/abi/abigen/testdata/v2/crowdsale.go.txt +++ b/accounts/abi/abigen/testdata/v2/crowdsale.go.txt @@ -50,15 +50,22 @@ func (c *Crowdsale) Instance(backend bind.ContractBackend, addr common.Address) } func (crowdsale *Crowdsale) PackConstructor(ifSuccessfulSendTo common.Address, fundingGoalInEthers *big.Int, durationInMinutes *big.Int, etherCostOfEachToken *big.Int, addressOfTokenUsedAsReward common.Address) []byte { - res, _ := crowdsale.abi.Pack("", ifSuccessfulSendTo, fundingGoalInEthers, durationInMinutes, etherCostOfEachToken, addressOfTokenUsedAsReward) - return res + enc, err := crowdsale.abi.Pack("", ifSuccessfulSendTo, fundingGoalInEthers, durationInMinutes, etherCostOfEachToken, addressOfTokenUsedAsReward) + if err != nil { + panic(err) + } + return enc } // AmountRaised is a free data retrieval call binding the contract method 0x7b3e5e7b. // // Solidity: function amountRaised() returns(uint256) -func (crowdsale *Crowdsale) PackAmountRaised() ([]byte, error) { - return crowdsale.abi.Pack("amountRaised") +func (crowdsale *Crowdsale) PackAmountRaised() []byte { + enc, err := crowdsale.abi.Pack("amountRaised") + if err != nil { + panic(err) + } + return enc } func (crowdsale *Crowdsale) UnpackAmountRaised(data []byte) (*big.Int, error) { @@ -77,8 +84,12 @@ func (crowdsale *Crowdsale) UnpackAmountRaised(data []byte) (*big.Int, error) { // Beneficiary is a free data retrieval call binding the contract method 0x38af3eed. // // Solidity: function beneficiary() returns(address) -func (crowdsale *Crowdsale) PackBeneficiary() ([]byte, error) { - return crowdsale.abi.Pack("beneficiary") +func (crowdsale *Crowdsale) PackBeneficiary() []byte { + enc, err := crowdsale.abi.Pack("beneficiary") + if err != nil { + panic(err) + } + return enc } func (crowdsale *Crowdsale) UnpackBeneficiary(data []byte) (common.Address, error) { @@ -97,15 +108,23 @@ func (crowdsale *Crowdsale) UnpackBeneficiary(data []byte) (common.Address, erro // CheckGoalReached is a free data retrieval call binding the contract method 0x01cb3b20. // // Solidity: function checkGoalReached() returns() -func (crowdsale *Crowdsale) PackCheckGoalReached() ([]byte, error) { - return crowdsale.abi.Pack("checkGoalReached") +func (crowdsale *Crowdsale) PackCheckGoalReached() []byte { + enc, err := crowdsale.abi.Pack("checkGoalReached") + if err != nil { + panic(err) + } + return enc } // Deadline is a free data retrieval call binding the contract method 0x29dcb0cf. // // Solidity: function deadline() returns(uint256) -func (crowdsale *Crowdsale) PackDeadline() ([]byte, error) { - return crowdsale.abi.Pack("deadline") +func (crowdsale *Crowdsale) PackDeadline() []byte { + enc, err := crowdsale.abi.Pack("deadline") + if err != nil { + panic(err) + } + return enc } func (crowdsale *Crowdsale) UnpackDeadline(data []byte) (*big.Int, error) { @@ -124,8 +143,12 @@ func (crowdsale *Crowdsale) UnpackDeadline(data []byte) (*big.Int, error) { // Funders is a free data retrieval call binding the contract method 0xdc0d3dff. // // Solidity: function funders(uint256 ) returns(address addr, uint256 amount) -func (crowdsale *Crowdsale) PackFunders(Arg0 *big.Int) ([]byte, error) { - return crowdsale.abi.Pack("funders", Arg0) +func (crowdsale *Crowdsale) PackFunders(Arg0 *big.Int) []byte { + enc, err := crowdsale.abi.Pack("funders", Arg0) + if err != nil { + panic(err) + } + return enc } type FundersOutput struct { @@ -152,8 +175,12 @@ func (crowdsale *Crowdsale) UnpackFunders(data []byte) (FundersOutput, error) { // FundingGoal is a free data retrieval call binding the contract method 0x7a3a0e84. // // Solidity: function fundingGoal() returns(uint256) -func (crowdsale *Crowdsale) PackFundingGoal() ([]byte, error) { - return crowdsale.abi.Pack("fundingGoal") +func (crowdsale *Crowdsale) PackFundingGoal() []byte { + enc, err := crowdsale.abi.Pack("fundingGoal") + if err != nil { + panic(err) + } + return enc } func (crowdsale *Crowdsale) UnpackFundingGoal(data []byte) (*big.Int, error) { @@ -172,8 +199,12 @@ func (crowdsale *Crowdsale) UnpackFundingGoal(data []byte) (*big.Int, error) { // Price is a free data retrieval call binding the contract method 0xa035b1fe. // // Solidity: function price() returns(uint256) -func (crowdsale *Crowdsale) PackPrice() ([]byte, error) { - return crowdsale.abi.Pack("price") +func (crowdsale *Crowdsale) PackPrice() []byte { + enc, err := crowdsale.abi.Pack("price") + if err != nil { + panic(err) + } + return enc } func (crowdsale *Crowdsale) UnpackPrice(data []byte) (*big.Int, error) { @@ -192,8 +223,12 @@ func (crowdsale *Crowdsale) UnpackPrice(data []byte) (*big.Int, error) { // TokenReward is a free data retrieval call binding the contract method 0x6e66f6e9. // // Solidity: function tokenReward() returns(address) -func (crowdsale *Crowdsale) PackTokenReward() ([]byte, error) { - return crowdsale.abi.Pack("tokenReward") +func (crowdsale *Crowdsale) PackTokenReward() []byte { + enc, err := crowdsale.abi.Pack("tokenReward") + if err != nil { + panic(err) + } + return enc } func (crowdsale *Crowdsale) UnpackTokenReward(data []byte) (common.Address, error) { diff --git a/accounts/abi/abigen/testdata/v2/dao.go.txt b/accounts/abi/abigen/testdata/v2/dao.go.txt index 65f6350a86..50458c4e97 100644 --- a/accounts/abi/abigen/testdata/v2/dao.go.txt +++ b/accounts/abi/abigen/testdata/v2/dao.go.txt @@ -50,29 +50,44 @@ func (c *DAO) Instance(backend bind.ContractBackend, addr common.Address) bind.C } func (dAO *DAO) PackConstructor(minimumQuorumForProposals *big.Int, minutesForDebate *big.Int, marginOfVotesForMajority *big.Int, congressLeader common.Address) []byte { - res, _ := dAO.abi.Pack("", minimumQuorumForProposals, minutesForDebate, marginOfVotesForMajority, congressLeader) - return res + enc, err := dAO.abi.Pack("", minimumQuorumForProposals, minutesForDebate, marginOfVotesForMajority, congressLeader) + if err != nil { + panic(err) + } + return enc } // ChangeMembership is a free data retrieval call binding the contract method 0x9644fcbd. // // Solidity: function changeMembership(address targetMember, bool canVote, string memberName) returns() -func (dAO *DAO) PackChangeMembership(TargetMember common.Address, CanVote bool, MemberName string) ([]byte, error) { - return dAO.abi.Pack("changeMembership", TargetMember, CanVote, MemberName) +func (dAO *DAO) PackChangeMembership(TargetMember common.Address, CanVote bool, MemberName string) []byte { + enc, err := dAO.abi.Pack("changeMembership", TargetMember, CanVote, MemberName) + if err != nil { + panic(err) + } + return enc } // ChangeVotingRules is a free data retrieval call binding the contract method 0xbcca1fd3. // // Solidity: function changeVotingRules(uint256 minimumQuorumForProposals, uint256 minutesForDebate, int256 marginOfVotesForMajority) returns() -func (dAO *DAO) PackChangeVotingRules(MinimumQuorumForProposals *big.Int, MinutesForDebate *big.Int, MarginOfVotesForMajority *big.Int) ([]byte, error) { - return dAO.abi.Pack("changeVotingRules", MinimumQuorumForProposals, MinutesForDebate, MarginOfVotesForMajority) +func (dAO *DAO) PackChangeVotingRules(MinimumQuorumForProposals *big.Int, MinutesForDebate *big.Int, MarginOfVotesForMajority *big.Int) []byte { + enc, err := dAO.abi.Pack("changeVotingRules", MinimumQuorumForProposals, MinutesForDebate, MarginOfVotesForMajority) + if err != nil { + panic(err) + } + return enc } // CheckProposalCode is a free data retrieval call binding the contract method 0xeceb2945. // // Solidity: function checkProposalCode(uint256 proposalNumber, address beneficiary, uint256 etherAmount, bytes transactionBytecode) returns(bool codeChecksOut) -func (dAO *DAO) PackCheckProposalCode(ProposalNumber *big.Int, Beneficiary common.Address, EtherAmount *big.Int, TransactionBytecode []byte) ([]byte, error) { - return dAO.abi.Pack("checkProposalCode", ProposalNumber, Beneficiary, EtherAmount, TransactionBytecode) +func (dAO *DAO) PackCheckProposalCode(ProposalNumber *big.Int, Beneficiary common.Address, EtherAmount *big.Int, TransactionBytecode []byte) []byte { + enc, err := dAO.abi.Pack("checkProposalCode", ProposalNumber, Beneficiary, EtherAmount, TransactionBytecode) + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackCheckProposalCode(data []byte) (bool, error) { @@ -91,8 +106,12 @@ func (dAO *DAO) UnpackCheckProposalCode(data []byte) (bool, error) { // DebatingPeriodInMinutes is a free data retrieval call binding the contract method 0x69bd3436. // // Solidity: function debatingPeriodInMinutes() returns(uint256) -func (dAO *DAO) PackDebatingPeriodInMinutes() ([]byte, error) { - return dAO.abi.Pack("debatingPeriodInMinutes") +func (dAO *DAO) PackDebatingPeriodInMinutes() []byte { + enc, err := dAO.abi.Pack("debatingPeriodInMinutes") + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackDebatingPeriodInMinutes(data []byte) (*big.Int, error) { @@ -111,8 +130,12 @@ func (dAO *DAO) UnpackDebatingPeriodInMinutes(data []byte) (*big.Int, error) { // ExecuteProposal is a free data retrieval call binding the contract method 0x237e9492. // // Solidity: function executeProposal(uint256 proposalNumber, bytes transactionBytecode) returns(int256 result) -func (dAO *DAO) PackExecuteProposal(ProposalNumber *big.Int, TransactionBytecode []byte) ([]byte, error) { - return dAO.abi.Pack("executeProposal", ProposalNumber, TransactionBytecode) +func (dAO *DAO) PackExecuteProposal(ProposalNumber *big.Int, TransactionBytecode []byte) []byte { + enc, err := dAO.abi.Pack("executeProposal", ProposalNumber, TransactionBytecode) + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackExecuteProposal(data []byte) (*big.Int, error) { @@ -131,8 +154,12 @@ func (dAO *DAO) UnpackExecuteProposal(data []byte) (*big.Int, error) { // MajorityMargin is a free data retrieval call binding the contract method 0xaa02a90f. // // Solidity: function majorityMargin() returns(int256) -func (dAO *DAO) PackMajorityMargin() ([]byte, error) { - return dAO.abi.Pack("majorityMargin") +func (dAO *DAO) PackMajorityMargin() []byte { + enc, err := dAO.abi.Pack("majorityMargin") + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackMajorityMargin(data []byte) (*big.Int, error) { @@ -151,8 +178,12 @@ func (dAO *DAO) UnpackMajorityMargin(data []byte) (*big.Int, error) { // MemberId is a free data retrieval call binding the contract method 0x39106821. // // Solidity: function memberId(address ) returns(uint256) -func (dAO *DAO) PackMemberId(Arg0 common.Address) ([]byte, error) { - return dAO.abi.Pack("memberId", Arg0) +func (dAO *DAO) PackMemberId(Arg0 common.Address) []byte { + enc, err := dAO.abi.Pack("memberId", Arg0) + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackMemberId(data []byte) (*big.Int, error) { @@ -171,8 +202,12 @@ func (dAO *DAO) UnpackMemberId(data []byte) (*big.Int, error) { // Members is a free data retrieval call binding the contract method 0x5daf08ca. // // Solidity: function members(uint256 ) returns(address member, bool canVote, string name, uint256 memberSince) -func (dAO *DAO) PackMembers(Arg0 *big.Int) ([]byte, error) { - return dAO.abi.Pack("members", Arg0) +func (dAO *DAO) PackMembers(Arg0 *big.Int) []byte { + enc, err := dAO.abi.Pack("members", Arg0) + if err != nil { + panic(err) + } + return enc } type MembersOutput struct { @@ -205,8 +240,12 @@ func (dAO *DAO) UnpackMembers(data []byte) (MembersOutput, error) { // MinimumQuorum is a free data retrieval call binding the contract method 0x8160f0b5. // // Solidity: function minimumQuorum() returns(uint256) -func (dAO *DAO) PackMinimumQuorum() ([]byte, error) { - return dAO.abi.Pack("minimumQuorum") +func (dAO *DAO) PackMinimumQuorum() []byte { + enc, err := dAO.abi.Pack("minimumQuorum") + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackMinimumQuorum(data []byte) (*big.Int, error) { @@ -225,8 +264,12 @@ func (dAO *DAO) UnpackMinimumQuorum(data []byte) (*big.Int, error) { // NewProposal is a free data retrieval call binding the contract method 0xb1050da5. // // Solidity: function newProposal(address beneficiary, uint256 etherAmount, string JobDescription, bytes transactionBytecode) returns(uint256 proposalID) -func (dAO *DAO) PackNewProposal(Beneficiary common.Address, EtherAmount *big.Int, JobDescription string, TransactionBytecode []byte) ([]byte, error) { - return dAO.abi.Pack("newProposal", Beneficiary, EtherAmount, JobDescription, TransactionBytecode) +func (dAO *DAO) PackNewProposal(Beneficiary common.Address, EtherAmount *big.Int, JobDescription string, TransactionBytecode []byte) []byte { + enc, err := dAO.abi.Pack("newProposal", Beneficiary, EtherAmount, JobDescription, TransactionBytecode) + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackNewProposal(data []byte) (*big.Int, error) { @@ -245,8 +288,12 @@ func (dAO *DAO) UnpackNewProposal(data []byte) (*big.Int, error) { // NumProposals is a free data retrieval call binding the contract method 0x400e3949. // // Solidity: function numProposals() returns(uint256) -func (dAO *DAO) PackNumProposals() ([]byte, error) { - return dAO.abi.Pack("numProposals") +func (dAO *DAO) PackNumProposals() []byte { + enc, err := dAO.abi.Pack("numProposals") + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackNumProposals(data []byte) (*big.Int, error) { @@ -265,8 +312,12 @@ func (dAO *DAO) UnpackNumProposals(data []byte) (*big.Int, error) { // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. // // Solidity: function owner() returns(address) -func (dAO *DAO) PackOwner() ([]byte, error) { - return dAO.abi.Pack("owner") +func (dAO *DAO) PackOwner() []byte { + enc, err := dAO.abi.Pack("owner") + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackOwner(data []byte) (common.Address, error) { @@ -285,8 +336,12 @@ func (dAO *DAO) UnpackOwner(data []byte) (common.Address, error) { // Proposals is a free data retrieval call binding the contract method 0x013cf08b. // // Solidity: function proposals(uint256 ) returns(address recipient, uint256 amount, string description, uint256 votingDeadline, bool executed, bool proposalPassed, uint256 numberOfVotes, int256 currentResult, bytes32 proposalHash) -func (dAO *DAO) PackProposals(Arg0 *big.Int) ([]byte, error) { - return dAO.abi.Pack("proposals", Arg0) +func (dAO *DAO) PackProposals(Arg0 *big.Int) []byte { + enc, err := dAO.abi.Pack("proposals", Arg0) + if err != nil { + panic(err) + } + return enc } type ProposalsOutput struct { @@ -334,15 +389,23 @@ func (dAO *DAO) UnpackProposals(data []byte) (ProposalsOutput, error) { // TransferOwnership is a free data retrieval call binding the contract method 0xf2fde38b. // // Solidity: function transferOwnership(address newOwner) returns() -func (dAO *DAO) PackTransferOwnership(NewOwner common.Address) ([]byte, error) { - return dAO.abi.Pack("transferOwnership", NewOwner) +func (dAO *DAO) PackTransferOwnership(NewOwner common.Address) []byte { + enc, err := dAO.abi.Pack("transferOwnership", NewOwner) + if err != nil { + panic(err) + } + return enc } // Vote is a free data retrieval call binding the contract method 0xd3c0715b. // // Solidity: function vote(uint256 proposalNumber, bool supportsProposal, string justificationText) returns(uint256 voteID) -func (dAO *DAO) PackVote(ProposalNumber *big.Int, SupportsProposal bool, JustificationText string) ([]byte, error) { - return dAO.abi.Pack("vote", ProposalNumber, SupportsProposal, JustificationText) +func (dAO *DAO) PackVote(ProposalNumber *big.Int, SupportsProposal bool, JustificationText string) []byte { + enc, err := dAO.abi.Pack("vote", ProposalNumber, SupportsProposal, JustificationText) + if err != nil { + panic(err) + } + return enc } func (dAO *DAO) UnpackVote(data []byte) (*big.Int, error) { diff --git a/accounts/abi/abigen/testdata/v2/deeplynestedarray.go.txt b/accounts/abi/abigen/testdata/v2/deeplynestedarray.go.txt index b1d7fd2f39..d0bb81f525 100644 --- a/accounts/abi/abigen/testdata/v2/deeplynestedarray.go.txt +++ b/accounts/abi/abigen/testdata/v2/deeplynestedarray.go.txt @@ -52,8 +52,12 @@ func (c *DeeplyNestedArray) Instance(backend bind.ContractBackend, addr common.A // DeepUint64Array is a free data retrieval call binding the contract method 0x98ed1856. // // Solidity: function deepUint64Array(uint256 , uint256 , uint256 ) view returns(uint64) -func (deeplyNestedArray *DeeplyNestedArray) PackDeepUint64Array(Arg0 *big.Int, Arg1 *big.Int, Arg2 *big.Int) ([]byte, error) { - return deeplyNestedArray.abi.Pack("deepUint64Array", Arg0, Arg1, Arg2) +func (deeplyNestedArray *DeeplyNestedArray) PackDeepUint64Array(Arg0 *big.Int, Arg1 *big.Int, Arg2 *big.Int) []byte { + enc, err := deeplyNestedArray.abi.Pack("deepUint64Array", Arg0, Arg1, Arg2) + if err != nil { + panic(err) + } + return enc } func (deeplyNestedArray *DeeplyNestedArray) UnpackDeepUint64Array(data []byte) (uint64, error) { @@ -72,8 +76,12 @@ func (deeplyNestedArray *DeeplyNestedArray) UnpackDeepUint64Array(data []byte) ( // RetrieveDeepArray is a free data retrieval call binding the contract method 0x8ed4573a. // // Solidity: function retrieveDeepArray() view returns(uint64[3][4][5]) -func (deeplyNestedArray *DeeplyNestedArray) PackRetrieveDeepArray() ([]byte, error) { - return deeplyNestedArray.abi.Pack("retrieveDeepArray") +func (deeplyNestedArray *DeeplyNestedArray) PackRetrieveDeepArray() []byte { + enc, err := deeplyNestedArray.abi.Pack("retrieveDeepArray") + if err != nil { + panic(err) + } + return enc } func (deeplyNestedArray *DeeplyNestedArray) UnpackRetrieveDeepArray(data []byte) ([5][4][3]uint64, error) { @@ -92,6 +100,10 @@ func (deeplyNestedArray *DeeplyNestedArray) UnpackRetrieveDeepArray(data []byte) // StoreDeepUintArray is a free data retrieval call binding the contract method 0x34424855. // // Solidity: function storeDeepUintArray(uint64[3][4][5] arr) returns() -func (deeplyNestedArray *DeeplyNestedArray) PackStoreDeepUintArray(Arr [5][4][3]uint64) ([]byte, error) { - return deeplyNestedArray.abi.Pack("storeDeepUintArray", Arr) +func (deeplyNestedArray *DeeplyNestedArray) PackStoreDeepUintArray(Arr [5][4][3]uint64) []byte { + enc, err := deeplyNestedArray.abi.Pack("storeDeepUintArray", Arr) + if err != nil { + panic(err) + } + return enc } diff --git a/accounts/abi/abigen/testdata/v2/getter.go.txt b/accounts/abi/abigen/testdata/v2/getter.go.txt index 43972fd9f9..2e52057e69 100644 --- a/accounts/abi/abigen/testdata/v2/getter.go.txt +++ b/accounts/abi/abigen/testdata/v2/getter.go.txt @@ -52,8 +52,12 @@ func (c *Getter) Instance(backend bind.ContractBackend, addr common.Address) bin // Getter is a free data retrieval call binding the contract method 0x993a04b7. // // Solidity: function getter() returns(string, int256, bytes32) -func (getter *Getter) PackGetter() ([]byte, error) { - return getter.abi.Pack("getter") +func (getter *Getter) PackGetter() []byte { + enc, err := getter.abi.Pack("getter") + if err != nil { + panic(err) + } + return enc } type GetterOutput struct { diff --git a/accounts/abi/abigen/testdata/v2/identifiercollision.go.txt b/accounts/abi/abigen/testdata/v2/identifiercollision.go.txt index 9631917f56..2db6b91a4f 100644 --- a/accounts/abi/abigen/testdata/v2/identifiercollision.go.txt +++ b/accounts/abi/abigen/testdata/v2/identifiercollision.go.txt @@ -52,8 +52,12 @@ func (c *IdentifierCollision) Instance(backend bind.ContractBackend, addr common // MyVar is a free data retrieval call binding the contract method 0x4ef1f0ad. // // Solidity: function MyVar() view returns(uint256) -func (identifierCollision *IdentifierCollision) PackMyVar() ([]byte, error) { - return identifierCollision.abi.Pack("MyVar") +func (identifierCollision *IdentifierCollision) PackMyVar() []byte { + enc, err := identifierCollision.abi.Pack("MyVar") + if err != nil { + panic(err) + } + return enc } func (identifierCollision *IdentifierCollision) UnpackMyVar(data []byte) (*big.Int, error) { @@ -72,8 +76,12 @@ func (identifierCollision *IdentifierCollision) UnpackMyVar(data []byte) (*big.I // PubVar is a free data retrieval call binding the contract method 0x01ad4d87. // // Solidity: function _myVar() view returns(uint256) -func (identifierCollision *IdentifierCollision) PackPubVar() ([]byte, error) { - return identifierCollision.abi.Pack("_myVar") +func (identifierCollision *IdentifierCollision) PackPubVar() []byte { + enc, err := identifierCollision.abi.Pack("_myVar") + if err != nil { + panic(err) + } + return enc } func (identifierCollision *IdentifierCollision) UnpackPubVar(data []byte) (*big.Int, error) { diff --git a/accounts/abi/abigen/testdata/v2/inputchecker.go.txt b/accounts/abi/abigen/testdata/v2/inputchecker.go.txt index 0226f1bb08..2b5acc1dea 100644 --- a/accounts/abi/abigen/testdata/v2/inputchecker.go.txt +++ b/accounts/abi/abigen/testdata/v2/inputchecker.go.txt @@ -51,41 +51,65 @@ func (c *InputChecker) Instance(backend bind.ContractBackend, addr common.Addres // AnonInput is a free data retrieval call binding the contract method 0x3e708e82. // // Solidity: function anonInput(string ) returns() -func (inputChecker *InputChecker) PackAnonInput(Arg0 string) ([]byte, error) { - return inputChecker.abi.Pack("anonInput", Arg0) +func (inputChecker *InputChecker) PackAnonInput(Arg0 string) []byte { + enc, err := inputChecker.abi.Pack("anonInput", Arg0) + if err != nil { + panic(err) + } + return enc } // AnonInputs is a free data retrieval call binding the contract method 0x28160527. // // Solidity: function anonInputs(string , string ) returns() -func (inputChecker *InputChecker) PackAnonInputs(Arg0 string, Arg1 string) ([]byte, error) { - return inputChecker.abi.Pack("anonInputs", Arg0, Arg1) +func (inputChecker *InputChecker) PackAnonInputs(Arg0 string, Arg1 string) []byte { + enc, err := inputChecker.abi.Pack("anonInputs", Arg0, Arg1) + if err != nil { + panic(err) + } + return enc } // MixedInputs is a free data retrieval call binding the contract method 0xc689ebdc. // // Solidity: function mixedInputs(string , string str) returns() -func (inputChecker *InputChecker) PackMixedInputs(Arg0 string, Str string) ([]byte, error) { - return inputChecker.abi.Pack("mixedInputs", Arg0, Str) +func (inputChecker *InputChecker) PackMixedInputs(Arg0 string, Str string) []byte { + enc, err := inputChecker.abi.Pack("mixedInputs", Arg0, Str) + if err != nil { + panic(err) + } + return enc } // NamedInput is a free data retrieval call binding the contract method 0x0d402005. // // Solidity: function namedInput(string str) returns() -func (inputChecker *InputChecker) PackNamedInput(Str string) ([]byte, error) { - return inputChecker.abi.Pack("namedInput", Str) +func (inputChecker *InputChecker) PackNamedInput(Str string) []byte { + enc, err := inputChecker.abi.Pack("namedInput", Str) + if err != nil { + panic(err) + } + return enc } // NamedInputs is a free data retrieval call binding the contract method 0x63c796ed. // // Solidity: function namedInputs(string str1, string str2) returns() -func (inputChecker *InputChecker) PackNamedInputs(Str1 string, Str2 string) ([]byte, error) { - return inputChecker.abi.Pack("namedInputs", Str1, Str2) +func (inputChecker *InputChecker) PackNamedInputs(Str1 string, Str2 string) []byte { + enc, err := inputChecker.abi.Pack("namedInputs", Str1, Str2) + if err != nil { + panic(err) + } + return enc } // NoInput is a free data retrieval call binding the contract method 0x53539029. // // Solidity: function noInput() returns() -func (inputChecker *InputChecker) PackNoInput() ([]byte, error) { - return inputChecker.abi.Pack("noInput") +func (inputChecker *InputChecker) PackNoInput() []byte { + enc, err := inputChecker.abi.Pack("noInput") + if err != nil { + panic(err) + } + return enc } diff --git a/accounts/abi/abigen/testdata/v2/interactor.go.txt b/accounts/abi/abigen/testdata/v2/interactor.go.txt index 5fdba215fa..f1948a8f19 100644 --- a/accounts/abi/abigen/testdata/v2/interactor.go.txt +++ b/accounts/abi/abigen/testdata/v2/interactor.go.txt @@ -50,15 +50,22 @@ func (c *Interactor) Instance(backend bind.ContractBackend, addr common.Address) } func (interactor *Interactor) PackConstructor(str string) []byte { - res, _ := interactor.abi.Pack("", str) - return res + enc, err := interactor.abi.Pack("", str) + if err != nil { + panic(err) + } + return enc } // DeployString is a free data retrieval call binding the contract method 0x6874e809. // // Solidity: function deployString() returns(string) -func (interactor *Interactor) PackDeployString() ([]byte, error) { - return interactor.abi.Pack("deployString") +func (interactor *Interactor) PackDeployString() []byte { + enc, err := interactor.abi.Pack("deployString") + if err != nil { + panic(err) + } + return enc } func (interactor *Interactor) UnpackDeployString(data []byte) (string, error) { @@ -77,15 +84,23 @@ func (interactor *Interactor) UnpackDeployString(data []byte) (string, error) { // Transact is a free data retrieval call binding the contract method 0xd736c513. // // Solidity: function transact(string str) returns() -func (interactor *Interactor) PackTransact(Str string) ([]byte, error) { - return interactor.abi.Pack("transact", Str) +func (interactor *Interactor) PackTransact(Str string) []byte { + enc, err := interactor.abi.Pack("transact", Str) + if err != nil { + panic(err) + } + return enc } // TransactString is a free data retrieval call binding the contract method 0x0d86a0e1. // // Solidity: function transactString() returns(string) -func (interactor *Interactor) PackTransactString() ([]byte, error) { - return interactor.abi.Pack("transactString") +func (interactor *Interactor) PackTransactString() []byte { + enc, err := interactor.abi.Pack("transactString") + if err != nil { + panic(err) + } + return enc } func (interactor *Interactor) UnpackTransactString(data []byte) (string, error) { diff --git a/accounts/abi/abigen/testdata/v2/nameconflict.go.txt b/accounts/abi/abigen/testdata/v2/nameconflict.go.txt index bd4d75e365..b7f9494d54 100644 --- a/accounts/abi/abigen/testdata/v2/nameconflict.go.txt +++ b/accounts/abi/abigen/testdata/v2/nameconflict.go.txt @@ -58,15 +58,23 @@ func (c *NameConflict) Instance(backend bind.ContractBackend, addr common.Addres // AddRequest is a free data retrieval call binding the contract method 0xcce7b048. // // Solidity: function addRequest((bytes,bytes) req) pure returns() -func (nameConflict *NameConflict) PackAddRequest(Req Oraclerequest) ([]byte, error) { - return nameConflict.abi.Pack("addRequest", Req) +func (nameConflict *NameConflict) PackAddRequest(Req Oraclerequest) []byte { + enc, err := nameConflict.abi.Pack("addRequest", Req) + if err != nil { + panic(err) + } + return enc } // GetRequest is a free data retrieval call binding the contract method 0xc2bb515f. // // Solidity: function getRequest() pure returns((bytes,bytes)) -func (nameConflict *NameConflict) PackGetRequest() ([]byte, error) { - return nameConflict.abi.Pack("getRequest") +func (nameConflict *NameConflict) PackGetRequest() []byte { + enc, err := nameConflict.abi.Pack("getRequest") + if err != nil { + panic(err) + } + return enc } func (nameConflict *NameConflict) UnpackGetRequest(data []byte) (Oraclerequest, error) { diff --git a/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt b/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt index 7001e65809..e9db3bb7ff 100644 --- a/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt +++ b/accounts/abi/abigen/testdata/v2/numericmethodname.go.txt @@ -52,22 +52,34 @@ func (c *NumericMethodName) Instance(backend bind.ContractBackend, addr common.A // E1test is a free data retrieval call binding the contract method 0xffa02795. // // Solidity: function _1test() pure returns() -func (numericMethodName *NumericMethodName) PackE1test() ([]byte, error) { - return numericMethodName.abi.Pack("_1test") +func (numericMethodName *NumericMethodName) PackE1test() []byte { + enc, err := numericMethodName.abi.Pack("_1test") + if err != nil { + panic(err) + } + return enc } // E1test0 is a free data retrieval call binding the contract method 0xd02767c7. // // Solidity: function __1test() pure returns() -func (numericMethodName *NumericMethodName) PackE1test0() ([]byte, error) { - return numericMethodName.abi.Pack("__1test") +func (numericMethodName *NumericMethodName) PackE1test0() []byte { + enc, err := numericMethodName.abi.Pack("__1test") + if err != nil { + panic(err) + } + return enc } // E2test is a free data retrieval call binding the contract method 0x9d993132. // // Solidity: function __2test() pure returns() -func (numericMethodName *NumericMethodName) PackE2test() ([]byte, error) { - return numericMethodName.abi.Pack("__2test") +func (numericMethodName *NumericMethodName) PackE2test() []byte { + enc, err := numericMethodName.abi.Pack("__2test") + if err != nil { + panic(err) + } + return enc } // NumericMethodNameE1TestEvent represents a E1TestEvent event raised by the NumericMethodName contract. diff --git a/accounts/abi/abigen/testdata/v2/outputchecker.go.txt b/accounts/abi/abigen/testdata/v2/outputchecker.go.txt index e3f5b97856..ee5100bbbf 100644 --- a/accounts/abi/abigen/testdata/v2/outputchecker.go.txt +++ b/accounts/abi/abigen/testdata/v2/outputchecker.go.txt @@ -51,8 +51,12 @@ func (c *OutputChecker) Instance(backend bind.ContractBackend, addr common.Addre // AnonOutput is a free data retrieval call binding the contract method 0x008bda05. // // Solidity: function anonOutput() returns(string) -func (outputChecker *OutputChecker) PackAnonOutput() ([]byte, error) { - return outputChecker.abi.Pack("anonOutput") +func (outputChecker *OutputChecker) PackAnonOutput() []byte { + enc, err := outputChecker.abi.Pack("anonOutput") + if err != nil { + panic(err) + } + return enc } func (outputChecker *OutputChecker) UnpackAnonOutput(data []byte) (string, error) { @@ -71,8 +75,12 @@ func (outputChecker *OutputChecker) UnpackAnonOutput(data []byte) (string, error // AnonOutputs is a free data retrieval call binding the contract method 0x3c401115. // // Solidity: function anonOutputs() returns(string, string) -func (outputChecker *OutputChecker) PackAnonOutputs() ([]byte, error) { - return outputChecker.abi.Pack("anonOutputs") +func (outputChecker *OutputChecker) PackAnonOutputs() []byte { + enc, err := outputChecker.abi.Pack("anonOutputs") + if err != nil { + panic(err) + } + return enc } type AnonOutputsOutput struct { @@ -99,8 +107,12 @@ func (outputChecker *OutputChecker) UnpackAnonOutputs(data []byte) (AnonOutputsO // CollidingOutputs is a free data retrieval call binding the contract method 0xeccbc1ee. // // Solidity: function collidingOutputs() returns(string str, string Str) -func (outputChecker *OutputChecker) PackCollidingOutputs() ([]byte, error) { - return outputChecker.abi.Pack("collidingOutputs") +func (outputChecker *OutputChecker) PackCollidingOutputs() []byte { + enc, err := outputChecker.abi.Pack("collidingOutputs") + if err != nil { + panic(err) + } + return enc } type CollidingOutputsOutput struct { @@ -127,8 +139,12 @@ func (outputChecker *OutputChecker) UnpackCollidingOutputs(data []byte) (Collidi // MixedOutputs is a free data retrieval call binding the contract method 0x21b77b44. // // Solidity: function mixedOutputs() returns(string, string str) -func (outputChecker *OutputChecker) PackMixedOutputs() ([]byte, error) { - return outputChecker.abi.Pack("mixedOutputs") +func (outputChecker *OutputChecker) PackMixedOutputs() []byte { + enc, err := outputChecker.abi.Pack("mixedOutputs") + if err != nil { + panic(err) + } + return enc } type MixedOutputsOutput struct { @@ -155,8 +171,12 @@ func (outputChecker *OutputChecker) UnpackMixedOutputs(data []byte) (MixedOutput // NamedOutput is a free data retrieval call binding the contract method 0x5e632bd5. // // Solidity: function namedOutput() returns(string str) -func (outputChecker *OutputChecker) PackNamedOutput() ([]byte, error) { - return outputChecker.abi.Pack("namedOutput") +func (outputChecker *OutputChecker) PackNamedOutput() []byte { + enc, err := outputChecker.abi.Pack("namedOutput") + if err != nil { + panic(err) + } + return enc } func (outputChecker *OutputChecker) UnpackNamedOutput(data []byte) (string, error) { @@ -175,8 +195,12 @@ func (outputChecker *OutputChecker) UnpackNamedOutput(data []byte) (string, erro // NamedOutputs is a free data retrieval call binding the contract method 0x7970a189. // // Solidity: function namedOutputs() returns(string str1, string str2) -func (outputChecker *OutputChecker) PackNamedOutputs() ([]byte, error) { - return outputChecker.abi.Pack("namedOutputs") +func (outputChecker *OutputChecker) PackNamedOutputs() []byte { + enc, err := outputChecker.abi.Pack("namedOutputs") + if err != nil { + panic(err) + } + return enc } type NamedOutputsOutput struct { @@ -203,6 +227,10 @@ func (outputChecker *OutputChecker) UnpackNamedOutputs(data []byte) (NamedOutput // NoOutput is a free data retrieval call binding the contract method 0x625f0306. // // Solidity: function noOutput() returns() -func (outputChecker *OutputChecker) PackNoOutput() ([]byte, error) { - return outputChecker.abi.Pack("noOutput") +func (outputChecker *OutputChecker) PackNoOutput() []byte { + enc, err := outputChecker.abi.Pack("noOutput") + if err != nil { + panic(err) + } + return enc } diff --git a/accounts/abi/abigen/testdata/v2/overload.go.txt b/accounts/abi/abigen/testdata/v2/overload.go.txt index 6a0d7d081b..6e41dd0ce0 100644 --- a/accounts/abi/abigen/testdata/v2/overload.go.txt +++ b/accounts/abi/abigen/testdata/v2/overload.go.txt @@ -52,15 +52,23 @@ func (c *Overload) Instance(backend bind.ContractBackend, addr common.Address) b // Foo is a free data retrieval call binding the contract method 0x04bc52f8. // // Solidity: function foo(uint256 i, uint256 j) returns() -func (overload *Overload) PackFoo(I *big.Int, J *big.Int) ([]byte, error) { - return overload.abi.Pack("foo", I, J) +func (overload *Overload) PackFoo(I *big.Int, J *big.Int) []byte { + enc, err := overload.abi.Pack("foo", I, J) + if err != nil { + panic(err) + } + return enc } // Foo0 is a free data retrieval call binding the contract method 0x2fbebd38. // // Solidity: function foo(uint256 i) returns() -func (overload *Overload) PackFoo0(I *big.Int) ([]byte, error) { - return overload.abi.Pack("foo0", I) +func (overload *Overload) PackFoo0(I *big.Int) []byte { + enc, err := overload.abi.Pack("foo0", I) + if err != nil { + panic(err) + } + return enc } // OverloadBar represents a Bar event raised by the Overload contract. diff --git a/accounts/abi/abigen/testdata/v2/rangekeyword.go.txt b/accounts/abi/abigen/testdata/v2/rangekeyword.go.txt index acd90f02f0..100f7f5397 100644 --- a/accounts/abi/abigen/testdata/v2/rangekeyword.go.txt +++ b/accounts/abi/abigen/testdata/v2/rangekeyword.go.txt @@ -52,6 +52,10 @@ func (c *RangeKeyword) Instance(backend bind.ContractBackend, addr common.Addres // FunctionWithKeywordParameter is a free data retrieval call binding the contract method 0x527a119f. // // Solidity: function functionWithKeywordParameter(uint256 range) pure returns() -func (rangeKeyword *RangeKeyword) PackFunctionWithKeywordParameter(Arg0 *big.Int) ([]byte, error) { - return rangeKeyword.abi.Pack("functionWithKeywordParameter", Arg0) +func (rangeKeyword *RangeKeyword) PackFunctionWithKeywordParameter(Arg0 *big.Int) []byte { + enc, err := rangeKeyword.abi.Pack("functionWithKeywordParameter", Arg0) + if err != nil { + panic(err) + } + return enc } diff --git a/accounts/abi/abigen/testdata/v2/slicer.go.txt b/accounts/abi/abigen/testdata/v2/slicer.go.txt index 5b2e7add45..0f53fc9e2d 100644 --- a/accounts/abi/abigen/testdata/v2/slicer.go.txt +++ b/accounts/abi/abigen/testdata/v2/slicer.go.txt @@ -52,8 +52,12 @@ func (c *Slicer) Instance(backend bind.ContractBackend, addr common.Address) bin // EchoAddresses is a free data retrieval call binding the contract method 0xbe1127a3. // // Solidity: function echoAddresses(address[] input) returns(address[] output) -func (slicer *Slicer) PackEchoAddresses(Input []common.Address) ([]byte, error) { - return slicer.abi.Pack("echoAddresses", Input) +func (slicer *Slicer) PackEchoAddresses(Input []common.Address) []byte { + enc, err := slicer.abi.Pack("echoAddresses", Input) + if err != nil { + panic(err) + } + return enc } func (slicer *Slicer) UnpackEchoAddresses(data []byte) ([]common.Address, error) { @@ -72,8 +76,12 @@ func (slicer *Slicer) UnpackEchoAddresses(data []byte) ([]common.Address, error) // EchoBools is a free data retrieval call binding the contract method 0xf637e589. // // Solidity: function echoBools(bool[] input) returns(bool[] output) -func (slicer *Slicer) PackEchoBools(Input []bool) ([]byte, error) { - return slicer.abi.Pack("echoBools", Input) +func (slicer *Slicer) PackEchoBools(Input []bool) []byte { + enc, err := slicer.abi.Pack("echoBools", Input) + if err != nil { + panic(err) + } + return enc } func (slicer *Slicer) UnpackEchoBools(data []byte) ([]bool, error) { @@ -92,8 +100,12 @@ func (slicer *Slicer) UnpackEchoBools(data []byte) ([]bool, error) { // EchoFancyInts is a free data retrieval call binding the contract method 0xd88becc0. // // Solidity: function echoFancyInts(uint24[23] input) returns(uint24[23] output) -func (slicer *Slicer) PackEchoFancyInts(Input [23]*big.Int) ([]byte, error) { - return slicer.abi.Pack("echoFancyInts", Input) +func (slicer *Slicer) PackEchoFancyInts(Input [23]*big.Int) []byte { + enc, err := slicer.abi.Pack("echoFancyInts", Input) + if err != nil { + panic(err) + } + return enc } func (slicer *Slicer) UnpackEchoFancyInts(data []byte) ([23]*big.Int, error) { @@ -112,8 +124,12 @@ func (slicer *Slicer) UnpackEchoFancyInts(data []byte) ([23]*big.Int, error) { // EchoInts is a free data retrieval call binding the contract method 0xe15a3db7. // // Solidity: function echoInts(int256[] input) returns(int256[] output) -func (slicer *Slicer) PackEchoInts(Input []*big.Int) ([]byte, error) { - return slicer.abi.Pack("echoInts", Input) +func (slicer *Slicer) PackEchoInts(Input []*big.Int) []byte { + enc, err := slicer.abi.Pack("echoInts", Input) + if err != nil { + panic(err) + } + return enc } func (slicer *Slicer) UnpackEchoInts(data []byte) ([]*big.Int, error) { diff --git a/accounts/abi/abigen/testdata/v2/structs.go.txt b/accounts/abi/abigen/testdata/v2/structs.go.txt index 3ae5733807..7264568c21 100644 --- a/accounts/abi/abigen/testdata/v2/structs.go.txt +++ b/accounts/abi/abigen/testdata/v2/structs.go.txt @@ -57,8 +57,12 @@ func (c *Structs) Instance(backend bind.ContractBackend, addr common.Address) bi // F is a free data retrieval call binding the contract method 0x28811f59. // // Solidity: function F() view returns((bytes32)[] a, uint256[] c, bool[] d) -func (structs *Structs) PackF() ([]byte, error) { - return structs.abi.Pack("F") +func (structs *Structs) PackF() []byte { + enc, err := structs.abi.Pack("F") + if err != nil { + panic(err) + } + return enc } type FOutput struct { @@ -88,8 +92,12 @@ func (structs *Structs) UnpackF(data []byte) (FOutput, error) { // G is a free data retrieval call binding the contract method 0x6fecb623. // // Solidity: function G() view returns((bytes32)[] a) -func (structs *Structs) PackG() ([]byte, error) { - return structs.abi.Pack("G") +func (structs *Structs) PackG() []byte { + enc, err := structs.abi.Pack("G") + if err != nil { + panic(err) + } + return enc } func (structs *Structs) UnpackG(data []byte) ([]Struct0, error) { diff --git a/accounts/abi/abigen/testdata/v2/token.go.txt b/accounts/abi/abigen/testdata/v2/token.go.txt index 877e0b0f7c..13138df35d 100644 --- a/accounts/abi/abigen/testdata/v2/token.go.txt +++ b/accounts/abi/abigen/testdata/v2/token.go.txt @@ -50,15 +50,22 @@ func (c *Token) Instance(backend bind.ContractBackend, addr common.Address) bind } func (token *Token) PackConstructor(initialSupply *big.Int, tokenName string, decimalUnits uint8, tokenSymbol string) []byte { - res, _ := token.abi.Pack("", initialSupply, tokenName, decimalUnits, tokenSymbol) - return res + enc, err := token.abi.Pack("", initialSupply, tokenName, decimalUnits, tokenSymbol) + if err != nil { + panic(err) + } + return enc } // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. // // Solidity: function allowance(address , address ) returns(uint256) -func (token *Token) PackAllowance(Arg0 common.Address, Arg1 common.Address) ([]byte, error) { - return token.abi.Pack("allowance", Arg0, Arg1) +func (token *Token) PackAllowance(Arg0 common.Address, Arg1 common.Address) []byte { + enc, err := token.abi.Pack("allowance", Arg0, Arg1) + if err != nil { + panic(err) + } + return enc } func (token *Token) UnpackAllowance(data []byte) (*big.Int, error) { @@ -77,8 +84,12 @@ func (token *Token) UnpackAllowance(data []byte) (*big.Int, error) { // ApproveAndCall is a free data retrieval call binding the contract method 0xcae9ca51. // // Solidity: function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns(bool success) -func (token *Token) PackApproveAndCall(Spender common.Address, Value *big.Int, ExtraData []byte) ([]byte, error) { - return token.abi.Pack("approveAndCall", Spender, Value, ExtraData) +func (token *Token) PackApproveAndCall(Spender common.Address, Value *big.Int, ExtraData []byte) []byte { + enc, err := token.abi.Pack("approveAndCall", Spender, Value, ExtraData) + if err != nil { + panic(err) + } + return enc } func (token *Token) UnpackApproveAndCall(data []byte) (bool, error) { @@ -97,8 +108,12 @@ func (token *Token) UnpackApproveAndCall(data []byte) (bool, error) { // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. // // Solidity: function balanceOf(address ) returns(uint256) -func (token *Token) PackBalanceOf(Arg0 common.Address) ([]byte, error) { - return token.abi.Pack("balanceOf", Arg0) +func (token *Token) PackBalanceOf(Arg0 common.Address) []byte { + enc, err := token.abi.Pack("balanceOf", Arg0) + if err != nil { + panic(err) + } + return enc } func (token *Token) UnpackBalanceOf(data []byte) (*big.Int, error) { @@ -117,8 +132,12 @@ func (token *Token) UnpackBalanceOf(data []byte) (*big.Int, error) { // Decimals is a free data retrieval call binding the contract method 0x313ce567. // // Solidity: function decimals() returns(uint8) -func (token *Token) PackDecimals() ([]byte, error) { - return token.abi.Pack("decimals") +func (token *Token) PackDecimals() []byte { + enc, err := token.abi.Pack("decimals") + if err != nil { + panic(err) + } + return enc } func (token *Token) UnpackDecimals(data []byte) (uint8, error) { @@ -137,8 +156,12 @@ func (token *Token) UnpackDecimals(data []byte) (uint8, error) { // Name is a free data retrieval call binding the contract method 0x06fdde03. // // Solidity: function name() returns(string) -func (token *Token) PackName() ([]byte, error) { - return token.abi.Pack("name") +func (token *Token) PackName() []byte { + enc, err := token.abi.Pack("name") + if err != nil { + panic(err) + } + return enc } func (token *Token) UnpackName(data []byte) (string, error) { @@ -157,8 +180,12 @@ func (token *Token) UnpackName(data []byte) (string, error) { // SpentAllowance is a free data retrieval call binding the contract method 0xdc3080f2. // // Solidity: function spentAllowance(address , address ) returns(uint256) -func (token *Token) PackSpentAllowance(Arg0 common.Address, Arg1 common.Address) ([]byte, error) { - return token.abi.Pack("spentAllowance", Arg0, Arg1) +func (token *Token) PackSpentAllowance(Arg0 common.Address, Arg1 common.Address) []byte { + enc, err := token.abi.Pack("spentAllowance", Arg0, Arg1) + if err != nil { + panic(err) + } + return enc } func (token *Token) UnpackSpentAllowance(data []byte) (*big.Int, error) { @@ -177,8 +204,12 @@ func (token *Token) UnpackSpentAllowance(data []byte) (*big.Int, error) { // Symbol is a free data retrieval call binding the contract method 0x95d89b41. // // Solidity: function symbol() returns(string) -func (token *Token) PackSymbol() ([]byte, error) { - return token.abi.Pack("symbol") +func (token *Token) PackSymbol() []byte { + enc, err := token.abi.Pack("symbol") + if err != nil { + panic(err) + } + return enc } func (token *Token) UnpackSymbol(data []byte) (string, error) { @@ -197,15 +228,23 @@ func (token *Token) UnpackSymbol(data []byte) (string, error) { // Transfer is a free data retrieval call binding the contract method 0xa9059cbb. // // Solidity: function transfer(address _to, uint256 _value) returns() -func (token *Token) PackTransfer(To common.Address, Value *big.Int) ([]byte, error) { - return token.abi.Pack("transfer", To, Value) +func (token *Token) PackTransfer(To common.Address, Value *big.Int) []byte { + enc, err := token.abi.Pack("transfer", To, Value) + if err != nil { + panic(err) + } + return enc } // TransferFrom is a free data retrieval call binding the contract method 0x23b872dd. // // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success) -func (token *Token) PackTransferFrom(From common.Address, To common.Address, Value *big.Int) ([]byte, error) { - return token.abi.Pack("transferFrom", From, To, Value) +func (token *Token) PackTransferFrom(From common.Address, To common.Address, Value *big.Int) []byte { + enc, err := token.abi.Pack("transferFrom", From, To, Value) + if err != nil { + panic(err) + } + return enc } func (token *Token) UnpackTransferFrom(data []byte) (bool, error) { diff --git a/accounts/abi/abigen/testdata/v2/tuple.go.txt b/accounts/abi/abigen/testdata/v2/tuple.go.txt index 34eada17ae..e026a17593 100644 --- a/accounts/abi/abigen/testdata/v2/tuple.go.txt +++ b/accounts/abi/abigen/testdata/v2/tuple.go.txt @@ -77,8 +77,12 @@ func (c *Tuple) Instance(backend bind.ContractBackend, addr common.Address) bind // Func1 is a free data retrieval call binding the contract method 0x443c79b4. // // Solidity: function func1((uint256,uint256[],(uint256,uint256)[]) a, (uint256,uint256)[2][] b, (uint256,uint256)[][2] c, (uint256,uint256[],(uint256,uint256)[])[] d, uint256[] e) pure returns((uint256,uint256[],(uint256,uint256)[]), (uint256,uint256)[2][], (uint256,uint256)[][2], (uint256,uint256[],(uint256,uint256)[])[], uint256[]) -func (tuple *Tuple) PackFunc1(A TupleS, B [][2]TupleT, C [2][]TupleT, D []TupleS, E []*big.Int) ([]byte, error) { - return tuple.abi.Pack("func1", A, B, C, D, E) +func (tuple *Tuple) PackFunc1(A TupleS, B [][2]TupleT, C [2][]TupleT, D []TupleS, E []*big.Int) []byte { + enc, err := tuple.abi.Pack("func1", A, B, C, D, E) + if err != nil { + panic(err) + } + return enc } type Func1Output struct { @@ -114,15 +118,23 @@ func (tuple *Tuple) UnpackFunc1(data []byte) (Func1Output, error) { // Func2 is a free data retrieval call binding the contract method 0xd0062cdd. // // Solidity: function func2((uint256,uint256[],(uint256,uint256)[]) a, (uint256,uint256)[2][] b, (uint256,uint256)[][2] c, (uint256,uint256[],(uint256,uint256)[])[] d, uint256[] e) returns() -func (tuple *Tuple) PackFunc2(A TupleS, B [][2]TupleT, C [2][]TupleT, D []TupleS, E []*big.Int) ([]byte, error) { - return tuple.abi.Pack("func2", A, B, C, D, E) +func (tuple *Tuple) PackFunc2(A TupleS, B [][2]TupleT, C [2][]TupleT, D []TupleS, E []*big.Int) []byte { + enc, err := tuple.abi.Pack("func2", A, B, C, D, E) + if err != nil { + panic(err) + } + return enc } // Func3 is a free data retrieval call binding the contract method 0xe4d9a43b. // // Solidity: function func3((uint16,uint16)[] ) pure returns() -func (tuple *Tuple) PackFunc3(Arg0 []TupleQ) ([]byte, error) { - return tuple.abi.Pack("func3", Arg0) +func (tuple *Tuple) PackFunc3(Arg0 []TupleQ) []byte { + enc, err := tuple.abi.Pack("func3", Arg0) + if err != nil { + panic(err) + } + return enc } // TupleTupleEvent represents a TupleEvent event raised by the Tuple contract. diff --git a/accounts/abi/abigen/testdata/v2/tupler.go.txt b/accounts/abi/abigen/testdata/v2/tupler.go.txt index 874affd6b8..1a8cdc5816 100644 --- a/accounts/abi/abigen/testdata/v2/tupler.go.txt +++ b/accounts/abi/abigen/testdata/v2/tupler.go.txt @@ -52,8 +52,12 @@ func (c *Tupler) Instance(backend bind.ContractBackend, addr common.Address) bin // Tuple is a free data retrieval call binding the contract method 0x3175aae2. // // Solidity: function tuple() returns(string a, int256 b, bytes32 c) -func (tupler *Tupler) PackTuple() ([]byte, error) { - return tupler.abi.Pack("tuple") +func (tupler *Tupler) PackTuple() []byte { + enc, err := tupler.abi.Pack("tuple") + if err != nil { + panic(err) + } + return enc } type TupleOutput struct { diff --git a/accounts/abi/abigen/testdata/v2/underscorer.go.txt b/accounts/abi/abigen/testdata/v2/underscorer.go.txt index 1cd99962e9..cdaef62923 100644 --- a/accounts/abi/abigen/testdata/v2/underscorer.go.txt +++ b/accounts/abi/abigen/testdata/v2/underscorer.go.txt @@ -52,8 +52,12 @@ func (c *Underscorer) Instance(backend bind.ContractBackend, addr common.Address // AllPurelyUnderscoredOutput is a free data retrieval call binding the contract method 0xb564b34d. // // Solidity: function AllPurelyUnderscoredOutput() view returns(int256 _, int256 __) -func (underscorer *Underscorer) PackAllPurelyUnderscoredOutput() ([]byte, error) { - return underscorer.abi.Pack("AllPurelyUnderscoredOutput") +func (underscorer *Underscorer) PackAllPurelyUnderscoredOutput() []byte { + enc, err := underscorer.abi.Pack("AllPurelyUnderscoredOutput") + if err != nil { + panic(err) + } + return enc } type AllPurelyUnderscoredOutputOutput struct { @@ -80,8 +84,12 @@ func (underscorer *Underscorer) UnpackAllPurelyUnderscoredOutput(data []byte) (A // LowerLowerCollision is a free data retrieval call binding the contract method 0xe409ca45. // // Solidity: function LowerLowerCollision() view returns(int256 _res, int256 res) -func (underscorer *Underscorer) PackLowerLowerCollision() ([]byte, error) { - return underscorer.abi.Pack("LowerLowerCollision") +func (underscorer *Underscorer) PackLowerLowerCollision() []byte { + enc, err := underscorer.abi.Pack("LowerLowerCollision") + if err != nil { + panic(err) + } + return enc } type LowerLowerCollisionOutput struct { @@ -108,8 +116,12 @@ func (underscorer *Underscorer) UnpackLowerLowerCollision(data []byte) (LowerLow // LowerUpperCollision is a free data retrieval call binding the contract method 0x03a59213. // // Solidity: function LowerUpperCollision() view returns(int256 _res, int256 Res) -func (underscorer *Underscorer) PackLowerUpperCollision() ([]byte, error) { - return underscorer.abi.Pack("LowerUpperCollision") +func (underscorer *Underscorer) PackLowerUpperCollision() []byte { + enc, err := underscorer.abi.Pack("LowerUpperCollision") + if err != nil { + panic(err) + } + return enc } type LowerUpperCollisionOutput struct { @@ -136,8 +148,12 @@ func (underscorer *Underscorer) UnpackLowerUpperCollision(data []byte) (LowerUpp // PurelyUnderscoredOutput is a free data retrieval call binding the contract method 0x9df48485. // // Solidity: function PurelyUnderscoredOutput() view returns(int256 _, int256 res) -func (underscorer *Underscorer) PackPurelyUnderscoredOutput() ([]byte, error) { - return underscorer.abi.Pack("PurelyUnderscoredOutput") +func (underscorer *Underscorer) PackPurelyUnderscoredOutput() []byte { + enc, err := underscorer.abi.Pack("PurelyUnderscoredOutput") + if err != nil { + panic(err) + } + return enc } type PurelyUnderscoredOutputOutput struct { @@ -164,8 +180,12 @@ func (underscorer *Underscorer) UnpackPurelyUnderscoredOutput(data []byte) (Pure // UnderscoredOutput is a free data retrieval call binding the contract method 0x67e6633d. // // Solidity: function UnderscoredOutput() view returns(int256 _int, string _string) -func (underscorer *Underscorer) PackUnderscoredOutput() ([]byte, error) { - return underscorer.abi.Pack("UnderscoredOutput") +func (underscorer *Underscorer) PackUnderscoredOutput() []byte { + enc, err := underscorer.abi.Pack("UnderscoredOutput") + if err != nil { + panic(err) + } + return enc } type UnderscoredOutputOutput struct { @@ -192,8 +212,12 @@ func (underscorer *Underscorer) UnpackUnderscoredOutput(data []byte) (Underscore // UpperLowerCollision is a free data retrieval call binding the contract method 0xaf7486ab. // // Solidity: function UpperLowerCollision() view returns(int256 _Res, int256 res) -func (underscorer *Underscorer) PackUpperLowerCollision() ([]byte, error) { - return underscorer.abi.Pack("UpperLowerCollision") +func (underscorer *Underscorer) PackUpperLowerCollision() []byte { + enc, err := underscorer.abi.Pack("UpperLowerCollision") + if err != nil { + panic(err) + } + return enc } type UpperLowerCollisionOutput struct { @@ -220,8 +244,12 @@ func (underscorer *Underscorer) UnpackUpperLowerCollision(data []byte) (UpperLow // UpperUpperCollision is a free data retrieval call binding the contract method 0xe02ab24d. // // Solidity: function UpperUpperCollision() view returns(int256 _Res, int256 Res) -func (underscorer *Underscorer) PackUpperUpperCollision() ([]byte, error) { - return underscorer.abi.Pack("UpperUpperCollision") +func (underscorer *Underscorer) PackUpperUpperCollision() []byte { + enc, err := underscorer.abi.Pack("UpperUpperCollision") + if err != nil { + panic(err) + } + return enc } type UpperUpperCollisionOutput struct { @@ -248,8 +276,12 @@ func (underscorer *Underscorer) UnpackUpperUpperCollision(data []byte) (UpperUpp // UnderScoredFunc is a free data retrieval call binding the contract method 0x46546dbe. // // Solidity: function _under_scored_func() view returns(int256 _int) -func (underscorer *Underscorer) PackUnderScoredFunc() ([]byte, error) { - return underscorer.abi.Pack("_under_scored_func") +func (underscorer *Underscorer) PackUnderScoredFunc() []byte { + enc, err := underscorer.abi.Pack("_under_scored_func") + if err != nil { + panic(err) + } + return enc } func (underscorer *Underscorer) UnpackUnderScoredFunc(data []byte) (*big.Int, error) { diff --git a/accounts/abi/bind/v2/internal/contracts/db/bindings.go b/accounts/abi/bind/v2/internal/contracts/db/bindings.go index a18c56a8ae..11c4790aad 100644 --- a/accounts/abi/bind/v2/internal/contracts/db/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/db/bindings.go @@ -59,8 +59,12 @@ func (c *DB) Instance(backend bind.ContractBackend, addr common.Address) bind.Co // Get is a free data retrieval call binding the contract method 0x9507d39a. // // Solidity: function get(uint256 k) returns(uint256) -func (dB *DB) PackGet(K *big.Int) ([]byte, error) { - return dB.abi.Pack("get", K) +func (dB *DB) PackGet(K *big.Int) []byte { + enc, err := dB.abi.Pack("get", K) + if err != nil { + panic(err) + } + return enc } func (dB *DB) UnpackGet(data []byte) (*big.Int, error) { @@ -79,8 +83,12 @@ func (dB *DB) UnpackGet(data []byte) (*big.Int, error) { // GetNamedStatParams is a free data retrieval call binding the contract method 0xe369ba3b. // // Solidity: function getNamedStatParams() view returns(uint256 gets, uint256 inserts, uint256 mods) -func (dB *DB) PackGetNamedStatParams() ([]byte, error) { - return dB.abi.Pack("getNamedStatParams") +func (dB *DB) PackGetNamedStatParams() []byte { + enc, err := dB.abi.Pack("getNamedStatParams") + if err != nil { + panic(err) + } + return enc } type GetNamedStatParamsOutput struct { @@ -110,8 +118,12 @@ func (dB *DB) UnpackGetNamedStatParams(data []byte) (GetNamedStatParamsOutput, e // GetStatParams is a free data retrieval call binding the contract method 0x6fcb9c70. // // Solidity: function getStatParams() view returns(uint256, uint256, uint256) -func (dB *DB) PackGetStatParams() ([]byte, error) { - return dB.abi.Pack("getStatParams") +func (dB *DB) PackGetStatParams() []byte { + enc, err := dB.abi.Pack("getStatParams") + if err != nil { + panic(err) + } + return enc } type GetStatParamsOutput struct { @@ -141,8 +153,12 @@ func (dB *DB) UnpackGetStatParams(data []byte) (GetStatParamsOutput, error) { // GetStatsStruct is a free data retrieval call binding the contract method 0xee8161e0. // // Solidity: function getStatsStruct() view returns((uint256,uint256,uint256)) -func (dB *DB) PackGetStatsStruct() ([]byte, error) { - return dB.abi.Pack("getStatsStruct") +func (dB *DB) PackGetStatsStruct() []byte { + enc, err := dB.abi.Pack("getStatsStruct") + if err != nil { + panic(err) + } + return enc } func (dB *DB) UnpackGetStatsStruct(data []byte) (DBStats, error) { @@ -161,8 +177,12 @@ func (dB *DB) UnpackGetStatsStruct(data []byte) (DBStats, error) { // Insert is a free data retrieval call binding the contract method 0x1d834a1b. // // Solidity: function insert(uint256 k, uint256 v) returns(uint256) -func (dB *DB) PackInsert(K *big.Int, V *big.Int) ([]byte, error) { - return dB.abi.Pack("insert", K, V) +func (dB *DB) PackInsert(K *big.Int, V *big.Int) []byte { + enc, err := dB.abi.Pack("insert", K, V) + if err != nil { + panic(err) + } + return enc } func (dB *DB) UnpackInsert(data []byte) (*big.Int, error) { diff --git a/accounts/abi/bind/v2/internal/contracts/events/bindings.go b/accounts/abi/bind/v2/internal/contracts/events/bindings.go index 109cf5fd54..01191b45a0 100644 --- a/accounts/abi/bind/v2/internal/contracts/events/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/events/bindings.go @@ -58,8 +58,12 @@ func (c *C) Instance(backend bind.ContractBackend, addr common.Address) bind.Con // DoSomethingWithManyArgs is a free data retrieval call binding the contract method 0x6fd8b968. // // Solidity: function DoSomethingWithManyArgs() pure returns(uint256, uint256, uint256, bool) -func (c *C) PackDoSomethingWithManyArgs() ([]byte, error) { - return c.abi.Pack("DoSomethingWithManyArgs") +func (c *C) PackDoSomethingWithManyArgs() []byte { + enc, err := c.abi.Pack("DoSomethingWithManyArgs") + if err != nil { + panic(err) + } + return enc } type DoSomethingWithManyArgsOutput struct { @@ -92,8 +96,12 @@ func (c *C) UnpackDoSomethingWithManyArgs(data []byte) (DoSomethingWithManyArgsO // DoSomethingWithPoint is a free data retrieval call binding the contract method 0xedcdc894. // // Solidity: function DoSomethingWithPoint((uint256,uint256) p) pure returns((uint256,uint256)) -func (c *C) PackDoSomethingWithPoint(P CPoint) ([]byte, error) { - return c.abi.Pack("DoSomethingWithPoint", P) +func (c *C) PackDoSomethingWithPoint(P CPoint) []byte { + enc, err := c.abi.Pack("DoSomethingWithPoint", P) + if err != nil { + panic(err) + } + return enc } func (c *C) UnpackDoSomethingWithPoint(data []byte) (CPoint, error) { @@ -112,15 +120,23 @@ func (c *C) UnpackDoSomethingWithPoint(data []byte) (CPoint, error) { // EmitMulti is a free data retrieval call binding the contract method 0xcb493749. // // Solidity: function EmitMulti() returns() -func (c *C) PackEmitMulti() ([]byte, error) { - return c.abi.Pack("EmitMulti") +func (c *C) PackEmitMulti() []byte { + enc, err := c.abi.Pack("EmitMulti") + if err != nil { + panic(err) + } + return enc } // EmitOne is a free data retrieval call binding the contract method 0xe8e49a71. // // Solidity: function EmitOne() returns() -func (c *C) PackEmitOne() ([]byte, error) { - return c.abi.Pack("EmitOne") +func (c *C) PackEmitOne() []byte { + enc, err := c.abi.Pack("EmitOne") + if err != nil { + panic(err) + } + return enc } // CBasic1 represents a Basic1 event raised by the C contract. diff --git a/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go b/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go index ba0fab826e..4394857f87 100644 --- a/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/nested_libraries/bindings.go @@ -54,15 +54,22 @@ func (c *C1) Instance(backend bind.ContractBackend, addr common.Address) bind.Co } func (c1 *C1) PackConstructor(v1 *big.Int, v2 *big.Int) []byte { - res, _ := c1.abi.Pack("", v1, v2) - return res + enc, err := c1.abi.Pack("", v1, v2) + if err != nil { + panic(err) + } + return enc } // Do is a free data retrieval call binding the contract method 0x2ad11272. // // Solidity: function Do(uint256 val) pure returns(uint256 res) -func (c1 *C1) PackDo(Val *big.Int) ([]byte, error) { - return c1.abi.Pack("Do", Val) +func (c1 *C1) PackDo(Val *big.Int) []byte { + enc, err := c1.abi.Pack("Do", Val) + if err != nil { + panic(err) + } + return enc } func (c1 *C1) UnpackDo(data []byte) (*big.Int, error) { @@ -110,15 +117,22 @@ func (c *C2) Instance(backend bind.ContractBackend, addr common.Address) bind.Co } func (c2 *C2) PackConstructor(v1 *big.Int, v2 *big.Int) []byte { - res, _ := c2.abi.Pack("", v1, v2) - return res + enc, err := c2.abi.Pack("", v1, v2) + if err != nil { + panic(err) + } + return enc } // Do is a free data retrieval call binding the contract method 0x2ad11272. // // Solidity: function Do(uint256 val) pure returns(uint256 res) -func (c2 *C2) PackDo(Val *big.Int) ([]byte, error) { - return c2.abi.Pack("Do", Val) +func (c2 *C2) PackDo(Val *big.Int) []byte { + enc, err := c2.abi.Pack("Do", Val) + if err != nil { + panic(err) + } + return enc } func (c2 *C2) UnpackDo(data []byte) (*big.Int, error) { @@ -164,8 +178,12 @@ func (c *L1) Instance(backend bind.ContractBackend, addr common.Address) bind.Co // Do is a free data retrieval call binding the contract method 0x2ad11272. // // Solidity: function Do(uint256 val) pure returns(uint256) -func (l1 *L1) PackDo(Val *big.Int) ([]byte, error) { - return l1.abi.Pack("Do", Val) +func (l1 *L1) PackDo(Val *big.Int) []byte { + enc, err := l1.abi.Pack("Do", Val) + if err != nil { + panic(err) + } + return enc } func (l1 *L1) UnpackDo(data []byte) (*big.Int, error) { @@ -214,8 +232,12 @@ func (c *L2) Instance(backend bind.ContractBackend, addr common.Address) bind.Co // Do is a free data retrieval call binding the contract method 0x2ad11272. // // Solidity: function Do(uint256 val) pure returns(uint256) -func (l2 *L2) PackDo(Val *big.Int) ([]byte, error) { - return l2.abi.Pack("Do", Val) +func (l2 *L2) PackDo(Val *big.Int) []byte { + enc, err := l2.abi.Pack("Do", Val) + if err != nil { + panic(err) + } + return enc } func (l2 *L2) UnpackDo(data []byte) (*big.Int, error) { @@ -264,8 +286,12 @@ func (c *L2b) Instance(backend bind.ContractBackend, addr common.Address) bind.C // Do is a free data retrieval call binding the contract method 0x2ad11272. // // Solidity: function Do(uint256 val) pure returns(uint256) -func (l2b *L2b) PackDo(Val *big.Int) ([]byte, error) { - return l2b.abi.Pack("Do", Val) +func (l2b *L2b) PackDo(Val *big.Int) []byte { + enc, err := l2b.abi.Pack("Do", Val) + if err != nil { + panic(err) + } + return enc } func (l2b *L2b) UnpackDo(data []byte) (*big.Int, error) { @@ -311,8 +337,12 @@ func (c *L3) Instance(backend bind.ContractBackend, addr common.Address) bind.Co // Do is a free data retrieval call binding the contract method 0x2ad11272. // // Solidity: function Do(uint256 val) pure returns(uint256) -func (l3 *L3) PackDo(Val *big.Int) ([]byte, error) { - return l3.abi.Pack("Do", Val) +func (l3 *L3) PackDo(Val *big.Int) []byte { + enc, err := l3.abi.Pack("Do", Val) + if err != nil { + panic(err) + } + return enc } func (l3 *L3) UnpackDo(data []byte) (*big.Int, error) { @@ -362,8 +392,12 @@ func (c *L4) Instance(backend bind.ContractBackend, addr common.Address) bind.Co // Do is a free data retrieval call binding the contract method 0x2ad11272. // // Solidity: function Do(uint256 val) pure returns(uint256) -func (l4 *L4) PackDo(Val *big.Int) ([]byte, error) { - return l4.abi.Pack("Do", Val) +func (l4 *L4) PackDo(Val *big.Int) []byte { + enc, err := l4.abi.Pack("Do", Val) + if err != nil { + panic(err) + } + return enc } func (l4 *L4) UnpackDo(data []byte) (*big.Int, error) { @@ -412,8 +446,12 @@ func (c *L4b) Instance(backend bind.ContractBackend, addr common.Address) bind.C // Do is a free data retrieval call binding the contract method 0x2ad11272. // // Solidity: function Do(uint256 val) pure returns(uint256) -func (l4b *L4b) PackDo(Val *big.Int) ([]byte, error) { - return l4b.abi.Pack("Do", Val) +func (l4b *L4b) PackDo(Val *big.Int) []byte { + enc, err := l4b.abi.Pack("Do", Val) + if err != nil { + panic(err) + } + return enc } func (l4b *L4b) UnpackDo(data []byte) (*big.Int, error) { diff --git a/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go b/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go index 11c5856369..4dfd195099 100644 --- a/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/solc_errors/bindings.go @@ -52,15 +52,23 @@ func (c *C) Instance(backend bind.ContractBackend, addr common.Address) bind.Con // Bar is a free data retrieval call binding the contract method 0xb0a378b0. // // Solidity: function Bar() pure returns() -func (c *C) PackBar() ([]byte, error) { - return c.abi.Pack("Bar") +func (c *C) PackBar() []byte { + enc, err := c.abi.Pack("Bar") + if err != nil { + panic(err) + } + return enc } // Foo is a free data retrieval call binding the contract method 0xbfb4ebcf. // // Solidity: function Foo() pure returns() -func (c *C) PackFoo() ([]byte, error) { - return c.abi.Pack("Foo") +func (c *C) PackFoo() []byte { + enc, err := c.abi.Pack("Foo") + if err != nil { + panic(err) + } + return enc } func (c *C) UnpackError(raw []byte) any { @@ -150,8 +158,12 @@ func (c *C2) Instance(backend bind.ContractBackend, addr common.Address) bind.Co // Foo is a free data retrieval call binding the contract method 0xbfb4ebcf. // // Solidity: function Foo() pure returns() -func (c2 *C2) PackFoo() ([]byte, error) { - return c2.abi.Pack("Foo") +func (c2 *C2) PackFoo() []byte { + enc, err := c2.abi.Pack("Foo") + if err != nil { + panic(err) + } + return enc } func (c2 *C2) UnpackError(raw []byte) any { diff --git a/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/bindings.go b/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/bindings.go index b23cf3ae6d..2586a406f5 100644 --- a/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/bindings.go +++ b/accounts/abi/bind/v2/internal/contracts/uint256arrayreturn/bindings.go @@ -52,8 +52,12 @@ func (c *MyContract) Instance(backend bind.ContractBackend, addr common.Address) // GetNums is a free data retrieval call binding the contract method 0xbd6d1007. // // Solidity: function GetNums() pure returns(uint256[5]) -func (myContract *MyContract) PackGetNums() ([]byte, error) { - return myContract.abi.Pack("GetNums") +func (myContract *MyContract) PackGetNums() []byte { + enc, err := myContract.abi.Pack("GetNums") + if err != nil { + panic(err) + } + return enc } func (myContract *MyContract) UnpackGetNums(data []byte) ([5]*big.Int, error) {