mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2025-01-18 08:38:46 +00:00
cc74e74a60
This request is extending the devnet functionality to more fully handle contract processing by adding support for the following calls: * trace_call, * trace_transaction * debug_accountAt, * eth_getCode * eth_estimateGas * eth_gasPrice It also contains an initial rationalization of the devnet subscription code to use the erigon client code directly rather than using its own intermediate subscription management. This is used to implement a general purpose block waiter - which can be used in any scenario step - rather than being specific to transaction processing. This pull also contains an end to end tested sync processor for bor and associated support services: * Heimdall (supports sync event transfer) * Faucet - allows the creation and funding of arbitary test specific accounts (cross chain) Notes and Caveats: * Code generation for contracts requires `--evm-version paris`. For chains which don't support push0 for solc over 0.8.19 * The bor log processing post the application of sync events causes a panic - this will be the subject of a seperate smaller push as it is not devnet specific * The bor code seems to make repeated calls for the same sync events and also reverts requests - this needs further investigation. This is the behaviour of the current implementation and may be required - although it does seem to generate repeat processing - which could be avoided.
605 lines
24 KiB
Go
605 lines
24 KiB
Go
// Code generated - DO NOT EDIT.
|
|
// This file is a generated binding and any manual changes will be lost.
|
|
|
|
package contracts
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
"reflect"
|
|
"strings"
|
|
|
|
ethereum "github.com/ledgerwatch/erigon"
|
|
libcommon "github.com/ledgerwatch/erigon-lib/common"
|
|
"github.com/ledgerwatch/erigon/accounts/abi"
|
|
"github.com/ledgerwatch/erigon/accounts/abi/bind"
|
|
"github.com/ledgerwatch/erigon/core/types"
|
|
"github.com/ledgerwatch/erigon/event"
|
|
)
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var (
|
|
_ = big.NewInt
|
|
_ = strings.NewReader
|
|
_ = ethereum.NotFound
|
|
_ = bind.Bind
|
|
_ = libcommon.Big1
|
|
_ = types.BloomLookup
|
|
_ = event.NewSubscription
|
|
)
|
|
|
|
// FaucetABI is the input ABI used to generate the binding from.
|
|
const FaucetABI = "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_source\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"received\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"sent\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"destinations\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"addresspayable\",\"name\":\"_destination\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_requested\",\"type\":\"uint256\"}],\"name\":\"send\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"sources\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]"
|
|
|
|
// FaucetBin is the compiled bytecode used for deploying new contracts.
|
|
var FaucetBin = "0x608060405234801561001057600080fd5b506102ea806100206000396000f3fe6080604052600436106100385760003560e01c806359c02c37146100a0578063b750bdde146100df578063d0679d341461010c57600080fd5b3661009b57336000908152602081905260408120805434929061005c908490610225565b9091555050604080513381523460208201527ff11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef910160405180910390a1005b600080fd5b3480156100ac57600080fd5b506100cd6100bb366004610264565b60016020526000908152604090205481565b60405190815260200160405180910390f35b3480156100eb57600080fd5b506100cd6100fa366004610264565b60006020819052908152604090205481565b61011f61011a366004610288565b610121565b005b4760000361012d575050565b600081471115610176575060405181906001600160a01b0384169082156108fc029083906000818181858888f19350505050158015610170573d6000803e3d6000fd5b506101b1565b5060405147906001600160a01b0384169082156108fc029083906000818181858888f193505050501580156101af573d6000803e3d6000fd5b505b6001600160a01b038316600090815260016020526040812080548392906101d9908490610225565b9091555050604080516001600160a01b0385168152602081018390527f3bcb2e664d8f57273201bc888e82d6549f8308a52a9fcd7702b2ea8387f769a9910160405180910390a1505050565b8082018082111561024657634e487b7160e01b600052601160045260246000fd5b92915050565b6001600160a01b038116811461026157600080fd5b50565b60006020828403121561027657600080fd5b81356102818161024c565b9392505050565b6000806040838503121561029b57600080fd5b82356102a68161024c565b94602093909301359350505056fea2646970667358221220ac81b3f12efbe2860b7a5f00b56a253c6661d9ad6df22e642da3546e0015e9d664736f6c63430008140033"
|
|
|
|
// DeployFaucet deploys a new Ethereum contract, binding an instance of Faucet to it.
|
|
func DeployFaucet(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Faucet, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(FaucetABI))
|
|
if err != nil {
|
|
return libcommon.Address{}, nil, nil, err
|
|
}
|
|
|
|
address, tx, contract, err := bind.DeployContract(auth, parsed, libcommon.FromHex(FaucetBin), backend)
|
|
if err != nil {
|
|
return libcommon.Address{}, nil, nil, err
|
|
}
|
|
return address, tx, &Faucet{FaucetCaller: FaucetCaller{contract: contract}, FaucetTransactor: FaucetTransactor{contract: contract}, FaucetFilterer: FaucetFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// Faucet is an auto generated Go binding around an Ethereum contract.
|
|
type Faucet struct {
|
|
FaucetCaller // Read-only binding to the contract
|
|
FaucetTransactor // Write-only binding to the contract
|
|
FaucetFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// FaucetCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type FaucetCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// FaucetTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type FaucetTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// FaucetFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type FaucetFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// FaucetSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type FaucetSession struct {
|
|
Contract *Faucet // Generic contract binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// FaucetCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type FaucetCallerSession struct {
|
|
Contract *FaucetCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// FaucetTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type FaucetTransactorSession struct {
|
|
Contract *FaucetTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// FaucetRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type FaucetRaw struct {
|
|
Contract *Faucet // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// FaucetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type FaucetCallerRaw struct {
|
|
Contract *FaucetCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// FaucetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type FaucetTransactorRaw struct {
|
|
Contract *FaucetTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewFaucet creates a new instance of Faucet, bound to a specific deployed contract.
|
|
func NewFaucet(address libcommon.Address, backend bind.ContractBackend) (*Faucet, error) {
|
|
contract, err := bindFaucet(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Faucet{FaucetCaller: FaucetCaller{contract: contract}, FaucetTransactor: FaucetTransactor{contract: contract}, FaucetFilterer: FaucetFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewFaucetCaller creates a new read-only instance of Faucet, bound to a specific deployed contract.
|
|
func NewFaucetCaller(address libcommon.Address, caller bind.ContractCaller) (*FaucetCaller, error) {
|
|
contract, err := bindFaucet(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &FaucetCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewFaucetTransactor creates a new write-only instance of Faucet, bound to a specific deployed contract.
|
|
func NewFaucetTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*FaucetTransactor, error) {
|
|
contract, err := bindFaucet(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &FaucetTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewFaucetFilterer creates a new log filterer instance of Faucet, bound to a specific deployed contract.
|
|
func NewFaucetFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*FaucetFilterer, error) {
|
|
contract, err := bindFaucet(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &FaucetFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindFaucet binds a generic wrapper to an already deployed contract.
|
|
func bindFaucet(address libcommon.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(FaucetABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// Call invokes the (constant) contract method with params as input values and
|
|
// sets the output to result. The result type might be a single field for simple
|
|
// returns, a slice of interfaces for anonymous returns and a struct for named
|
|
// returns.
|
|
func (_Faucet *FaucetRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _Faucet.Contract.FaucetCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_Faucet *FaucetRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error) {
|
|
return _Faucet.Contract.FaucetTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_Faucet *FaucetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error) {
|
|
return _Faucet.Contract.FaucetTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// Call invokes the (constant) contract method with params as input values and
|
|
// sets the output to result. The result type might be a single field for simple
|
|
// returns, a slice of interfaces for anonymous returns and a struct for named
|
|
// returns.
|
|
func (_Faucet *FaucetCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _Faucet.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_Faucet *FaucetTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error) {
|
|
return _Faucet.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_Faucet *FaucetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error) {
|
|
return _Faucet.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// Destinations is a free data retrieval call binding the contract method 0x59c02c37.
|
|
//
|
|
// Solidity: function destinations(address ) view returns(uint256)
|
|
func (_Faucet *FaucetCaller) Destinations(opts *bind.CallOpts, arg0 libcommon.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _Faucet.contract.Call(opts, &out, "destinations", arg0)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Destinations is a free data retrieval call binding the contract method 0x59c02c37.
|
|
//
|
|
// Solidity: function destinations(address ) view returns(uint256)
|
|
func (_Faucet *FaucetSession) Destinations(arg0 libcommon.Address) (*big.Int, error) {
|
|
return _Faucet.Contract.Destinations(&_Faucet.CallOpts, arg0)
|
|
}
|
|
|
|
// Destinations is a free data retrieval call binding the contract method 0x59c02c37.
|
|
//
|
|
// Solidity: function destinations(address ) view returns(uint256)
|
|
func (_Faucet *FaucetCallerSession) Destinations(arg0 libcommon.Address) (*big.Int, error) {
|
|
return _Faucet.Contract.Destinations(&_Faucet.CallOpts, arg0)
|
|
}
|
|
|
|
// Sources is a free data retrieval call binding the contract method 0xb750bdde.
|
|
//
|
|
// Solidity: function sources(address ) view returns(uint256)
|
|
func (_Faucet *FaucetCaller) Sources(opts *bind.CallOpts, arg0 libcommon.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _Faucet.contract.Call(opts, &out, "sources", arg0)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Sources is a free data retrieval call binding the contract method 0xb750bdde.
|
|
//
|
|
// Solidity: function sources(address ) view returns(uint256)
|
|
func (_Faucet *FaucetSession) Sources(arg0 libcommon.Address) (*big.Int, error) {
|
|
return _Faucet.Contract.Sources(&_Faucet.CallOpts, arg0)
|
|
}
|
|
|
|
// Sources is a free data retrieval call binding the contract method 0xb750bdde.
|
|
//
|
|
// Solidity: function sources(address ) view returns(uint256)
|
|
func (_Faucet *FaucetCallerSession) Sources(arg0 libcommon.Address) (*big.Int, error) {
|
|
return _Faucet.Contract.Sources(&_Faucet.CallOpts, arg0)
|
|
}
|
|
|
|
// Send is a paid mutator transaction binding the contract method 0xd0679d34.
|
|
//
|
|
// Solidity: function send(address _destination, uint256 _requested) payable returns()
|
|
func (_Faucet *FaucetTransactor) Send(opts *bind.TransactOpts, _destination libcommon.Address, _requested *big.Int) (types.Transaction, error) {
|
|
return _Faucet.contract.Transact(opts, "send", _destination, _requested)
|
|
}
|
|
|
|
// Send is a paid mutator transaction binding the contract method 0xd0679d34.
|
|
//
|
|
// Solidity: function send(address _destination, uint256 _requested) payable returns()
|
|
func (_Faucet *FaucetSession) Send(_destination libcommon.Address, _requested *big.Int) (types.Transaction, error) {
|
|
return _Faucet.Contract.Send(&_Faucet.TransactOpts, _destination, _requested)
|
|
}
|
|
|
|
// Send is a paid mutator transaction binding the contract method 0xd0679d34.
|
|
//
|
|
// Solidity: function send(address _destination, uint256 _requested) payable returns()
|
|
func (_Faucet *FaucetTransactorSession) Send(_destination libcommon.Address, _requested *big.Int) (types.Transaction, error) {
|
|
return _Faucet.Contract.Send(&_Faucet.TransactOpts, _destination, _requested)
|
|
}
|
|
|
|
// SendParams is an auto generated read-only Go binding of transcaction calldata params
|
|
type SendParams struct {
|
|
Param__destination libcommon.Address
|
|
Param__requested *big.Int
|
|
}
|
|
|
|
// Parse Send method from calldata of a transaction
|
|
//
|
|
// Solidity: function send(address _destination, uint256 _requested) payable returns()
|
|
func ParseSend(calldata []byte) (*SendParams, error) {
|
|
if len(calldata) <= 4 {
|
|
return nil, fmt.Errorf("invalid calldata input")
|
|
}
|
|
|
|
_abi, err := abi.JSON(strings.NewReader(FaucetABI))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get abi of registry metadata: %w", err)
|
|
}
|
|
|
|
out, err := _abi.Methods["send"].Inputs.Unpack(calldata[4:])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to unpack send params data: %w", err)
|
|
}
|
|
|
|
var paramsResult = new(SendParams)
|
|
value := reflect.ValueOf(paramsResult).Elem()
|
|
|
|
if value.NumField() != len(out) {
|
|
return nil, fmt.Errorf("failed to match calldata with param field number")
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(libcommon.Address)).(*libcommon.Address)
|
|
out1 := *abi.ConvertType(out[1], new(*big.Int)).(**big.Int)
|
|
|
|
return &SendParams{
|
|
Param__destination: out0, Param__requested: out1,
|
|
}, nil
|
|
}
|
|
|
|
// Receive is a paid mutator transaction binding the contract receive function.
|
|
//
|
|
// Solidity: receive() payable returns()
|
|
func (_Faucet *FaucetTransactor) Receive(opts *bind.TransactOpts) (types.Transaction, error) {
|
|
return _Faucet.contract.RawTransact(opts, nil) // calldata is disallowed for receive function
|
|
}
|
|
|
|
// Receive is a paid mutator transaction binding the contract receive function.
|
|
//
|
|
// Solidity: receive() payable returns()
|
|
func (_Faucet *FaucetSession) Receive() (types.Transaction, error) {
|
|
return _Faucet.Contract.Receive(&_Faucet.TransactOpts)
|
|
}
|
|
|
|
// Receive is a paid mutator transaction binding the contract receive function.
|
|
//
|
|
// Solidity: receive() payable returns()
|
|
func (_Faucet *FaucetTransactorSession) Receive() (types.Transaction, error) {
|
|
return _Faucet.Contract.Receive(&_Faucet.TransactOpts)
|
|
}
|
|
|
|
// FaucetReceivedIterator is returned from FilterReceived and is used to iterate over the raw logs and unpacked data for Received events raised by the Faucet contract.
|
|
type FaucetReceivedIterator struct {
|
|
Event *FaucetReceived // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// Next advances the iterator to the subsequent event, returning whether there
|
|
// are any more events found. In case of a retrieval or parsing error, false is
|
|
// returned and Error() can be queried for the exact failure.
|
|
func (it *FaucetReceivedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(FaucetReceived)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(FaucetReceived)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *FaucetReceivedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *FaucetReceivedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// FaucetReceived represents a Received event raised by the Faucet contract.
|
|
type FaucetReceived struct {
|
|
Source libcommon.Address
|
|
Amount *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterReceived is a free log retrieval operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.
|
|
//
|
|
// Solidity: event received(address _source, uint256 _amount)
|
|
func (_Faucet *FaucetFilterer) FilterReceived(opts *bind.FilterOpts) (*FaucetReceivedIterator, error) {
|
|
|
|
logs, sub, err := _Faucet.contract.FilterLogs(opts, "received")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &FaucetReceivedIterator{contract: _Faucet.contract, event: "received", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchReceived is a free log subscription operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.
|
|
//
|
|
// Solidity: event received(address _source, uint256 _amount)
|
|
func (_Faucet *FaucetFilterer) WatchReceived(opts *bind.WatchOpts, sink chan<- *FaucetReceived) (event.Subscription, error) {
|
|
|
|
logs, sub, err := _Faucet.contract.WatchLogs(opts, "received")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(FaucetReceived)
|
|
if err := _Faucet.contract.UnpackLog(event, "received", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseReceived is a log parse operation binding the contract event 0xf11e547d796cc64acdf758e7cee90439494fd886a19159454aa61e473fdbafef.
|
|
//
|
|
// Solidity: event received(address _source, uint256 _amount)
|
|
func (_Faucet *FaucetFilterer) ParseReceived(log types.Log) (*FaucetReceived, error) {
|
|
event := new(FaucetReceived)
|
|
if err := _Faucet.contract.UnpackLog(event, "received", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// FaucetSentIterator is returned from FilterSent and is used to iterate over the raw logs and unpacked data for Sent events raised by the Faucet contract.
|
|
type FaucetSentIterator struct {
|
|
Event *FaucetSent // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// Next advances the iterator to the subsequent event, returning whether there
|
|
// are any more events found. In case of a retrieval or parsing error, false is
|
|
// returned and Error() can be queried for the exact failure.
|
|
func (it *FaucetSentIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(FaucetSent)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(FaucetSent)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *FaucetSentIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *FaucetSentIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// FaucetSent represents a Sent event raised by the Faucet contract.
|
|
type FaucetSent struct {
|
|
Destination libcommon.Address
|
|
Amount *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterSent is a free log retrieval operation binding the contract event 0x3bcb2e664d8f57273201bc888e82d6549f8308a52a9fcd7702b2ea8387f769a9.
|
|
//
|
|
// Solidity: event sent(address _destination, uint256 _amount)
|
|
func (_Faucet *FaucetFilterer) FilterSent(opts *bind.FilterOpts) (*FaucetSentIterator, error) {
|
|
|
|
logs, sub, err := _Faucet.contract.FilterLogs(opts, "sent")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &FaucetSentIterator{contract: _Faucet.contract, event: "sent", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchSent is a free log subscription operation binding the contract event 0x3bcb2e664d8f57273201bc888e82d6549f8308a52a9fcd7702b2ea8387f769a9.
|
|
//
|
|
// Solidity: event sent(address _destination, uint256 _amount)
|
|
func (_Faucet *FaucetFilterer) WatchSent(opts *bind.WatchOpts, sink chan<- *FaucetSent) (event.Subscription, error) {
|
|
|
|
logs, sub, err := _Faucet.contract.WatchLogs(opts, "sent")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(FaucetSent)
|
|
if err := _Faucet.contract.UnpackLog(event, "sent", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseSent is a log parse operation binding the contract event 0x3bcb2e664d8f57273201bc888e82d6549f8308a52a9fcd7702b2ea8387f769a9.
|
|
//
|
|
// Solidity: event sent(address _destination, uint256 _amount)
|
|
func (_Faucet *FaucetFilterer) ParseSent(log types.Log) (*FaucetSent, error) {
|
|
event := new(FaucetSent)
|
|
if err := _Faucet.contract.UnpackLog(event, "sent", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|