status-im
/
status-go
mirror of https://github.com/status-im/status-go.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
status-go/contracts/celer/bridge.go

4649 lines
185 KiB
Go
Raw Normal View History

feat: cbridge integration
2022-11-22 13:49:29 +00:00
// Code generated - DO NOT EDIT.
// This file is a generated binding and any manual changes will be lost.
package celer
import (
"math/big"
"strings"
ethereum "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts/abi"
"github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/event"
)
// Reference imports to suppress errors if they are not otherwise used.
var (
_ = big.NewInt
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)
// CelerABI is the input ABI used to generate the binding from.
const CelerABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"period\",\"type\":\"uint256\"}],\"name\":\"DelayPeriodUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"threshold\",\"type\":\"uint256\"}],\"name\":\"DelayThresholdUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"id\",\"type\":\"bytes32\"}],\"name\":\"DelayedTransferAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"id\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"DelayedTransferExecuted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"name\":\"EpochLengthUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"cap\",\"type\":\"uint256\"}],\"name\":\"EpochVolumeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"GovernorAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"GovernorRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"seqnum\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"provider\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"LiquidityAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"MaxSendUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"MinAddUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"MinSendUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"transferId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{
// Celer is an auto generated Go binding around an Ethereum contract.
type Celer struct {
CelerCaller // Read-only binding to the contract
CelerTransactor // Write-only binding to the contract
CelerFilterer // Log filterer for contract events
}
// CelerCaller is an auto generated read-only Go binding around an Ethereum contract.
type CelerCaller struct {
contract *bind.BoundContract // Generic contract wrapper for the low level calls
}
// CelerTransactor is an auto generated write-only Go binding around an Ethereum contract.
type CelerTransactor struct {
contract *bind.BoundContract // Generic contract wrapper for the low level calls
}
// CelerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type CelerFilterer struct {
contract *bind.BoundContract // Generic contract wrapper for the low level calls
}
// CelerSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type CelerSession struct {
Contract *Celer // 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
}
// CelerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type CelerCallerSession struct {
Contract *CelerCaller // Generic contract caller binding to set the session for
CallOpts bind.CallOpts // Call options to use throughout this session
}
// CelerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type CelerTransactorSession struct {
Contract *CelerTransactor // Generic contract transactor binding to set the session for
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}
// CelerRaw is an auto generated low-level Go binding around an Ethereum contract.
type CelerRaw struct {
Contract *Celer // Generic contract binding to access the raw methods on
}
// CelerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type CelerCallerRaw struct {
Contract *CelerCaller // Generic read-only contract binding to access the raw methods on
}
// CelerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type CelerTransactorRaw struct {
Contract *CelerTransactor // Generic write-only contract binding to access the raw methods on
}
// NewCeler creates a new instance of Celer, bound to a specific deployed contract.
func NewCeler(address common.Address, backend bind.ContractBackend) (*Celer, error) {
contract, err := bindCeler(address, backend, backend, backend)
if err != nil {
return nil, err
}
return &Celer{CelerCaller: CelerCaller{contract: contract}, CelerTransactor: CelerTransactor{contract: contract}, CelerFilterer: CelerFilterer{contract: contract}}, nil
}
// NewCelerCaller creates a new read-only instance of Celer, bound to a specific deployed contract.
func NewCelerCaller(address common.Address, caller bind.ContractCaller) (*CelerCaller, error) {
contract, err := bindCeler(address, caller, nil, nil)
if err != nil {
return nil, err
}
return &CelerCaller{contract: contract}, nil
}
// NewCelerTransactor creates a new write-only instance of Celer, bound to a specific deployed contract.
func NewCelerTransactor(address common.Address, transactor bind.ContractTransactor) (*CelerTransactor, error) {
contract, err := bindCeler(address, nil, transactor, nil)
if err != nil {
return nil, err
}
return &CelerTransactor{contract: contract}, nil
}
// NewCelerFilterer creates a new log filterer instance of Celer, bound to a specific deployed contract.
func NewCelerFilterer(address common.Address, filterer bind.ContractFilterer) (*CelerFilterer, error) {
contract, err := bindCeler(address, nil, nil, filterer)
if err != nil {
return nil, err
}
return &CelerFilterer{contract: contract}, nil
}
// bindCeler binds a generic wrapper to an already deployed contract.
func bindCeler(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
parsed, err := abi.JSON(strings.NewReader(CelerABI))
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 (_Celer *CelerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
return _Celer.Contract.CelerCaller.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 (_Celer *CelerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
return _Celer.Contract.CelerTransactor.contract.Transfer(opts)
}
// Transact invokes the (paid) contract method with params as input values.
func (_Celer *CelerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
return _Celer.Contract.CelerTransactor.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 (_Celer *CelerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
return _Celer.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 (_Celer *CelerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
return _Celer.Contract.contract.Transfer(opts)
}
// Transact invokes the (paid) contract method with params as input values.
func (_Celer *CelerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
return _Celer.Contract.contract.Transact(opts, method, params...)
}
// Addseq is a free data retrieval call binding the contract method 0x89e39127.
//
// Solidity: function addseq() view returns(uint64)
func (_Celer *CelerCaller) Addseq(opts *bind.CallOpts) (uint64, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "addseq")
if err != nil {
return *new(uint64), err
}
out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
return out0, err
}
// Addseq is a free data retrieval call binding the contract method 0x89e39127.
//
// Solidity: function addseq() view returns(uint64)
func (_Celer *CelerSession) Addseq() (uint64, error) {
return _Celer.Contract.Addseq(&_Celer.CallOpts)
}
// Addseq is a free data retrieval call binding the contract method 0x89e39127.
//
// Solidity: function addseq() view returns(uint64)
func (_Celer *CelerCallerSession) Addseq() (uint64, error) {
return _Celer.Contract.Addseq(&_Celer.CallOpts)
}
// DelayPeriod is a free data retrieval call binding the contract method 0xb1c94d94.
//
// Solidity: function delayPeriod() view returns(uint256)
func (_Celer *CelerCaller) DelayPeriod(opts *bind.CallOpts) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "delayPeriod")
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// DelayPeriod is a free data retrieval call binding the contract method 0xb1c94d94.
//
// Solidity: function delayPeriod() view returns(uint256)
func (_Celer *CelerSession) DelayPeriod() (*big.Int, error) {
return _Celer.Contract.DelayPeriod(&_Celer.CallOpts)
}
// DelayPeriod is a free data retrieval call binding the contract method 0xb1c94d94.
//
// Solidity: function delayPeriod() view returns(uint256)
func (_Celer *CelerCallerSession) DelayPeriod() (*big.Int, error) {
return _Celer.Contract.DelayPeriod(&_Celer.CallOpts)
}
// DelayThresholds is a free data retrieval call binding the contract method 0x52532faa.
//
// Solidity: function delayThresholds(address ) view returns(uint256)
func (_Celer *CelerCaller) DelayThresholds(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "delayThresholds", arg0)
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// DelayThresholds is a free data retrieval call binding the contract method 0x52532faa.
//
// Solidity: function delayThresholds(address ) view returns(uint256)
func (_Celer *CelerSession) DelayThresholds(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.DelayThresholds(&_Celer.CallOpts, arg0)
}
// DelayThresholds is a free data retrieval call binding the contract method 0x52532faa.
//
// Solidity: function delayThresholds(address ) view returns(uint256)
func (_Celer *CelerCallerSession) DelayThresholds(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.DelayThresholds(&_Celer.CallOpts, arg0)
}
// DelayedTransfers is a free data retrieval call binding the contract method 0xadc0d57f.
//
// Solidity: function delayedTransfers(bytes32 ) view returns(address receiver, address token, uint256 amount, uint256 timestamp)
func (_Celer *CelerCaller) DelayedTransfers(opts *bind.CallOpts, arg0 [32]byte) (struct {
Receiver common.Address
Token common.Address
Amount *big.Int
Timestamp *big.Int
}, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "delayedTransfers", arg0)
outstruct := new(struct {
Receiver common.Address
Token common.Address
Amount *big.Int
Timestamp *big.Int
})
if err != nil {
return *outstruct, err
}
outstruct.Receiver = *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
outstruct.Token = *abi.ConvertType(out[1], new(common.Address)).(*common.Address)
outstruct.Amount = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int)
outstruct.Timestamp = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int)
return *outstruct, err
}
// DelayedTransfers is a free data retrieval call binding the contract method 0xadc0d57f.
//
// Solidity: function delayedTransfers(bytes32 ) view returns(address receiver, address token, uint256 amount, uint256 timestamp)
func (_Celer *CelerSession) DelayedTransfers(arg0 [32]byte) (struct {
Receiver common.Address
Token common.Address
Amount *big.Int
Timestamp *big.Int
}, error) {
return _Celer.Contract.DelayedTransfers(&_Celer.CallOpts, arg0)
}
// DelayedTransfers is a free data retrieval call binding the contract method 0xadc0d57f.
//
// Solidity: function delayedTransfers(bytes32 ) view returns(address receiver, address token, uint256 amount, uint256 timestamp)
func (_Celer *CelerCallerSession) DelayedTransfers(arg0 [32]byte) (struct {
Receiver common.Address
Token common.Address
Amount *big.Int
Timestamp *big.Int
}, error) {
return _Celer.Contract.DelayedTransfers(&_Celer.CallOpts, arg0)
}
// EpochLength is a free data retrieval call binding the contract method 0x57d775f8.
//
// Solidity: function epochLength() view returns(uint256)
func (_Celer *CelerCaller) EpochLength(opts *bind.CallOpts) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "epochLength")
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// EpochLength is a free data retrieval call binding the contract method 0x57d775f8.
//
// Solidity: function epochLength() view returns(uint256)
func (_Celer *CelerSession) EpochLength() (*big.Int, error) {
return _Celer.Contract.EpochLength(&_Celer.CallOpts)
}
// EpochLength is a free data retrieval call binding the contract method 0x57d775f8.
//
// Solidity: function epochLength() view returns(uint256)
func (_Celer *CelerCallerSession) EpochLength() (*big.Int, error) {
return _Celer.Contract.EpochLength(&_Celer.CallOpts)
}
// EpochVolumeCaps is a free data retrieval call binding the contract method 0xb5f2bc47.
//
// Solidity: function epochVolumeCaps(address ) view returns(uint256)
func (_Celer *CelerCaller) EpochVolumeCaps(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "epochVolumeCaps", arg0)
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// EpochVolumeCaps is a free data retrieval call binding the contract method 0xb5f2bc47.
//
// Solidity: function epochVolumeCaps(address ) view returns(uint256)
func (_Celer *CelerSession) EpochVolumeCaps(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.EpochVolumeCaps(&_Celer.CallOpts, arg0)
}
// EpochVolumeCaps is a free data retrieval call binding the contract method 0xb5f2bc47.
//
// Solidity: function epochVolumeCaps(address ) view returns(uint256)
func (_Celer *CelerCallerSession) EpochVolumeCaps(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.EpochVolumeCaps(&_Celer.CallOpts, arg0)
}
// EpochVolumes is a free data retrieval call binding the contract method 0x60216b00.
//
// Solidity: function epochVolumes(address ) view returns(uint256)
func (_Celer *CelerCaller) EpochVolumes(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "epochVolumes", arg0)
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// EpochVolumes is a free data retrieval call binding the contract method 0x60216b00.
//
// Solidity: function epochVolumes(address ) view returns(uint256)
func (_Celer *CelerSession) EpochVolumes(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.EpochVolumes(&_Celer.CallOpts, arg0)
}
// EpochVolumes is a free data retrieval call binding the contract method 0x60216b00.
//
// Solidity: function epochVolumes(address ) view returns(uint256)
func (_Celer *CelerCallerSession) EpochVolumes(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.EpochVolumes(&_Celer.CallOpts, arg0)
}
// Governors is a free data retrieval call binding the contract method 0xe3eece26.
//
// Solidity: function governors(address ) view returns(bool)
func (_Celer *CelerCaller) Governors(opts *bind.CallOpts, arg0 common.Address) (bool, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "governors", arg0)
if err != nil {
return *new(bool), err
}
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
return out0, err
}
// Governors is a free data retrieval call binding the contract method 0xe3eece26.
//
// Solidity: function governors(address ) view returns(bool)
func (_Celer *CelerSession) Governors(arg0 common.Address) (bool, error) {
return _Celer.Contract.Governors(&_Celer.CallOpts, arg0)
}
// Governors is a free data retrieval call binding the contract method 0xe3eece26.
//
// Solidity: function governors(address ) view returns(bool)
func (_Celer *CelerCallerSession) Governors(arg0 common.Address) (bool, error) {
return _Celer.Contract.Governors(&_Celer.CallOpts, arg0)
}
// IsGovernor is a free data retrieval call binding the contract method 0xe43581b8.
//
// Solidity: function isGovernor(address _account) view returns(bool)
func (_Celer *CelerCaller) IsGovernor(opts *bind.CallOpts, _account common.Address) (bool, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "isGovernor", _account)
if err != nil {
return *new(bool), err
}
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
return out0, err
}
// IsGovernor is a free data retrieval call binding the contract method 0xe43581b8.
//
// Solidity: function isGovernor(address _account) view returns(bool)
func (_Celer *CelerSession) IsGovernor(_account common.Address) (bool, error) {
return _Celer.Contract.IsGovernor(&_Celer.CallOpts, _account)
}
// IsGovernor is a free data retrieval call binding the contract method 0xe43581b8.
//
// Solidity: function isGovernor(address _account) view returns(bool)
func (_Celer *CelerCallerSession) IsGovernor(_account common.Address) (bool, error) {
return _Celer.Contract.IsGovernor(&_Celer.CallOpts, _account)
}
// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) view returns(bool)
func (_Celer *CelerCaller) IsPauser(opts *bind.CallOpts, account common.Address) (bool, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "isPauser", account)
if err != nil {
return *new(bool), err
}
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
return out0, err
}
// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) view returns(bool)
func (_Celer *CelerSession) IsPauser(account common.Address) (bool, error) {
return _Celer.Contract.IsPauser(&_Celer.CallOpts, account)
}
// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e.
//
// Solidity: function isPauser(address account) view returns(bool)
func (_Celer *CelerCallerSession) IsPauser(account common.Address) (bool, error) {
return _Celer.Contract.IsPauser(&_Celer.CallOpts, account)
}
// LastOpTimestamps is a free data retrieval call binding the contract method 0xf8321383.
//
// Solidity: function lastOpTimestamps(address ) view returns(uint256)
func (_Celer *CelerCaller) LastOpTimestamps(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "lastOpTimestamps", arg0)
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// LastOpTimestamps is a free data retrieval call binding the contract method 0xf8321383.
//
// Solidity: function lastOpTimestamps(address ) view returns(uint256)
func (_Celer *CelerSession) LastOpTimestamps(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.LastOpTimestamps(&_Celer.CallOpts, arg0)
}
// LastOpTimestamps is a free data retrieval call binding the contract method 0xf8321383.
//
// Solidity: function lastOpTimestamps(address ) view returns(uint256)
func (_Celer *CelerCallerSession) LastOpTimestamps(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.LastOpTimestamps(&_Celer.CallOpts, arg0)
}
// MaxSend is a free data retrieval call binding the contract method 0x618ee055.
//
// Solidity: function maxSend(address ) view returns(uint256)
func (_Celer *CelerCaller) MaxSend(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "maxSend", arg0)
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// MaxSend is a free data retrieval call binding the contract method 0x618ee055.
//
// Solidity: function maxSend(address ) view returns(uint256)
func (_Celer *CelerSession) MaxSend(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.MaxSend(&_Celer.CallOpts, arg0)
}
// MaxSend is a free data retrieval call binding the contract method 0x618ee055.
//
// Solidity: function maxSend(address ) view returns(uint256)
func (_Celer *CelerCallerSession) MaxSend(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.MaxSend(&_Celer.CallOpts, arg0)
}
// MinAdd is a free data retrieval call binding the contract method 0xccde517a.
//
// Solidity: function minAdd(address ) view returns(uint256)
func (_Celer *CelerCaller) MinAdd(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "minAdd", arg0)
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// MinAdd is a free data retrieval call binding the contract method 0xccde517a.
//
// Solidity: function minAdd(address ) view returns(uint256)
func (_Celer *CelerSession) MinAdd(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.MinAdd(&_Celer.CallOpts, arg0)
}
// MinAdd is a free data retrieval call binding the contract method 0xccde517a.
//
// Solidity: function minAdd(address ) view returns(uint256)
func (_Celer *CelerCallerSession) MinAdd(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.MinAdd(&_Celer.CallOpts, arg0)
}
// MinSend is a free data retrieval call binding the contract method 0xf8b30d7d.
//
// Solidity: function minSend(address ) view returns(uint256)
func (_Celer *CelerCaller) MinSend(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "minSend", arg0)
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// MinSend is a free data retrieval call binding the contract method 0xf8b30d7d.
//
// Solidity: function minSend(address ) view returns(uint256)
func (_Celer *CelerSession) MinSend(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.MinSend(&_Celer.CallOpts, arg0)
}
// MinSend is a free data retrieval call binding the contract method 0xf8b30d7d.
//
// Solidity: function minSend(address ) view returns(uint256)
func (_Celer *CelerCallerSession) MinSend(arg0 common.Address) (*big.Int, error) {
return _Celer.Contract.MinSend(&_Celer.CallOpts, arg0)
}
// MinimalMaxSlippage is a free data retrieval call binding the contract method 0x2fd1b0a4.
//
// Solidity: function minimalMaxSlippage() view returns(uint32)
func (_Celer *CelerCaller) MinimalMaxSlippage(opts *bind.CallOpts) (uint32, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "minimalMaxSlippage")
if err != nil {
return *new(uint32), err
}
out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32)
return out0, err
}
// MinimalMaxSlippage is a free data retrieval call binding the contract method 0x2fd1b0a4.
//
// Solidity: function minimalMaxSlippage() view returns(uint32)
func (_Celer *CelerSession) MinimalMaxSlippage() (uint32, error) {
return _Celer.Contract.MinimalMaxSlippage(&_Celer.CallOpts)
}
// MinimalMaxSlippage is a free data retrieval call binding the contract method 0x2fd1b0a4.
//
// Solidity: function minimalMaxSlippage() view returns(uint32)
func (_Celer *CelerCallerSession) MinimalMaxSlippage() (uint32, error) {
return _Celer.Contract.MinimalMaxSlippage(&_Celer.CallOpts)
}
// NativeWrap is a free data retrieval call binding the contract method 0x457bfa2f.
//
// Solidity: function nativeWrap() view returns(address)
func (_Celer *CelerCaller) NativeWrap(opts *bind.CallOpts) (common.Address, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "nativeWrap")
if err != nil {
return *new(common.Address), err
}
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
return out0, err
}
// NativeWrap is a free data retrieval call binding the contract method 0x457bfa2f.
//
// Solidity: function nativeWrap() view returns(address)
func (_Celer *CelerSession) NativeWrap() (common.Address, error) {
return _Celer.Contract.NativeWrap(&_Celer.CallOpts)
}
// NativeWrap is a free data retrieval call binding the contract method 0x457bfa2f.
//
// Solidity: function nativeWrap() view returns(address)
func (_Celer *CelerCallerSession) NativeWrap() (common.Address, error) {
return _Celer.Contract.NativeWrap(&_Celer.CallOpts)
}
// NoticePeriod is a free data retrieval call binding the contract method 0x9b14d4c6.
//
// Solidity: function noticePeriod() view returns(uint256)
func (_Celer *CelerCaller) NoticePeriod(opts *bind.CallOpts) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "noticePeriod")
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// NoticePeriod is a free data retrieval call binding the contract method 0x9b14d4c6.
//
// Solidity: function noticePeriod() view returns(uint256)
func (_Celer *CelerSession) NoticePeriod() (*big.Int, error) {
return _Celer.Contract.NoticePeriod(&_Celer.CallOpts)
}
// NoticePeriod is a free data retrieval call binding the contract method 0x9b14d4c6.
//
// Solidity: function noticePeriod() view returns(uint256)
func (_Celer *CelerCallerSession) NoticePeriod() (*big.Int, error) {
return _Celer.Contract.NoticePeriod(&_Celer.CallOpts)
}
// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() view returns(address)
func (_Celer *CelerCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "owner")
if err != nil {
return *new(common.Address), err
}
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
return out0, err
}
// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() view returns(address)
func (_Celer *CelerSession) Owner() (common.Address, error) {
return _Celer.Contract.Owner(&_Celer.CallOpts)
}
// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() view returns(address)
func (_Celer *CelerCallerSession) Owner() (common.Address, error) {
return _Celer.Contract.Owner(&_Celer.CallOpts)
}
// Paused is a free data retrieval call binding the contract method 0x5c975abb.
//
// Solidity: function paused() view returns(bool)
func (_Celer *CelerCaller) Paused(opts *bind.CallOpts) (bool, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "paused")
if err != nil {
return *new(bool), err
}
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
return out0, err
}
// Paused is a free data retrieval call binding the contract method 0x5c975abb.
//
// Solidity: function paused() view returns(bool)
func (_Celer *CelerSession) Paused() (bool, error) {
return _Celer.Contract.Paused(&_Celer.CallOpts)
}
// Paused is a free data retrieval call binding the contract method 0x5c975abb.
//
// Solidity: function paused() view returns(bool)
func (_Celer *CelerCallerSession) Paused() (bool, error) {
return _Celer.Contract.Paused(&_Celer.CallOpts)
}
// Pausers is a free data retrieval call binding the contract method 0x80f51c12.
//
// Solidity: function pausers(address ) view returns(bool)
func (_Celer *CelerCaller) Pausers(opts *bind.CallOpts, arg0 common.Address) (bool, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "pausers", arg0)
if err != nil {
return *new(bool), err
}
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
return out0, err
}
// Pausers is a free data retrieval call binding the contract method 0x80f51c12.
//
// Solidity: function pausers(address ) view returns(bool)
func (_Celer *CelerSession) Pausers(arg0 common.Address) (bool, error) {
return _Celer.Contract.Pausers(&_Celer.CallOpts, arg0)
}
// Pausers is a free data retrieval call binding the contract method 0x80f51c12.
//
// Solidity: function pausers(address ) view returns(bool)
func (_Celer *CelerCallerSession) Pausers(arg0 common.Address) (bool, error) {
return _Celer.Contract.Pausers(&_Celer.CallOpts, arg0)
}
// ResetTime is a free data retrieval call binding the contract method 0x65a114f1.
//
// Solidity: function resetTime() view returns(uint256)
func (_Celer *CelerCaller) ResetTime(opts *bind.CallOpts) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "resetTime")
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// ResetTime is a free data retrieval call binding the contract method 0x65a114f1.
//
// Solidity: function resetTime() view returns(uint256)
func (_Celer *CelerSession) ResetTime() (*big.Int, error) {
return _Celer.Contract.ResetTime(&_Celer.CallOpts)
}
// ResetTime is a free data retrieval call binding the contract method 0x65a114f1.
//
// Solidity: function resetTime() view returns(uint256)
func (_Celer *CelerCallerSession) ResetTime() (*big.Int, error) {
return _Celer.Contract.ResetTime(&_Celer.CallOpts)
}
// SsHash is a free data retrieval call binding the contract method 0xd0790da9.
//
// Solidity: function ssHash() view returns(bytes32)
func (_Celer *CelerCaller) SsHash(opts *bind.CallOpts) ([32]byte, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "ssHash")
if err != nil {
return *new([32]byte), err
}
out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
return out0, err
}
// SsHash is a free data retrieval call binding the contract method 0xd0790da9.
//
// Solidity: function ssHash() view returns(bytes32)
func (_Celer *CelerSession) SsHash() ([32]byte, error) {
return _Celer.Contract.SsHash(&_Celer.CallOpts)
}
// SsHash is a free data retrieval call binding the contract method 0xd0790da9.
//
// Solidity: function ssHash() view returns(bytes32)
func (_Celer *CelerCallerSession) SsHash() ([32]byte, error) {
return _Celer.Contract.SsHash(&_Celer.CallOpts)
}
// Transfers is a free data retrieval call binding the contract method 0x3c64f04b.
//
// Solidity: function transfers(bytes32 ) view returns(bool)
func (_Celer *CelerCaller) Transfers(opts *bind.CallOpts, arg0 [32]byte) (bool, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "transfers", arg0)
if err != nil {
return *new(bool), err
}
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
return out0, err
}
// Transfers is a free data retrieval call binding the contract method 0x3c64f04b.
//
// Solidity: function transfers(bytes32 ) view returns(bool)
func (_Celer *CelerSession) Transfers(arg0 [32]byte) (bool, error) {
return _Celer.Contract.Transfers(&_Celer.CallOpts, arg0)
}
// Transfers is a free data retrieval call binding the contract method 0x3c64f04b.
//
// Solidity: function transfers(bytes32 ) view returns(bool)
func (_Celer *CelerCallerSession) Transfers(arg0 [32]byte) (bool, error) {
return _Celer.Contract.Transfers(&_Celer.CallOpts, arg0)
}
// TriggerTime is a free data retrieval call binding the contract method 0x370fb47b.
//
// Solidity: function triggerTime() view returns(uint256)
func (_Celer *CelerCaller) TriggerTime(opts *bind.CallOpts) (*big.Int, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "triggerTime")
if err != nil {
return *new(*big.Int), err
}
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
return out0, err
}
// TriggerTime is a free data retrieval call binding the contract method 0x370fb47b.
//
// Solidity: function triggerTime() view returns(uint256)
func (_Celer *CelerSession) TriggerTime() (*big.Int, error) {
return _Celer.Contract.TriggerTime(&_Celer.CallOpts)
}
// TriggerTime is a free data retrieval call binding the contract method 0x370fb47b.
//
// Solidity: function triggerTime() view returns(uint256)
func (_Celer *CelerCallerSession) TriggerTime() (*big.Int, error) {
return _Celer.Contract.TriggerTime(&_Celer.CallOpts)
}
// VerifySigs is a free data retrieval call binding the contract method 0x682dbc22.
//
// Solidity: function verifySigs(bytes _msg, bytes[] _sigs, address[] _signers, uint256[] _powers) view returns()
func (_Celer *CelerCaller) VerifySigs(opts *bind.CallOpts, _msg []byte, _sigs [][]byte, _signers []common.Address, _powers []*big.Int) error {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "verifySigs", _msg, _sigs, _signers, _powers)
if err != nil {
return err
}
return err
}
// VerifySigs is a free data retrieval call binding the contract method 0x682dbc22.
//
// Solidity: function verifySigs(bytes _msg, bytes[] _sigs, address[] _signers, uint256[] _powers) view returns()
func (_Celer *CelerSession) VerifySigs(_msg []byte, _sigs [][]byte, _signers []common.Address, _powers []*big.Int) error {
return _Celer.Contract.VerifySigs(&_Celer.CallOpts, _msg, _sigs, _signers, _powers)
}
// VerifySigs is a free data retrieval call binding the contract method 0x682dbc22.
//
// Solidity: function verifySigs(bytes _msg, bytes[] _sigs, address[] _signers, uint256[] _powers) view returns()
func (_Celer *CelerCallerSession) VerifySigs(_msg []byte, _sigs [][]byte, _signers []common.Address, _powers []*big.Int) error {
return _Celer.Contract.VerifySigs(&_Celer.CallOpts, _msg, _sigs, _signers, _powers)
}
// Withdraws is a free data retrieval call binding the contract method 0xe09ab428.
//
// Solidity: function withdraws(bytes32 ) view returns(bool)
func (_Celer *CelerCaller) Withdraws(opts *bind.CallOpts, arg0 [32]byte) (bool, error) {
var out []interface{}
err := _Celer.contract.Call(opts, &out, "withdraws", arg0)
if err != nil {
return *new(bool), err
}
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
return out0, err
}
// Withdraws is a free data retrieval call binding the contract method 0xe09ab428.
//
// Solidity: function withdraws(bytes32 ) view returns(bool)
func (_Celer *CelerSession) Withdraws(arg0 [32]byte) (bool, error) {
return _Celer.Contract.Withdraws(&_Celer.CallOpts, arg0)
}
// Withdraws is a free data retrieval call binding the contract method 0xe09ab428.
//
// Solidity: function withdraws(bytes32 ) view returns(bool)
func (_Celer *CelerCallerSession) Withdraws(arg0 [32]byte) (bool, error) {
return _Celer.Contract.Withdraws(&_Celer.CallOpts, arg0)
}
// AddGovernor is a paid mutator transaction binding the contract method 0x3c4a25d0.
//
// Solidity: function addGovernor(address _account) returns()
func (_Celer *CelerTransactor) AddGovernor(opts *bind.TransactOpts, _account common.Address) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "addGovernor", _account)
}
// AddGovernor is a paid mutator transaction binding the contract method 0x3c4a25d0.
//
// Solidity: function addGovernor(address _account) returns()
func (_Celer *CelerSession) AddGovernor(_account common.Address) (*types.Transaction, error) {
return _Celer.Contract.AddGovernor(&_Celer.TransactOpts, _account)
}
// AddGovernor is a paid mutator transaction binding the contract method 0x3c4a25d0.
//
// Solidity: function addGovernor(address _account) returns()
func (_Celer *CelerTransactorSession) AddGovernor(_account common.Address) (*types.Transaction, error) {
return _Celer.Contract.AddGovernor(&_Celer.TransactOpts, _account)
}
// AddLiquidity is a paid mutator transaction binding the contract method 0x56688700.
//
// Solidity: function addLiquidity(address _token, uint256 _amount) returns()
func (_Celer *CelerTransactor) AddLiquidity(opts *bind.TransactOpts, _token common.Address, _amount *big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "addLiquidity", _token, _amount)
}
// AddLiquidity is a paid mutator transaction binding the contract method 0x56688700.
//
// Solidity: function addLiquidity(address _token, uint256 _amount) returns()
func (_Celer *CelerSession) AddLiquidity(_token common.Address, _amount *big.Int) (*types.Transaction, error) {
return _Celer.Contract.AddLiquidity(&_Celer.TransactOpts, _token, _amount)
}
// AddLiquidity is a paid mutator transaction binding the contract method 0x56688700.
//
// Solidity: function addLiquidity(address _token, uint256 _amount) returns()
func (_Celer *CelerTransactorSession) AddLiquidity(_token common.Address, _amount *big.Int) (*types.Transaction, error) {
return _Celer.Contract.AddLiquidity(&_Celer.TransactOpts, _token, _amount)
}
// AddNativeLiquidity is a paid mutator transaction binding the contract method 0x7044c89e.
//
// Solidity: function addNativeLiquidity(uint256 _amount) payable returns()
func (_Celer *CelerTransactor) AddNativeLiquidity(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "addNativeLiquidity", _amount)
}
// AddNativeLiquidity is a paid mutator transaction binding the contract method 0x7044c89e.
//
// Solidity: function addNativeLiquidity(uint256 _amount) payable returns()
func (_Celer *CelerSession) AddNativeLiquidity(_amount *big.Int) (*types.Transaction, error) {
return _Celer.Contract.AddNativeLiquidity(&_Celer.TransactOpts, _amount)
}
// AddNativeLiquidity is a paid mutator transaction binding the contract method 0x7044c89e.
//
// Solidity: function addNativeLiquidity(uint256 _amount) payable returns()
func (_Celer *CelerTransactorSession) AddNativeLiquidity(_amount *big.Int) (*types.Transaction, error) {
return _Celer.Contract.AddNativeLiquidity(&_Celer.TransactOpts, _amount)
}
// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_Celer *CelerTransactor) AddPauser(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "addPauser", account)
}
// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_Celer *CelerSession) AddPauser(account common.Address) (*types.Transaction, error) {
return _Celer.Contract.AddPauser(&_Celer.TransactOpts, account)
}
// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4.
//
// Solidity: function addPauser(address account) returns()
func (_Celer *CelerTransactorSession) AddPauser(account common.Address) (*types.Transaction, error) {
return _Celer.Contract.AddPauser(&_Celer.TransactOpts, account)
}
// ExecuteDelayedTransfer is a paid mutator transaction binding the contract method 0x9e25fc5c.
//
// Solidity: function executeDelayedTransfer(bytes32 id) returns()
func (_Celer *CelerTransactor) ExecuteDelayedTransfer(opts *bind.TransactOpts, id [32]byte) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "executeDelayedTransfer", id)
}
// ExecuteDelayedTransfer is a paid mutator transaction binding the contract method 0x9e25fc5c.
//
// Solidity: function executeDelayedTransfer(bytes32 id) returns()
func (_Celer *CelerSession) ExecuteDelayedTransfer(id [32]byte) (*types.Transaction, error) {
return _Celer.Contract.ExecuteDelayedTransfer(&_Celer.TransactOpts, id)
}
// ExecuteDelayedTransfer is a paid mutator transaction binding the contract method 0x9e25fc5c.
//
// Solidity: function executeDelayedTransfer(bytes32 id) returns()
func (_Celer *CelerTransactorSession) ExecuteDelayedTransfer(id [32]byte) (*types.Transaction, error) {
return _Celer.Contract.ExecuteDelayedTransfer(&_Celer.TransactOpts, id)
}
// IncreaseNoticePeriod is a paid mutator transaction binding the contract method 0xf20c922a.
//
// Solidity: function increaseNoticePeriod(uint256 period) returns()
func (_Celer *CelerTransactor) IncreaseNoticePeriod(opts *bind.TransactOpts, period *big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "increaseNoticePeriod", period)
}
// IncreaseNoticePeriod is a paid mutator transaction binding the contract method 0xf20c922a.
//
// Solidity: function increaseNoticePeriod(uint256 period) returns()
func (_Celer *CelerSession) IncreaseNoticePeriod(period *big.Int) (*types.Transaction, error) {
return _Celer.Contract.IncreaseNoticePeriod(&_Celer.TransactOpts, period)
}
// IncreaseNoticePeriod is a paid mutator transaction binding the contract method 0xf20c922a.
//
// Solidity: function increaseNoticePeriod(uint256 period) returns()
func (_Celer *CelerTransactorSession) IncreaseNoticePeriod(period *big.Int) (*types.Transaction, error) {
return _Celer.Contract.IncreaseNoticePeriod(&_Celer.TransactOpts, period)
}
// NotifyResetSigners is a paid mutator transaction binding the contract method 0x25c38b9f.
//
// Solidity: function notifyResetSigners() returns()
func (_Celer *CelerTransactor) NotifyResetSigners(opts *bind.TransactOpts) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "notifyResetSigners")
}
// NotifyResetSigners is a paid mutator transaction binding the contract method 0x25c38b9f.
//
// Solidity: function notifyResetSigners() returns()
func (_Celer *CelerSession) NotifyResetSigners() (*types.Transaction, error) {
return _Celer.Contract.NotifyResetSigners(&_Celer.TransactOpts)
}
// NotifyResetSigners is a paid mutator transaction binding the contract method 0x25c38b9f.
//
// Solidity: function notifyResetSigners() returns()
func (_Celer *CelerTransactorSession) NotifyResetSigners() (*types.Transaction, error) {
return _Celer.Contract.NotifyResetSigners(&_Celer.TransactOpts)
}
// Pause is a paid mutator transaction binding the contract method 0x8456cb59.
//
// Solidity: function pause() returns()
func (_Celer *CelerTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "pause")
}
// Pause is a paid mutator transaction binding the contract method 0x8456cb59.
//
// Solidity: function pause() returns()
func (_Celer *CelerSession) Pause() (*types.Transaction, error) {
return _Celer.Contract.Pause(&_Celer.TransactOpts)
}
// Pause is a paid mutator transaction binding the contract method 0x8456cb59.
//
// Solidity: function pause() returns()
func (_Celer *CelerTransactorSession) Pause() (*types.Transaction, error) {
return _Celer.Contract.Pause(&_Celer.TransactOpts)
}
// Relay is a paid mutator transaction binding the contract method 0xcdd1b25d.
//
// Solidity: function relay(bytes _relayRequest, bytes[] _sigs, address[] _signers, uint256[] _powers) returns()
func (_Celer *CelerTransactor) Relay(opts *bind.TransactOpts, _relayRequest []byte, _sigs [][]byte, _signers []common.Address, _powers []*big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "relay", _relayRequest, _sigs, _signers, _powers)
}
// Relay is a paid mutator transaction binding the contract method 0xcdd1b25d.
//
// Solidity: function relay(bytes _relayRequest, bytes[] _sigs, address[] _signers, uint256[] _powers) returns()
func (_Celer *CelerSession) Relay(_relayRequest []byte, _sigs [][]byte, _signers []common.Address, _powers []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.Relay(&_Celer.TransactOpts, _relayRequest, _sigs, _signers, _powers)
}
// Relay is a paid mutator transaction binding the contract method 0xcdd1b25d.
//
// Solidity: function relay(bytes _relayRequest, bytes[] _sigs, address[] _signers, uint256[] _powers) returns()
func (_Celer *CelerTransactorSession) Relay(_relayRequest []byte, _sigs [][]byte, _signers []common.Address, _powers []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.Relay(&_Celer.TransactOpts, _relayRequest, _sigs, _signers, _powers)
}
// RemoveGovernor is a paid mutator transaction binding the contract method 0xeecdac88.
//
// Solidity: function removeGovernor(address _account) returns()
func (_Celer *CelerTransactor) RemoveGovernor(opts *bind.TransactOpts, _account common.Address) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "removeGovernor", _account)
}
// RemoveGovernor is a paid mutator transaction binding the contract method 0xeecdac88.
//
// Solidity: function removeGovernor(address _account) returns()
func (_Celer *CelerSession) RemoveGovernor(_account common.Address) (*types.Transaction, error) {
return _Celer.Contract.RemoveGovernor(&_Celer.TransactOpts, _account)
}
// RemoveGovernor is a paid mutator transaction binding the contract method 0xeecdac88.
//
// Solidity: function removeGovernor(address _account) returns()
func (_Celer *CelerTransactorSession) RemoveGovernor(_account common.Address) (*types.Transaction, error) {
return _Celer.Contract.RemoveGovernor(&_Celer.TransactOpts, _account)
}
// RemovePauser is a paid mutator transaction binding the contract method 0x6b2c0f55.
//
// Solidity: function removePauser(address account) returns()
func (_Celer *CelerTransactor) RemovePauser(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "removePauser", account)
}
// RemovePauser is a paid mutator transaction binding the contract method 0x6b2c0f55.
//
// Solidity: function removePauser(address account) returns()
func (_Celer *CelerSession) RemovePauser(account common.Address) (*types.Transaction, error) {
return _Celer.Contract.RemovePauser(&_Celer.TransactOpts, account)
}
// RemovePauser is a paid mutator transaction binding the contract method 0x6b2c0f55.
//
// Solidity: function removePauser(address account) returns()
func (_Celer *CelerTransactorSession) RemovePauser(account common.Address) (*types.Transaction, error) {
return _Celer.Contract.RemovePauser(&_Celer.TransactOpts, account)
}
// RenounceGovernor is a paid mutator transaction binding the contract method 0xe026049c.
//
// Solidity: function renounceGovernor() returns()
func (_Celer *CelerTransactor) RenounceGovernor(opts *bind.TransactOpts) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "renounceGovernor")
}
// RenounceGovernor is a paid mutator transaction binding the contract method 0xe026049c.
//
// Solidity: function renounceGovernor() returns()
func (_Celer *CelerSession) RenounceGovernor() (*types.Transaction, error) {
return _Celer.Contract.RenounceGovernor(&_Celer.TransactOpts)
}
// RenounceGovernor is a paid mutator transaction binding the contract method 0xe026049c.
//
// Solidity: function renounceGovernor() returns()
func (_Celer *CelerTransactorSession) RenounceGovernor() (*types.Transaction, error) {
return _Celer.Contract.RenounceGovernor(&_Celer.TransactOpts)
}
// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_Celer *CelerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "renounceOwnership")
}
// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_Celer *CelerSession) RenounceOwnership() (*types.Transaction, error) {
return _Celer.Contract.RenounceOwnership(&_Celer.TransactOpts)
}
// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_Celer *CelerTransactorSession) RenounceOwnership() (*types.Transaction, error) {
return _Celer.Contract.RenounceOwnership(&_Celer.TransactOpts)
}
// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_Celer *CelerTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "renouncePauser")
}
// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_Celer *CelerSession) RenouncePauser() (*types.Transaction, error) {
return _Celer.Contract.RenouncePauser(&_Celer.TransactOpts)
}
// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
//
// Solidity: function renouncePauser() returns()
func (_Celer *CelerTransactorSession) RenouncePauser() (*types.Transaction, error) {
return _Celer.Contract.RenouncePauser(&_Celer.TransactOpts)
}
// ResetSigners is a paid mutator transaction binding the contract method 0xa7bdf45a.
//
// Solidity: function resetSigners(address[] _signers, uint256[] _powers) returns()
func (_Celer *CelerTransactor) ResetSigners(opts *bind.TransactOpts, _signers []common.Address, _powers []*big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "resetSigners", _signers, _powers)
}
// ResetSigners is a paid mutator transaction binding the contract method 0xa7bdf45a.
//
// Solidity: function resetSigners(address[] _signers, uint256[] _powers) returns()
func (_Celer *CelerSession) ResetSigners(_signers []common.Address, _powers []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.ResetSigners(&_Celer.TransactOpts, _signers, _powers)
}
// ResetSigners is a paid mutator transaction binding the contract method 0xa7bdf45a.
//
// Solidity: function resetSigners(address[] _signers, uint256[] _powers) returns()
func (_Celer *CelerTransactorSession) ResetSigners(_signers []common.Address, _powers []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.ResetSigners(&_Celer.TransactOpts, _signers, _powers)
}
// Send is a paid mutator transaction binding the contract method 0xa5977fbb.
//
// Solidity: function send(address _receiver, address _token, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage) returns()
func (_Celer *CelerTransactor) Send(opts *bind.TransactOpts, _receiver common.Address, _token common.Address, _amount *big.Int, _dstChainId uint64, _nonce uint64, _maxSlippage uint32) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "send", _receiver, _token, _amount, _dstChainId, _nonce, _maxSlippage)
}
// Send is a paid mutator transaction binding the contract method 0xa5977fbb.
//
// Solidity: function send(address _receiver, address _token, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage) returns()
func (_Celer *CelerSession) Send(_receiver common.Address, _token common.Address, _amount *big.Int, _dstChainId uint64, _nonce uint64, _maxSlippage uint32) (*types.Transaction, error) {
return _Celer.Contract.Send(&_Celer.TransactOpts, _receiver, _token, _amount, _dstChainId, _nonce, _maxSlippage)
}
// Send is a paid mutator transaction binding the contract method 0xa5977fbb.
//
// Solidity: function send(address _receiver, address _token, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage) returns()
func (_Celer *CelerTransactorSession) Send(_receiver common.Address, _token common.Address, _amount *big.Int, _dstChainId uint64, _nonce uint64, _maxSlippage uint32) (*types.Transaction, error) {
return _Celer.Contract.Send(&_Celer.TransactOpts, _receiver, _token, _amount, _dstChainId, _nonce, _maxSlippage)
}
// SendNative is a paid mutator transaction binding the contract method 0x3f2e5fc3.
//
// Solidity: function sendNative(address _receiver, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage) payable returns()
func (_Celer *CelerTransactor) SendNative(opts *bind.TransactOpts, _receiver common.Address, _amount *big.Int, _dstChainId uint64, _nonce uint64, _maxSlippage uint32) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "sendNative", _receiver, _amount, _dstChainId, _nonce, _maxSlippage)
}
// SendNative is a paid mutator transaction binding the contract method 0x3f2e5fc3.
//
// Solidity: function sendNative(address _receiver, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage) payable returns()
func (_Celer *CelerSession) SendNative(_receiver common.Address, _amount *big.Int, _dstChainId uint64, _nonce uint64, _maxSlippage uint32) (*types.Transaction, error) {
return _Celer.Contract.SendNative(&_Celer.TransactOpts, _receiver, _amount, _dstChainId, _nonce, _maxSlippage)
}
// SendNative is a paid mutator transaction binding the contract method 0x3f2e5fc3.
//
// Solidity: function sendNative(address _receiver, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage) payable returns()
func (_Celer *CelerTransactorSession) SendNative(_receiver common.Address, _amount *big.Int, _dstChainId uint64, _nonce uint64, _maxSlippage uint32) (*types.Transaction, error) {
return _Celer.Contract.SendNative(&_Celer.TransactOpts, _receiver, _amount, _dstChainId, _nonce, _maxSlippage)
}
// SetDelayPeriod is a paid mutator transaction binding the contract method 0x3d572107.
//
// Solidity: function setDelayPeriod(uint256 _period) returns()
func (_Celer *CelerTransactor) SetDelayPeriod(opts *bind.TransactOpts, _period *big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "setDelayPeriod", _period)
}
// SetDelayPeriod is a paid mutator transaction binding the contract method 0x3d572107.
//
// Solidity: function setDelayPeriod(uint256 _period) returns()
func (_Celer *CelerSession) SetDelayPeriod(_period *big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetDelayPeriod(&_Celer.TransactOpts, _period)
}
// SetDelayPeriod is a paid mutator transaction binding the contract method 0x3d572107.
//
// Solidity: function setDelayPeriod(uint256 _period) returns()
func (_Celer *CelerTransactorSession) SetDelayPeriod(_period *big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetDelayPeriod(&_Celer.TransactOpts, _period)
}
// SetDelayThresholds is a paid mutator transaction binding the contract method 0x17bdbae5.
//
// Solidity: function setDelayThresholds(address[] _tokens, uint256[] _thresholds) returns()
func (_Celer *CelerTransactor) SetDelayThresholds(opts *bind.TransactOpts, _tokens []common.Address, _thresholds []*big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "setDelayThresholds", _tokens, _thresholds)
}
// SetDelayThresholds is a paid mutator transaction binding the contract method 0x17bdbae5.
//
// Solidity: function setDelayThresholds(address[] _tokens, uint256[] _thresholds) returns()
func (_Celer *CelerSession) SetDelayThresholds(_tokens []common.Address, _thresholds []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetDelayThresholds(&_Celer.TransactOpts, _tokens, _thresholds)
}
// SetDelayThresholds is a paid mutator transaction binding the contract method 0x17bdbae5.
//
// Solidity: function setDelayThresholds(address[] _tokens, uint256[] _thresholds) returns()
func (_Celer *CelerTransactorSession) SetDelayThresholds(_tokens []common.Address, _thresholds []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetDelayThresholds(&_Celer.TransactOpts, _tokens, _thresholds)
}
// SetEpochLength is a paid mutator transaction binding the contract method 0x54eea796.
//
// Solidity: function setEpochLength(uint256 _length) returns()
func (_Celer *CelerTransactor) SetEpochLength(opts *bind.TransactOpts, _length *big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "setEpochLength", _length)
}
// SetEpochLength is a paid mutator transaction binding the contract method 0x54eea796.
//
// Solidity: function setEpochLength(uint256 _length) returns()
func (_Celer *CelerSession) SetEpochLength(_length *big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetEpochLength(&_Celer.TransactOpts, _length)
}
// SetEpochLength is a paid mutator transaction binding the contract method 0x54eea796.
//
// Solidity: function setEpochLength(uint256 _length) returns()
func (_Celer *CelerTransactorSession) SetEpochLength(_length *big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetEpochLength(&_Celer.TransactOpts, _length)
}
// SetEpochVolumeCaps is a paid mutator transaction binding the contract method 0x47b16c6c.
//
// Solidity: function setEpochVolumeCaps(address[] _tokens, uint256[] _caps) returns()
func (_Celer *CelerTransactor) SetEpochVolumeCaps(opts *bind.TransactOpts, _tokens []common.Address, _caps []*big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "setEpochVolumeCaps", _tokens, _caps)
}
// SetEpochVolumeCaps is a paid mutator transaction binding the contract method 0x47b16c6c.
//
// Solidity: function setEpochVolumeCaps(address[] _tokens, uint256[] _caps) returns()
func (_Celer *CelerSession) SetEpochVolumeCaps(_tokens []common.Address, _caps []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetEpochVolumeCaps(&_Celer.TransactOpts, _tokens, _caps)
}
// SetEpochVolumeCaps is a paid mutator transaction binding the contract method 0x47b16c6c.
//
// Solidity: function setEpochVolumeCaps(address[] _tokens, uint256[] _caps) returns()
func (_Celer *CelerTransactorSession) SetEpochVolumeCaps(_tokens []common.Address, _caps []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetEpochVolumeCaps(&_Celer.TransactOpts, _tokens, _caps)
}
// SetMaxSend is a paid mutator transaction binding the contract method 0x878fe1ce.
//
// Solidity: function setMaxSend(address[] _tokens, uint256[] _amounts) returns()
func (_Celer *CelerTransactor) SetMaxSend(opts *bind.TransactOpts, _tokens []common.Address, _amounts []*big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "setMaxSend", _tokens, _amounts)
}
// SetMaxSend is a paid mutator transaction binding the contract method 0x878fe1ce.
//
// Solidity: function setMaxSend(address[] _tokens, uint256[] _amounts) returns()
func (_Celer *CelerSession) SetMaxSend(_tokens []common.Address, _amounts []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetMaxSend(&_Celer.TransactOpts, _tokens, _amounts)
}
// SetMaxSend is a paid mutator transaction binding the contract method 0x878fe1ce.
//
// Solidity: function setMaxSend(address[] _tokens, uint256[] _amounts) returns()
func (_Celer *CelerTransactorSession) SetMaxSend(_tokens []common.Address, _amounts []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetMaxSend(&_Celer.TransactOpts, _tokens, _amounts)
}
// SetMinAdd is a paid mutator transaction binding the contract method 0xe999e5f4.
//
// Solidity: function setMinAdd(address[] _tokens, uint256[] _amounts) returns()
func (_Celer *CelerTransactor) SetMinAdd(opts *bind.TransactOpts, _tokens []common.Address, _amounts []*big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "setMinAdd", _tokens, _amounts)
}
// SetMinAdd is a paid mutator transaction binding the contract method 0xe999e5f4.
//
// Solidity: function setMinAdd(address[] _tokens, uint256[] _amounts) returns()
func (_Celer *CelerSession) SetMinAdd(_tokens []common.Address, _amounts []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetMinAdd(&_Celer.TransactOpts, _tokens, _amounts)
}
// SetMinAdd is a paid mutator transaction binding the contract method 0xe999e5f4.
//
// Solidity: function setMinAdd(address[] _tokens, uint256[] _amounts) returns()
func (_Celer *CelerTransactorSession) SetMinAdd(_tokens []common.Address, _amounts []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetMinAdd(&_Celer.TransactOpts, _tokens, _amounts)
}
// SetMinSend is a paid mutator transaction binding the contract method 0x08992741.
//
// Solidity: function setMinSend(address[] _tokens, uint256[] _amounts) returns()
func (_Celer *CelerTransactor) SetMinSend(opts *bind.TransactOpts, _tokens []common.Address, _amounts []*big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "setMinSend", _tokens, _amounts)
}
// SetMinSend is a paid mutator transaction binding the contract method 0x08992741.
//
// Solidity: function setMinSend(address[] _tokens, uint256[] _amounts) returns()
func (_Celer *CelerSession) SetMinSend(_tokens []common.Address, _amounts []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetMinSend(&_Celer.TransactOpts, _tokens, _amounts)
}
// SetMinSend is a paid mutator transaction binding the contract method 0x08992741.
//
// Solidity: function setMinSend(address[] _tokens, uint256[] _amounts) returns()
func (_Celer *CelerTransactorSession) SetMinSend(_tokens []common.Address, _amounts []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.SetMinSend(&_Celer.TransactOpts, _tokens, _amounts)
}
// SetMinimalMaxSlippage is a paid mutator transaction binding the contract method 0x48234126.
//
// Solidity: function setMinimalMaxSlippage(uint32 _minimalMaxSlippage) returns()
func (_Celer *CelerTransactor) SetMinimalMaxSlippage(opts *bind.TransactOpts, _minimalMaxSlippage uint32) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "setMinimalMaxSlippage", _minimalMaxSlippage)
}
// SetMinimalMaxSlippage is a paid mutator transaction binding the contract method 0x48234126.
//
// Solidity: function setMinimalMaxSlippage(uint32 _minimalMaxSlippage) returns()
func (_Celer *CelerSession) SetMinimalMaxSlippage(_minimalMaxSlippage uint32) (*types.Transaction, error) {
return _Celer.Contract.SetMinimalMaxSlippage(&_Celer.TransactOpts, _minimalMaxSlippage)
}
// SetMinimalMaxSlippage is a paid mutator transaction binding the contract method 0x48234126.
//
// Solidity: function setMinimalMaxSlippage(uint32 _minimalMaxSlippage) returns()
func (_Celer *CelerTransactorSession) SetMinimalMaxSlippage(_minimalMaxSlippage uint32) (*types.Transaction, error) {
return _Celer.Contract.SetMinimalMaxSlippage(&_Celer.TransactOpts, _minimalMaxSlippage)
}
// SetWrap is a paid mutator transaction binding the contract method 0x9ff9001a.
//
// Solidity: function setWrap(address _weth) returns()
func (_Celer *CelerTransactor) SetWrap(opts *bind.TransactOpts, _weth common.Address) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "setWrap", _weth)
}
// SetWrap is a paid mutator transaction binding the contract method 0x9ff9001a.
//
// Solidity: function setWrap(address _weth) returns()
func (_Celer *CelerSession) SetWrap(_weth common.Address) (*types.Transaction, error) {
return _Celer.Contract.SetWrap(&_Celer.TransactOpts, _weth)
}
// SetWrap is a paid mutator transaction binding the contract method 0x9ff9001a.
//
// Solidity: function setWrap(address _weth) returns()
func (_Celer *CelerTransactorSession) SetWrap(_weth common.Address) (*types.Transaction, error) {
return _Celer.Contract.SetWrap(&_Celer.TransactOpts, _weth)
}
// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_Celer *CelerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "transferOwnership", newOwner)
}
// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_Celer *CelerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
return _Celer.Contract.TransferOwnership(&_Celer.TransactOpts, newOwner)
}
// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_Celer *CelerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
return _Celer.Contract.TransferOwnership(&_Celer.TransactOpts, newOwner)
}
// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.
//
// Solidity: function unpause() returns()
func (_Celer *CelerTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "unpause")
}
// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.
//
// Solidity: function unpause() returns()
func (_Celer *CelerSession) Unpause() (*types.Transaction, error) {
return _Celer.Contract.Unpause(&_Celer.TransactOpts)
}
// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.
//
// Solidity: function unpause() returns()
func (_Celer *CelerTransactorSession) Unpause() (*types.Transaction, error) {
return _Celer.Contract.Unpause(&_Celer.TransactOpts)
}
// UpdateSigners is a paid mutator transaction binding the contract method 0xba2cb25c.
//
// Solidity: function updateSigners(uint256 _triggerTime, address[] _newSigners, uint256[] _newPowers, bytes[] _sigs, address[] _curSigners, uint256[] _curPowers) returns()
func (_Celer *CelerTransactor) UpdateSigners(opts *bind.TransactOpts, _triggerTime *big.Int, _newSigners []common.Address, _newPowers []*big.Int, _sigs [][]byte, _curSigners []common.Address, _curPowers []*big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "updateSigners", _triggerTime, _newSigners, _newPowers, _sigs, _curSigners, _curPowers)
}
// UpdateSigners is a paid mutator transaction binding the contract method 0xba2cb25c.
//
// Solidity: function updateSigners(uint256 _triggerTime, address[] _newSigners, uint256[] _newPowers, bytes[] _sigs, address[] _curSigners, uint256[] _curPowers) returns()
func (_Celer *CelerSession) UpdateSigners(_triggerTime *big.Int, _newSigners []common.Address, _newPowers []*big.Int, _sigs [][]byte, _curSigners []common.Address, _curPowers []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.UpdateSigners(&_Celer.TransactOpts, _triggerTime, _newSigners, _newPowers, _sigs, _curSigners, _curPowers)
}
// UpdateSigners is a paid mutator transaction binding the contract method 0xba2cb25c.
//
// Solidity: function updateSigners(uint256 _triggerTime, address[] _newSigners, uint256[] _newPowers, bytes[] _sigs, address[] _curSigners, uint256[] _curPowers) returns()
func (_Celer *CelerTransactorSession) UpdateSigners(_triggerTime *big.Int, _newSigners []common.Address, _newPowers []*big.Int, _sigs [][]byte, _curSigners []common.Address, _curPowers []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.UpdateSigners(&_Celer.TransactOpts, _triggerTime, _newSigners, _newPowers, _sigs, _curSigners, _curPowers)
}
// Withdraw is a paid mutator transaction binding the contract method 0xa21a9280.
//
// Solidity: function withdraw(bytes _wdmsg, bytes[] _sigs, address[] _signers, uint256[] _powers) returns()
func (_Celer *CelerTransactor) Withdraw(opts *bind.TransactOpts, _wdmsg []byte, _sigs [][]byte, _signers []common.Address, _powers []*big.Int) (*types.Transaction, error) {
return _Celer.contract.Transact(opts, "withdraw", _wdmsg, _sigs, _signers, _powers)
}
// Withdraw is a paid mutator transaction binding the contract method 0xa21a9280.
//
// Solidity: function withdraw(bytes _wdmsg, bytes[] _sigs, address[] _signers, uint256[] _powers) returns()
func (_Celer *CelerSession) Withdraw(_wdmsg []byte, _sigs [][]byte, _signers []common.Address, _powers []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.Withdraw(&_Celer.TransactOpts, _wdmsg, _sigs, _signers, _powers)
}
// Withdraw is a paid mutator transaction binding the contract method 0xa21a9280.
//
// Solidity: function withdraw(bytes _wdmsg, bytes[] _sigs, address[] _signers, uint256[] _powers) returns()
func (_Celer *CelerTransactorSession) Withdraw(_wdmsg []byte, _sigs [][]byte, _signers []common.Address, _powers []*big.Int) (*types.Transaction, error) {
return _Celer.Contract.Withdraw(&_Celer.TransactOpts, _wdmsg, _sigs, _signers, _powers)
}
// Receive is a paid mutator transaction binding the contract receive function.
//
// Solidity: receive() payable returns()
func (_Celer *CelerTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) {
return _Celer.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 (_Celer *CelerSession) Receive() (*types.Transaction, error) {
return _Celer.Contract.Receive(&_Celer.TransactOpts)
}
// Receive is a paid mutator transaction binding the contract receive function.
//
// Solidity: receive() payable returns()
func (_Celer *CelerTransactorSession) Receive() (*types.Transaction, error) {
return _Celer.Contract.Receive(&_Celer.TransactOpts)
}
// CelerDelayPeriodUpdatedIterator is returned from FilterDelayPeriodUpdated and is used to iterate over the raw logs and unpacked data for DelayPeriodUpdated events raised by the Celer contract.
type CelerDelayPeriodUpdatedIterator struct {
Event *CelerDelayPeriodUpdated // 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 *CelerDelayPeriodUpdatedIterator) 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(CelerDelayPeriodUpdated)
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(CelerDelayPeriodUpdated)
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 *CelerDelayPeriodUpdatedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerDelayPeriodUpdatedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerDelayPeriodUpdated represents a DelayPeriodUpdated event raised by the Celer contract.
type CelerDelayPeriodUpdated struct {
Period *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterDelayPeriodUpdated is a free log retrieval operation binding the contract event 0xc0a39f234199b125fb93713c4d067bdcebbf691087f87b79c0feb92b156ba8b6.
//
// Solidity: event DelayPeriodUpdated(uint256 period)
func (_Celer *CelerFilterer) FilterDelayPeriodUpdated(opts *bind.FilterOpts) (*CelerDelayPeriodUpdatedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "DelayPeriodUpdated")
if err != nil {
return nil, err
}
return &CelerDelayPeriodUpdatedIterator{contract: _Celer.contract, event: "DelayPeriodUpdated", logs: logs, sub: sub}, nil
}
// WatchDelayPeriodUpdated is a free log subscription operation binding the contract event 0xc0a39f234199b125fb93713c4d067bdcebbf691087f87b79c0feb92b156ba8b6.
//
// Solidity: event DelayPeriodUpdated(uint256 period)
func (_Celer *CelerFilterer) WatchDelayPeriodUpdated(opts *bind.WatchOpts, sink chan<- *CelerDelayPeriodUpdated) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "DelayPeriodUpdated")
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(CelerDelayPeriodUpdated)
if err := _Celer.contract.UnpackLog(event, "DelayPeriodUpdated", 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
}
// ParseDelayPeriodUpdated is a log parse operation binding the contract event 0xc0a39f234199b125fb93713c4d067bdcebbf691087f87b79c0feb92b156ba8b6.
//
// Solidity: event DelayPeriodUpdated(uint256 period)
func (_Celer *CelerFilterer) ParseDelayPeriodUpdated(log types.Log) (*CelerDelayPeriodUpdated, error) {
event := new(CelerDelayPeriodUpdated)
if err := _Celer.contract.UnpackLog(event, "DelayPeriodUpdated", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerDelayThresholdUpdatedIterator is returned from FilterDelayThresholdUpdated and is used to iterate over the raw logs and unpacked data for DelayThresholdUpdated events raised by the Celer contract.
type CelerDelayThresholdUpdatedIterator struct {
Event *CelerDelayThresholdUpdated // 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 *CelerDelayThresholdUpdatedIterator) 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(CelerDelayThresholdUpdated)
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(CelerDelayThresholdUpdated)
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 *CelerDelayThresholdUpdatedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerDelayThresholdUpdatedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerDelayThresholdUpdated represents a DelayThresholdUpdated event raised by the Celer contract.
type CelerDelayThresholdUpdated struct {
Token common.Address
Threshold *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterDelayThresholdUpdated is a free log retrieval operation binding the contract event 0xceaad6533bfb481492fb3e08ef19297f46611b8fa9de5ef4cf8dc23a56ad09ce.
//
// Solidity: event DelayThresholdUpdated(address token, uint256 threshold)
func (_Celer *CelerFilterer) FilterDelayThresholdUpdated(opts *bind.FilterOpts) (*CelerDelayThresholdUpdatedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "DelayThresholdUpdated")
if err != nil {
return nil, err
}
return &CelerDelayThresholdUpdatedIterator{contract: _Celer.contract, event: "DelayThresholdUpdated", logs: logs, sub: sub}, nil
}
// WatchDelayThresholdUpdated is a free log subscription operation binding the contract event 0xceaad6533bfb481492fb3e08ef19297f46611b8fa9de5ef4cf8dc23a56ad09ce.
//
// Solidity: event DelayThresholdUpdated(address token, uint256 threshold)
func (_Celer *CelerFilterer) WatchDelayThresholdUpdated(opts *bind.WatchOpts, sink chan<- *CelerDelayThresholdUpdated) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "DelayThresholdUpdated")
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(CelerDelayThresholdUpdated)
if err := _Celer.contract.UnpackLog(event, "DelayThresholdUpdated", 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
}
// ParseDelayThresholdUpdated is a log parse operation binding the contract event 0xceaad6533bfb481492fb3e08ef19297f46611b8fa9de5ef4cf8dc23a56ad09ce.
//
// Solidity: event DelayThresholdUpdated(address token, uint256 threshold)
func (_Celer *CelerFilterer) ParseDelayThresholdUpdated(log types.Log) (*CelerDelayThresholdUpdated, error) {
event := new(CelerDelayThresholdUpdated)
if err := _Celer.contract.UnpackLog(event, "DelayThresholdUpdated", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerDelayedTransferAddedIterator is returned from FilterDelayedTransferAdded and is used to iterate over the raw logs and unpacked data for DelayedTransferAdded events raised by the Celer contract.
type CelerDelayedTransferAddedIterator struct {
Event *CelerDelayedTransferAdded // 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 *CelerDelayedTransferAddedIterator) 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(CelerDelayedTransferAdded)
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(CelerDelayedTransferAdded)
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 *CelerDelayedTransferAddedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerDelayedTransferAddedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerDelayedTransferAdded represents a DelayedTransferAdded event raised by the Celer contract.
type CelerDelayedTransferAdded struct {
Id [32]byte
Raw types.Log // Blockchain specific contextual infos
}
// FilterDelayedTransferAdded is a free log retrieval operation binding the contract event 0xcbcfffe5102114216a85d3aceb14ad4b81a3935b1b5c468fadf3889eb9c5dce6.
//
// Solidity: event DelayedTransferAdded(bytes32 id)
func (_Celer *CelerFilterer) FilterDelayedTransferAdded(opts *bind.FilterOpts) (*CelerDelayedTransferAddedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "DelayedTransferAdded")
if err != nil {
return nil, err
}
return &CelerDelayedTransferAddedIterator{contract: _Celer.contract, event: "DelayedTransferAdded", logs: logs, sub: sub}, nil
}
// WatchDelayedTransferAdded is a free log subscription operation binding the contract event 0xcbcfffe5102114216a85d3aceb14ad4b81a3935b1b5c468fadf3889eb9c5dce6.
//
// Solidity: event DelayedTransferAdded(bytes32 id)
func (_Celer *CelerFilterer) WatchDelayedTransferAdded(opts *bind.WatchOpts, sink chan<- *CelerDelayedTransferAdded) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "DelayedTransferAdded")
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(CelerDelayedTransferAdded)
if err := _Celer.contract.UnpackLog(event, "DelayedTransferAdded", 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
}
// ParseDelayedTransferAdded is a log parse operation binding the contract event 0xcbcfffe5102114216a85d3aceb14ad4b81a3935b1b5c468fadf3889eb9c5dce6.
//
// Solidity: event DelayedTransferAdded(bytes32 id)
func (_Celer *CelerFilterer) ParseDelayedTransferAdded(log types.Log) (*CelerDelayedTransferAdded, error) {
event := new(CelerDelayedTransferAdded)
if err := _Celer.contract.UnpackLog(event, "DelayedTransferAdded", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerDelayedTransferExecutedIterator is returned from FilterDelayedTransferExecuted and is used to iterate over the raw logs and unpacked data for DelayedTransferExecuted events raised by the Celer contract.
type CelerDelayedTransferExecutedIterator struct {
Event *CelerDelayedTransferExecuted // 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 *CelerDelayedTransferExecutedIterator) 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(CelerDelayedTransferExecuted)
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(CelerDelayedTransferExecuted)
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 *CelerDelayedTransferExecutedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerDelayedTransferExecutedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerDelayedTransferExecuted represents a DelayedTransferExecuted event raised by the Celer contract.
type CelerDelayedTransferExecuted struct {
Id [32]byte
Receiver common.Address
Token common.Address
Amount *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterDelayedTransferExecuted is a free log retrieval operation binding the contract event 0x3b40e5089937425d14cdd96947e5661868357e224af59bd8b24a4b8a330d4426.
//
// Solidity: event DelayedTransferExecuted(bytes32 id, address receiver, address token, uint256 amount)
func (_Celer *CelerFilterer) FilterDelayedTransferExecuted(opts *bind.FilterOpts) (*CelerDelayedTransferExecutedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "DelayedTransferExecuted")
if err != nil {
return nil, err
}
return &CelerDelayedTransferExecutedIterator{contract: _Celer.contract, event: "DelayedTransferExecuted", logs: logs, sub: sub}, nil
}
// WatchDelayedTransferExecuted is a free log subscription operation binding the contract event 0x3b40e5089937425d14cdd96947e5661868357e224af59bd8b24a4b8a330d4426.
//
// Solidity: event DelayedTransferExecuted(bytes32 id, address receiver, address token, uint256 amount)
func (_Celer *CelerFilterer) WatchDelayedTransferExecuted(opts *bind.WatchOpts, sink chan<- *CelerDelayedTransferExecuted) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "DelayedTransferExecuted")
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(CelerDelayedTransferExecuted)
if err := _Celer.contract.UnpackLog(event, "DelayedTransferExecuted", 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
}
// ParseDelayedTransferExecuted is a log parse operation binding the contract event 0x3b40e5089937425d14cdd96947e5661868357e224af59bd8b24a4b8a330d4426.
//
// Solidity: event DelayedTransferExecuted(bytes32 id, address receiver, address token, uint256 amount)
func (_Celer *CelerFilterer) ParseDelayedTransferExecuted(log types.Log) (*CelerDelayedTransferExecuted, error) {
event := new(CelerDelayedTransferExecuted)
if err := _Celer.contract.UnpackLog(event, "DelayedTransferExecuted", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerEpochLengthUpdatedIterator is returned from FilterEpochLengthUpdated and is used to iterate over the raw logs and unpacked data for EpochLengthUpdated events raised by the Celer contract.
type CelerEpochLengthUpdatedIterator struct {
Event *CelerEpochLengthUpdated // 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 *CelerEpochLengthUpdatedIterator) 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(CelerEpochLengthUpdated)
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(CelerEpochLengthUpdated)
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 *CelerEpochLengthUpdatedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerEpochLengthUpdatedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerEpochLengthUpdated represents a EpochLengthUpdated event raised by the Celer contract.
type CelerEpochLengthUpdated struct {
Length *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterEpochLengthUpdated is a free log retrieval operation binding the contract event 0x2664fec2ff76486ac58ed087310855b648b15b9d19f3de8529e95f7c46b7d6b3.
//
// Solidity: event EpochLengthUpdated(uint256 length)
func (_Celer *CelerFilterer) FilterEpochLengthUpdated(opts *bind.FilterOpts) (*CelerEpochLengthUpdatedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "EpochLengthUpdated")
if err != nil {
return nil, err
}
return &CelerEpochLengthUpdatedIterator{contract: _Celer.contract, event: "EpochLengthUpdated", logs: logs, sub: sub}, nil
}
// WatchEpochLengthUpdated is a free log subscription operation binding the contract event 0x2664fec2ff76486ac58ed087310855b648b15b9d19f3de8529e95f7c46b7d6b3.
//
// Solidity: event EpochLengthUpdated(uint256 length)
func (_Celer *CelerFilterer) WatchEpochLengthUpdated(opts *bind.WatchOpts, sink chan<- *CelerEpochLengthUpdated) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "EpochLengthUpdated")
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(CelerEpochLengthUpdated)
if err := _Celer.contract.UnpackLog(event, "EpochLengthUpdated", 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
}
// ParseEpochLengthUpdated is a log parse operation binding the contract event 0x2664fec2ff76486ac58ed087310855b648b15b9d19f3de8529e95f7c46b7d6b3.
//
// Solidity: event EpochLengthUpdated(uint256 length)
func (_Celer *CelerFilterer) ParseEpochLengthUpdated(log types.Log) (*CelerEpochLengthUpdated, error) {
event := new(CelerEpochLengthUpdated)
if err := _Celer.contract.UnpackLog(event, "EpochLengthUpdated", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerEpochVolumeUpdatedIterator is returned from FilterEpochVolumeUpdated and is used to iterate over the raw logs and unpacked data for EpochVolumeUpdated events raised by the Celer contract.
type CelerEpochVolumeUpdatedIterator struct {
Event *CelerEpochVolumeUpdated // 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 *CelerEpochVolumeUpdatedIterator) 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(CelerEpochVolumeUpdated)
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(CelerEpochVolumeUpdated)
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 *CelerEpochVolumeUpdatedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerEpochVolumeUpdatedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerEpochVolumeUpdated represents a EpochVolumeUpdated event raised by the Celer contract.
type CelerEpochVolumeUpdated struct {
Token common.Address
Cap *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterEpochVolumeUpdated is a free log retrieval operation binding the contract event 0x608e49c22994f20b5d3496dca088b88dfd81b4a3e8cc3809ea1e10a320107e89.
//
// Solidity: event EpochVolumeUpdated(address token, uint256 cap)
func (_Celer *CelerFilterer) FilterEpochVolumeUpdated(opts *bind.FilterOpts) (*CelerEpochVolumeUpdatedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "EpochVolumeUpdated")
if err != nil {
return nil, err
}
return &CelerEpochVolumeUpdatedIterator{contract: _Celer.contract, event: "EpochVolumeUpdated", logs: logs, sub: sub}, nil
}
// WatchEpochVolumeUpdated is a free log subscription operation binding the contract event 0x608e49c22994f20b5d3496dca088b88dfd81b4a3e8cc3809ea1e10a320107e89.
//
// Solidity: event EpochVolumeUpdated(address token, uint256 cap)
func (_Celer *CelerFilterer) WatchEpochVolumeUpdated(opts *bind.WatchOpts, sink chan<- *CelerEpochVolumeUpdated) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "EpochVolumeUpdated")
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(CelerEpochVolumeUpdated)
if err := _Celer.contract.UnpackLog(event, "EpochVolumeUpdated", 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
}
// ParseEpochVolumeUpdated is a log parse operation binding the contract event 0x608e49c22994f20b5d3496dca088b88dfd81b4a3e8cc3809ea1e10a320107e89.
//
// Solidity: event EpochVolumeUpdated(address token, uint256 cap)
func (_Celer *CelerFilterer) ParseEpochVolumeUpdated(log types.Log) (*CelerEpochVolumeUpdated, error) {
event := new(CelerEpochVolumeUpdated)
if err := _Celer.contract.UnpackLog(event, "EpochVolumeUpdated", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerGovernorAddedIterator is returned from FilterGovernorAdded and is used to iterate over the raw logs and unpacked data for GovernorAdded events raised by the Celer contract.
type CelerGovernorAddedIterator struct {
Event *CelerGovernorAdded // 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 *CelerGovernorAddedIterator) 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(CelerGovernorAdded)
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(CelerGovernorAdded)
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 *CelerGovernorAddedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerGovernorAddedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerGovernorAdded represents a GovernorAdded event raised by the Celer contract.
type CelerGovernorAdded struct {
Account common.Address
Raw types.Log // Blockchain specific contextual infos
}
// FilterGovernorAdded is a free log retrieval operation binding the contract event 0xdc5a48d79e2e147530ff63ecdbed5a5a66adb9d5cf339384d5d076da197c40b5.
//
// Solidity: event GovernorAdded(address account)
func (_Celer *CelerFilterer) FilterGovernorAdded(opts *bind.FilterOpts) (*CelerGovernorAddedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "GovernorAdded")
if err != nil {
return nil, err
}
return &CelerGovernorAddedIterator{contract: _Celer.contract, event: "GovernorAdded", logs: logs, sub: sub}, nil
}
// WatchGovernorAdded is a free log subscription operation binding the contract event 0xdc5a48d79e2e147530ff63ecdbed5a5a66adb9d5cf339384d5d076da197c40b5.
//
// Solidity: event GovernorAdded(address account)
func (_Celer *CelerFilterer) WatchGovernorAdded(opts *bind.WatchOpts, sink chan<- *CelerGovernorAdded) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "GovernorAdded")
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(CelerGovernorAdded)
if err := _Celer.contract.UnpackLog(event, "GovernorAdded", 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
}
// ParseGovernorAdded is a log parse operation binding the contract event 0xdc5a48d79e2e147530ff63ecdbed5a5a66adb9d5cf339384d5d076da197c40b5.
//
// Solidity: event GovernorAdded(address account)
func (_Celer *CelerFilterer) ParseGovernorAdded(log types.Log) (*CelerGovernorAdded, error) {
event := new(CelerGovernorAdded)
if err := _Celer.contract.UnpackLog(event, "GovernorAdded", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerGovernorRemovedIterator is returned from FilterGovernorRemoved and is used to iterate over the raw logs and unpacked data for GovernorRemoved events raised by the Celer contract.
type CelerGovernorRemovedIterator struct {
Event *CelerGovernorRemoved // 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 *CelerGovernorRemovedIterator) 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(CelerGovernorRemoved)
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(CelerGovernorRemoved)
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 *CelerGovernorRemovedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerGovernorRemovedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerGovernorRemoved represents a GovernorRemoved event raised by the Celer contract.
type CelerGovernorRemoved struct {
Account common.Address
Raw types.Log // Blockchain specific contextual infos
}
// FilterGovernorRemoved is a free log retrieval operation binding the contract event 0x1ebe834e73d60a5fec822c1e1727d34bc79f2ad977ed504581cc1822fe20fb5b.
//
// Solidity: event GovernorRemoved(address account)
func (_Celer *CelerFilterer) FilterGovernorRemoved(opts *bind.FilterOpts) (*CelerGovernorRemovedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "GovernorRemoved")
if err != nil {
return nil, err
}
return &CelerGovernorRemovedIterator{contract: _Celer.contract, event: "GovernorRemoved", logs: logs, sub: sub}, nil
}
// WatchGovernorRemoved is a free log subscription operation binding the contract event 0x1ebe834e73d60a5fec822c1e1727d34bc79f2ad977ed504581cc1822fe20fb5b.
//
// Solidity: event GovernorRemoved(address account)
func (_Celer *CelerFilterer) WatchGovernorRemoved(opts *bind.WatchOpts, sink chan<- *CelerGovernorRemoved) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "GovernorRemoved")
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(CelerGovernorRemoved)
if err := _Celer.contract.UnpackLog(event, "GovernorRemoved", 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
}
// ParseGovernorRemoved is a log parse operation binding the contract event 0x1ebe834e73d60a5fec822c1e1727d34bc79f2ad977ed504581cc1822fe20fb5b.
//
// Solidity: event GovernorRemoved(address account)
func (_Celer *CelerFilterer) ParseGovernorRemoved(log types.Log) (*CelerGovernorRemoved, error) {
event := new(CelerGovernorRemoved)
if err := _Celer.contract.UnpackLog(event, "GovernorRemoved", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerLiquidityAddedIterator is returned from FilterLiquidityAdded and is used to iterate over the raw logs and unpacked data for LiquidityAdded events raised by the Celer contract.
type CelerLiquidityAddedIterator struct {
Event *CelerLiquidityAdded // 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 *CelerLiquidityAddedIterator) 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(CelerLiquidityAdded)
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(CelerLiquidityAdded)
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 *CelerLiquidityAddedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerLiquidityAddedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerLiquidityAdded represents a LiquidityAdded event raised by the Celer contract.
type CelerLiquidityAdded struct {
Seqnum uint64
Provider common.Address
Token common.Address
Amount *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterLiquidityAdded is a free log retrieval operation binding the contract event 0xd5d28426c3248963b1719df49aa4c665120372e02c8249bbea03d019c39ce764.
//
// Solidity: event LiquidityAdded(uint64 seqnum, address provider, address token, uint256 amount)
func (_Celer *CelerFilterer) FilterLiquidityAdded(opts *bind.FilterOpts) (*CelerLiquidityAddedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "LiquidityAdded")
if err != nil {
return nil, err
}
return &CelerLiquidityAddedIterator{contract: _Celer.contract, event: "LiquidityAdded", logs: logs, sub: sub}, nil
}
// WatchLiquidityAdded is a free log subscription operation binding the contract event 0xd5d28426c3248963b1719df49aa4c665120372e02c8249bbea03d019c39ce764.
//
// Solidity: event LiquidityAdded(uint64 seqnum, address provider, address token, uint256 amount)
func (_Celer *CelerFilterer) WatchLiquidityAdded(opts *bind.WatchOpts, sink chan<- *CelerLiquidityAdded) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "LiquidityAdded")
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(CelerLiquidityAdded)
if err := _Celer.contract.UnpackLog(event, "LiquidityAdded", 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
}
// ParseLiquidityAdded is a log parse operation binding the contract event 0xd5d28426c3248963b1719df49aa4c665120372e02c8249bbea03d019c39ce764.
//
// Solidity: event LiquidityAdded(uint64 seqnum, address provider, address token, uint256 amount)
func (_Celer *CelerFilterer) ParseLiquidityAdded(log types.Log) (*CelerLiquidityAdded, error) {
event := new(CelerLiquidityAdded)
if err := _Celer.contract.UnpackLog(event, "LiquidityAdded", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerMaxSendUpdatedIterator is returned from FilterMaxSendUpdated and is used to iterate over the raw logs and unpacked data for MaxSendUpdated events raised by the Celer contract.
type CelerMaxSendUpdatedIterator struct {
Event *CelerMaxSendUpdated // 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 *CelerMaxSendUpdatedIterator) 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(CelerMaxSendUpdated)
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(CelerMaxSendUpdated)
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 *CelerMaxSendUpdatedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerMaxSendUpdatedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerMaxSendUpdated represents a MaxSendUpdated event raised by the Celer contract.
type CelerMaxSendUpdated struct {
Token common.Address
Amount *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterMaxSendUpdated is a free log retrieval operation binding the contract event 0x4f12d1a5bfb3ccd3719255d4d299d808d50cdca9a0a5c2b3a5aaa7edde73052c.
//
// Solidity: event MaxSendUpdated(address token, uint256 amount)
func (_Celer *CelerFilterer) FilterMaxSendUpdated(opts *bind.FilterOpts) (*CelerMaxSendUpdatedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "MaxSendUpdated")
if err != nil {
return nil, err
}
return &CelerMaxSendUpdatedIterator{contract: _Celer.contract, event: "MaxSendUpdated", logs: logs, sub: sub}, nil
}
// WatchMaxSendUpdated is a free log subscription operation binding the contract event 0x4f12d1a5bfb3ccd3719255d4d299d808d50cdca9a0a5c2b3a5aaa7edde73052c.
//
// Solidity: event MaxSendUpdated(address token, uint256 amount)
func (_Celer *CelerFilterer) WatchMaxSendUpdated(opts *bind.WatchOpts, sink chan<- *CelerMaxSendUpdated) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "MaxSendUpdated")
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(CelerMaxSendUpdated)
if err := _Celer.contract.UnpackLog(event, "MaxSendUpdated", 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
}
// ParseMaxSendUpdated is a log parse operation binding the contract event 0x4f12d1a5bfb3ccd3719255d4d299d808d50cdca9a0a5c2b3a5aaa7edde73052c.
//
// Solidity: event MaxSendUpdated(address token, uint256 amount)
func (_Celer *CelerFilterer) ParseMaxSendUpdated(log types.Log) (*CelerMaxSendUpdated, error) {
event := new(CelerMaxSendUpdated)
if err := _Celer.contract.UnpackLog(event, "MaxSendUpdated", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerMinAddUpdatedIterator is returned from FilterMinAddUpdated and is used to iterate over the raw logs and unpacked data for MinAddUpdated events raised by the Celer contract.
type CelerMinAddUpdatedIterator struct {
Event *CelerMinAddUpdated // 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 *CelerMinAddUpdatedIterator) 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(CelerMinAddUpdated)
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(CelerMinAddUpdated)
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 *CelerMinAddUpdatedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerMinAddUpdatedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerMinAddUpdated represents a MinAddUpdated event raised by the Celer contract.
type CelerMinAddUpdated struct {
Token common.Address
Amount *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterMinAddUpdated is a free log retrieval operation binding the contract event 0xc56b0d14c4940515800d94ebbd0f3f5d8cc58ba1109c12536bd993b72e466e4f.
//
// Solidity: event MinAddUpdated(address token, uint256 amount)
func (_Celer *CelerFilterer) FilterMinAddUpdated(opts *bind.FilterOpts) (*CelerMinAddUpdatedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "MinAddUpdated")
if err != nil {
return nil, err
}
return &CelerMinAddUpdatedIterator{contract: _Celer.contract, event: "MinAddUpdated", logs: logs, sub: sub}, nil
}
// WatchMinAddUpdated is a free log subscription operation binding the contract event 0xc56b0d14c4940515800d94ebbd0f3f5d8cc58ba1109c12536bd993b72e466e4f.
//
// Solidity: event MinAddUpdated(address token, uint256 amount)
func (_Celer *CelerFilterer) WatchMinAddUpdated(opts *bind.WatchOpts, sink chan<- *CelerMinAddUpdated) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "MinAddUpdated")
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(CelerMinAddUpdated)
if err := _Celer.contract.UnpackLog(event, "MinAddUpdated", 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
}
// ParseMinAddUpdated is a log parse operation binding the contract event 0xc56b0d14c4940515800d94ebbd0f3f5d8cc58ba1109c12536bd993b72e466e4f.
//
// Solidity: event MinAddUpdated(address token, uint256 amount)
func (_Celer *CelerFilterer) ParseMinAddUpdated(log types.Log) (*CelerMinAddUpdated, error) {
event := new(CelerMinAddUpdated)
if err := _Celer.contract.UnpackLog(event, "MinAddUpdated", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerMinSendUpdatedIterator is returned from FilterMinSendUpdated and is used to iterate over the raw logs and unpacked data for MinSendUpdated events raised by the Celer contract.
type CelerMinSendUpdatedIterator struct {
Event *CelerMinSendUpdated // 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 *CelerMinSendUpdatedIterator) 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(CelerMinSendUpdated)
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(CelerMinSendUpdated)
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 *CelerMinSendUpdatedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerMinSendUpdatedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerMinSendUpdated represents a MinSendUpdated event raised by the Celer contract.
type CelerMinSendUpdated struct {
Token common.Address
Amount *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterMinSendUpdated is a free log retrieval operation binding the contract event 0x8b59d386e660418a48d742213ad5ce7c4dd51ae81f30e4e2c387f17d907010c9.
//
// Solidity: event MinSendUpdated(address token, uint256 amount)
func (_Celer *CelerFilterer) FilterMinSendUpdated(opts *bind.FilterOpts) (*CelerMinSendUpdatedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "MinSendUpdated")
if err != nil {
return nil, err
}
return &CelerMinSendUpdatedIterator{contract: _Celer.contract, event: "MinSendUpdated", logs: logs, sub: sub}, nil
}
// WatchMinSendUpdated is a free log subscription operation binding the contract event 0x8b59d386e660418a48d742213ad5ce7c4dd51ae81f30e4e2c387f17d907010c9.
//
// Solidity: event MinSendUpdated(address token, uint256 amount)
func (_Celer *CelerFilterer) WatchMinSendUpdated(opts *bind.WatchOpts, sink chan<- *CelerMinSendUpdated) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "MinSendUpdated")
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(CelerMinSendUpdated)
if err := _Celer.contract.UnpackLog(event, "MinSendUpdated", 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
}
// ParseMinSendUpdated is a log parse operation binding the contract event 0x8b59d386e660418a48d742213ad5ce7c4dd51ae81f30e4e2c387f17d907010c9.
//
// Solidity: event MinSendUpdated(address token, uint256 amount)
func (_Celer *CelerFilterer) ParseMinSendUpdated(log types.Log) (*CelerMinSendUpdated, error) {
event := new(CelerMinSendUpdated)
if err := _Celer.contract.UnpackLog(event, "MinSendUpdated", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Celer contract.
type CelerOwnershipTransferredIterator struct {
Event *CelerOwnershipTransferred // 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 *CelerOwnershipTransferredIterator) 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(CelerOwnershipTransferred)
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(CelerOwnershipTransferred)
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 *CelerOwnershipTransferredIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerOwnershipTransferredIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerOwnershipTransferred represents a OwnershipTransferred event raised by the Celer contract.
type CelerOwnershipTransferred struct {
PreviousOwner common.Address
NewOwner common.Address
Raw types.Log // Blockchain specific contextual infos
}
// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_Celer *CelerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*CelerOwnershipTransferredIterator, error) {
var previousOwnerRule []interface{}
for _, previousOwnerItem := range previousOwner {
previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
}
var newOwnerRule []interface{}
for _, newOwnerItem := range newOwner {
newOwnerRule = append(newOwnerRule, newOwnerItem)
}
logs, sub, err := _Celer.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
if err != nil {
return nil, err
}
return &CelerOwnershipTransferredIterator{contract: _Celer.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}
// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_Celer *CelerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *CelerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
var previousOwnerRule []interface{}
for _, previousOwnerItem := range previousOwner {
previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
}
var newOwnerRule []interface{}
for _, newOwnerItem := range newOwner {
newOwnerRule = append(newOwnerRule, newOwnerItem)
}
logs, sub, err := _Celer.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
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(CelerOwnershipTransferred)
if err := _Celer.contract.UnpackLog(event, "OwnershipTransferred", 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
}
// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_Celer *CelerFilterer) ParseOwnershipTransferred(log types.Log) (*CelerOwnershipTransferred, error) {
event := new(CelerOwnershipTransferred)
if err := _Celer.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the Celer contract.
type CelerPausedIterator struct {
Event *CelerPaused // 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 *CelerPausedIterator) 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(CelerPaused)
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(CelerPaused)
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 *CelerPausedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerPausedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerPaused represents a Paused event raised by the Celer contract.
type CelerPaused struct {
Account common.Address
Raw types.Log // Blockchain specific contextual infos
}
// FilterPaused is a free log retrieval operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.
//
// Solidity: event Paused(address account)
func (_Celer *CelerFilterer) FilterPaused(opts *bind.FilterOpts) (*CelerPausedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "Paused")
if err != nil {
return nil, err
}
return &CelerPausedIterator{contract: _Celer.contract, event: "Paused", logs: logs, sub: sub}, nil
}
// WatchPaused is a free log subscription operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.
//
// Solidity: event Paused(address account)
func (_Celer *CelerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *CelerPaused) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "Paused")
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(CelerPaused)
if err := _Celer.contract.UnpackLog(event, "Paused", 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
}
// ParsePaused is a log parse operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.
//
// Solidity: event Paused(address account)
func (_Celer *CelerFilterer) ParsePaused(log types.Log) (*CelerPaused, error) {
event := new(CelerPaused)
if err := _Celer.contract.UnpackLog(event, "Paused", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerPauserAddedIterator is returned from FilterPauserAdded and is used to iterate over the raw logs and unpacked data for PauserAdded events raised by the Celer contract.
type CelerPauserAddedIterator struct {
Event *CelerPauserAdded // 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 *CelerPauserAddedIterator) 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(CelerPauserAdded)
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(CelerPauserAdded)
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 *CelerPauserAddedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerPauserAddedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerPauserAdded represents a PauserAdded event raised by the Celer contract.
type CelerPauserAdded struct {
Account common.Address
Raw types.Log // Blockchain specific contextual infos
}
// FilterPauserAdded is a free log retrieval operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address account)
func (_Celer *CelerFilterer) FilterPauserAdded(opts *bind.FilterOpts) (*CelerPauserAddedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "PauserAdded")
if err != nil {
return nil, err
}
return &CelerPauserAddedIterator{contract: _Celer.contract, event: "PauserAdded", logs: logs, sub: sub}, nil
}
// WatchPauserAdded is a free log subscription operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address account)
func (_Celer *CelerFilterer) WatchPauserAdded(opts *bind.WatchOpts, sink chan<- *CelerPauserAdded) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "PauserAdded")
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(CelerPauserAdded)
if err := _Celer.contract.UnpackLog(event, "PauserAdded", 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
}
// ParsePauserAdded is a log parse operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8.
//
// Solidity: event PauserAdded(address account)
func (_Celer *CelerFilterer) ParsePauserAdded(log types.Log) (*CelerPauserAdded, error) {
event := new(CelerPauserAdded)
if err := _Celer.contract.UnpackLog(event, "PauserAdded", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerPauserRemovedIterator is returned from FilterPauserRemoved and is used to iterate over the raw logs and unpacked data for PauserRemoved events raised by the Celer contract.
type CelerPauserRemovedIterator struct {
Event *CelerPauserRemoved // 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 *CelerPauserRemovedIterator) 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(CelerPauserRemoved)
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(CelerPauserRemoved)
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 *CelerPauserRemovedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerPauserRemovedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerPauserRemoved represents a PauserRemoved event raised by the Celer contract.
type CelerPauserRemoved struct {
Account common.Address
Raw types.Log // Blockchain specific contextual infos
}
// FilterPauserRemoved is a free log retrieval operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address account)
func (_Celer *CelerFilterer) FilterPauserRemoved(opts *bind.FilterOpts) (*CelerPauserRemovedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "PauserRemoved")
if err != nil {
return nil, err
}
return &CelerPauserRemovedIterator{contract: _Celer.contract, event: "PauserRemoved", logs: logs, sub: sub}, nil
}
// WatchPauserRemoved is a free log subscription operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address account)
func (_Celer *CelerFilterer) WatchPauserRemoved(opts *bind.WatchOpts, sink chan<- *CelerPauserRemoved) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "PauserRemoved")
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(CelerPauserRemoved)
if err := _Celer.contract.UnpackLog(event, "PauserRemoved", 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
}
// ParsePauserRemoved is a log parse operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e.
//
// Solidity: event PauserRemoved(address account)
func (_Celer *CelerFilterer) ParsePauserRemoved(log types.Log) (*CelerPauserRemoved, error) {
event := new(CelerPauserRemoved)
if err := _Celer.contract.UnpackLog(event, "PauserRemoved", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerRelayIterator is returned from FilterRelay and is used to iterate over the raw logs and unpacked data for Relay events raised by the Celer contract.
type CelerRelayIterator struct {
Event *CelerRelay // 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 *CelerRelayIterator) 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(CelerRelay)
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(CelerRelay)
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 *CelerRelayIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerRelayIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerRelay represents a Relay event raised by the Celer contract.
type CelerRelay struct {
TransferId [32]byte
Sender common.Address
Receiver common.Address
Token common.Address
Amount *big.Int
SrcChainId uint64
SrcTransferId [32]byte
Raw types.Log // Blockchain specific contextual infos
}
// FilterRelay is a free log retrieval operation binding the contract event 0x79fa08de5149d912dce8e5e8da7a7c17ccdf23dd5d3bfe196802e6eb86347c7c.
//
// Solidity: event Relay(bytes32 transferId, address sender, address receiver, address token, uint256 amount, uint64 srcChainId, bytes32 srcTransferId)
func (_Celer *CelerFilterer) FilterRelay(opts *bind.FilterOpts) (*CelerRelayIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "Relay")
if err != nil {
return nil, err
}
return &CelerRelayIterator{contract: _Celer.contract, event: "Relay", logs: logs, sub: sub}, nil
}
// WatchRelay is a free log subscription operation binding the contract event 0x79fa08de5149d912dce8e5e8da7a7c17ccdf23dd5d3bfe196802e6eb86347c7c.
//
// Solidity: event Relay(bytes32 transferId, address sender, address receiver, address token, uint256 amount, uint64 srcChainId, bytes32 srcTransferId)
func (_Celer *CelerFilterer) WatchRelay(opts *bind.WatchOpts, sink chan<- *CelerRelay) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "Relay")
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(CelerRelay)
if err := _Celer.contract.UnpackLog(event, "Relay", 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
}
// ParseRelay is a log parse operation binding the contract event 0x79fa08de5149d912dce8e5e8da7a7c17ccdf23dd5d3bfe196802e6eb86347c7c.
//
// Solidity: event Relay(bytes32 transferId, address sender, address receiver, address token, uint256 amount, uint64 srcChainId, bytes32 srcTransferId)
func (_Celer *CelerFilterer) ParseRelay(log types.Log) (*CelerRelay, error) {
event := new(CelerRelay)
if err := _Celer.contract.UnpackLog(event, "Relay", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerResetNotificationIterator is returned from FilterResetNotification and is used to iterate over the raw logs and unpacked data for ResetNotification events raised by the Celer contract.
type CelerResetNotificationIterator struct {
Event *CelerResetNotification // 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 *CelerResetNotificationIterator) 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(CelerResetNotification)
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(CelerResetNotification)
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 *CelerResetNotificationIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerResetNotificationIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerResetNotification represents a ResetNotification event raised by the Celer contract.
type CelerResetNotification struct {
ResetTime *big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterResetNotification is a free log retrieval operation binding the contract event 0x68e825132f7d4bc837dea2d64ac9fc19912bf0224b67f9317d8f1a917f5304a1.
//
// Solidity: event ResetNotification(uint256 resetTime)
func (_Celer *CelerFilterer) FilterResetNotification(opts *bind.FilterOpts) (*CelerResetNotificationIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "ResetNotification")
if err != nil {
return nil, err
}
return &CelerResetNotificationIterator{contract: _Celer.contract, event: "ResetNotification", logs: logs, sub: sub}, nil
}
// WatchResetNotification is a free log subscription operation binding the contract event 0x68e825132f7d4bc837dea2d64ac9fc19912bf0224b67f9317d8f1a917f5304a1.
//
// Solidity: event ResetNotification(uint256 resetTime)
func (_Celer *CelerFilterer) WatchResetNotification(opts *bind.WatchOpts, sink chan<- *CelerResetNotification) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "ResetNotification")
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(CelerResetNotification)
if err := _Celer.contract.UnpackLog(event, "ResetNotification", 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
}
// ParseResetNotification is a log parse operation binding the contract event 0x68e825132f7d4bc837dea2d64ac9fc19912bf0224b67f9317d8f1a917f5304a1.
//
// Solidity: event ResetNotification(uint256 resetTime)
func (_Celer *CelerFilterer) ParseResetNotification(log types.Log) (*CelerResetNotification, error) {
event := new(CelerResetNotification)
if err := _Celer.contract.UnpackLog(event, "ResetNotification", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerSendIterator is returned from FilterSend and is used to iterate over the raw logs and unpacked data for Send events raised by the Celer contract.
type CelerSendIterator struct {
Event *CelerSend // 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 *CelerSendIterator) 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(CelerSend)
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(CelerSend)
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 *CelerSendIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerSendIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerSend represents a Send event raised by the Celer contract.
type CelerSend struct {
TransferId [32]byte
Sender common.Address
Receiver common.Address
Token common.Address
Amount *big.Int
DstChainId uint64
Nonce uint64
MaxSlippage uint32
Raw types.Log // Blockchain specific contextual infos
}
// FilterSend is a free log retrieval operation binding the contract event 0x89d8051e597ab4178a863a5190407b98abfeff406aa8db90c59af76612e58f01.
//
// Solidity: event Send(bytes32 transferId, address sender, address receiver, address token, uint256 amount, uint64 dstChainId, uint64 nonce, uint32 maxSlippage)
func (_Celer *CelerFilterer) FilterSend(opts *bind.FilterOpts) (*CelerSendIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "Send")
if err != nil {
return nil, err
}
return &CelerSendIterator{contract: _Celer.contract, event: "Send", logs: logs, sub: sub}, nil
}
// WatchSend is a free log subscription operation binding the contract event 0x89d8051e597ab4178a863a5190407b98abfeff406aa8db90c59af76612e58f01.
//
// Solidity: event Send(bytes32 transferId, address sender, address receiver, address token, uint256 amount, uint64 dstChainId, uint64 nonce, uint32 maxSlippage)
func (_Celer *CelerFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *CelerSend) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "Send")
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(CelerSend)
if err := _Celer.contract.UnpackLog(event, "Send", 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
}
// ParseSend is a log parse operation binding the contract event 0x89d8051e597ab4178a863a5190407b98abfeff406aa8db90c59af76612e58f01.
//
// Solidity: event Send(bytes32 transferId, address sender, address receiver, address token, uint256 amount, uint64 dstChainId, uint64 nonce, uint32 maxSlippage)
func (_Celer *CelerFilterer) ParseSend(log types.Log) (*CelerSend, error) {
event := new(CelerSend)
if err := _Celer.contract.UnpackLog(event, "Send", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerSignersUpdatedIterator is returned from FilterSignersUpdated and is used to iterate over the raw logs and unpacked data for SignersUpdated events raised by the Celer contract.
type CelerSignersUpdatedIterator struct {
Event *CelerSignersUpdated // 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 *CelerSignersUpdatedIterator) 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(CelerSignersUpdated)
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(CelerSignersUpdated)
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 *CelerSignersUpdatedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerSignersUpdatedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerSignersUpdated represents a SignersUpdated event raised by the Celer contract.
type CelerSignersUpdated struct {
Signers []common.Address
Powers []*big.Int
Raw types.Log // Blockchain specific contextual infos
}
// FilterSignersUpdated is a free log retrieval operation binding the contract event 0xf126123539a68393c55697f617e7d1148e371988daed246c2f41da99965a23f8.
//
// Solidity: event SignersUpdated(address[] _signers, uint256[] _powers)
func (_Celer *CelerFilterer) FilterSignersUpdated(opts *bind.FilterOpts) (*CelerSignersUpdatedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "SignersUpdated")
if err != nil {
return nil, err
}
return &CelerSignersUpdatedIterator{contract: _Celer.contract, event: "SignersUpdated", logs: logs, sub: sub}, nil
}
// WatchSignersUpdated is a free log subscription operation binding the contract event 0xf126123539a68393c55697f617e7d1148e371988daed246c2f41da99965a23f8.
//
// Solidity: event SignersUpdated(address[] _signers, uint256[] _powers)
func (_Celer *CelerFilterer) WatchSignersUpdated(opts *bind.WatchOpts, sink chan<- *CelerSignersUpdated) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "SignersUpdated")
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(CelerSignersUpdated)
if err := _Celer.contract.UnpackLog(event, "SignersUpdated", 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
}
// ParseSignersUpdated is a log parse operation binding the contract event 0xf126123539a68393c55697f617e7d1148e371988daed246c2f41da99965a23f8.
//
// Solidity: event SignersUpdated(address[] _signers, uint256[] _powers)
func (_Celer *CelerFilterer) ParseSignersUpdated(log types.Log) (*CelerSignersUpdated, error) {
event := new(CelerSignersUpdated)
if err := _Celer.contract.UnpackLog(event, "SignersUpdated", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the Celer contract.
type CelerUnpausedIterator struct {
Event *CelerUnpaused // 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 *CelerUnpausedIterator) 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(CelerUnpaused)
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(CelerUnpaused)
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 *CelerUnpausedIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerUnpausedIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerUnpaused represents a Unpaused event raised by the Celer contract.
type CelerUnpaused struct {
Account common.Address
Raw types.Log // Blockchain specific contextual infos
}
// FilterUnpaused is a free log retrieval operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.
//
// Solidity: event Unpaused(address account)
func (_Celer *CelerFilterer) FilterUnpaused(opts *bind.FilterOpts) (*CelerUnpausedIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "Unpaused")
if err != nil {
return nil, err
}
return &CelerUnpausedIterator{contract: _Celer.contract, event: "Unpaused", logs: logs, sub: sub}, nil
}
// WatchUnpaused is a free log subscription operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.
//
// Solidity: event Unpaused(address account)
func (_Celer *CelerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *CelerUnpaused) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "Unpaused")
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(CelerUnpaused)
if err := _Celer.contract.UnpackLog(event, "Unpaused", 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
}
// ParseUnpaused is a log parse operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.
//
// Solidity: event Unpaused(address account)
func (_Celer *CelerFilterer) ParseUnpaused(log types.Log) (*CelerUnpaused, error) {
event := new(CelerUnpaused)
if err := _Celer.contract.UnpackLog(event, "Unpaused", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}
// CelerWithdrawDoneIterator is returned from FilterWithdrawDone and is used to iterate over the raw logs and unpacked data for WithdrawDone events raised by the Celer contract.
type CelerWithdrawDoneIterator struct {
Event *CelerWithdrawDone // 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 *CelerWithdrawDoneIterator) 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(CelerWithdrawDone)
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(CelerWithdrawDone)
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 *CelerWithdrawDoneIterator) Error() error {
return it.fail
}
// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *CelerWithdrawDoneIterator) Close() error {
it.sub.Unsubscribe()
return nil
}
// CelerWithdrawDone represents a WithdrawDone event raised by the Celer contract.
type CelerWithdrawDone struct {
WithdrawId [32]byte
Seqnum uint64
Receiver common.Address
Token common.Address
Amount *big.Int
Refid [32]byte
Raw types.Log // Blockchain specific contextual infos
}
// FilterWithdrawDone is a free log retrieval operation binding the contract event 0x48a1ab26f3aa7b62bb6b6e8eed182f292b84eb7b006c0254386b268af20774be.
//
// Solidity: event WithdrawDone(bytes32 withdrawId, uint64 seqnum, address receiver, address token, uint256 amount, bytes32 refid)
func (_Celer *CelerFilterer) FilterWithdrawDone(opts *bind.FilterOpts) (*CelerWithdrawDoneIterator, error) {
logs, sub, err := _Celer.contract.FilterLogs(opts, "WithdrawDone")
if err != nil {
return nil, err
}
return &CelerWithdrawDoneIterator{contract: _Celer.contract, event: "WithdrawDone", logs: logs, sub: sub}, nil
}
// WatchWithdrawDone is a free log subscription operation binding the contract event 0x48a1ab26f3aa7b62bb6b6e8eed182f292b84eb7b006c0254386b268af20774be.
//
// Solidity: event WithdrawDone(bytes32 withdrawId, uint64 seqnum, address receiver, address token, uint256 amount, bytes32 refid)
func (_Celer *CelerFilterer) WatchWithdrawDone(opts *bind.WatchOpts, sink chan<- *CelerWithdrawDone) (event.Subscription, error) {
logs, sub, err := _Celer.contract.WatchLogs(opts, "WithdrawDone")
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(CelerWithdrawDone)
if err := _Celer.contract.UnpackLog(event, "WithdrawDone", 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
}
// ParseWithdrawDone is a log parse operation binding the contract event 0x48a1ab26f3aa7b62bb6b6e8eed182f292b84eb7b006c0254386b268af20774be.
//
// Solidity: event WithdrawDone(bytes32 withdrawId, uint64 seqnum, address receiver, address token, uint256 amount, bytes32 refid)
func (_Celer *CelerFilterer) ParseWithdrawDone(log types.Log) (*CelerWithdrawDone, error) {
event := new(CelerWithdrawDone)
if err := _Celer.contract.UnpackLog(event, "WithdrawDone", log); err != nil {
return nil, err
}
event.Raw = log
return event, nil
}