hermez-node/eth/contracts/tokenHEZ/HEZ.go
eth/contracts/tokenHEZ/HEZ.goRaw
1// Code generated - DO NOT EDIT.
2// This file is a generated binding and any manual changes will be lost.
3
4package HEZ
5
6import (
7 "math/big"
8 "strings"
9
10 ethereum "github.com/ethereum/go-ethereum"
11 "github.com/ethereum/go-ethereum/accounts/abi"
12 "github.com/ethereum/go-ethereum/accounts/abi/bind"
13 "github.com/ethereum/go-ethereum/common"
14 "github.com/ethereum/go-ethereum/core/types"
15 "github.com/ethereum/go-ethereum/event"
16)
17
18// Reference imports to suppress errors if they are not otherwise used.
19var (
20 _ = big.NewInt
21 _ = strings.NewReader
22 _ = ethereum.NotFound
23 _ = bind.Bind
24 _ = common.Big1
25 _ = types.BloomLookup
26 _ = event.NewSubscription
27)
28
29// HEZABI is the input ABI used to generate the binding from.
30const HEZABI = "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialHolder\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"authorizer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"}],\"name\":\"AuthorizationUsed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"EIP712DOMAIN_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"NAME_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PERMIT_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TRANSFER_WITH_AUTHORIZATION_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"VERSION_HASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"authorizationState\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialBalance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validAfter\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validBefore\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"transferWithAuthorization\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
31
32// HEZ is an auto generated Go binding around an Ethereum contract.
33type HEZ struct {
34 HEZCaller // Read-only binding to the contract
35 HEZTransactor // Write-only binding to the contract
36 HEZFilterer // Log filterer for contract events
37}
38
39// HEZCaller is an auto generated read-only Go binding around an Ethereum contract.
40type HEZCaller struct {
41 contract *bind.BoundContract // Generic contract wrapper for the low level calls
42}
43
44// HEZTransactor is an auto generated write-only Go binding around an Ethereum contract.
45type HEZTransactor struct {
46 contract *bind.BoundContract // Generic contract wrapper for the low level calls
47}
48
49// HEZFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
50type HEZFilterer struct {
51 contract *bind.BoundContract // Generic contract wrapper for the low level calls
52}
53
54// HEZSession is an auto generated Go binding around an Ethereum contract,
55// with pre-set call and transact options.
56type HEZSession struct {
57 Contract *HEZ // Generic contract binding to set the session for
58 CallOpts bind.CallOpts // Call options to use throughout this session
59 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
60}
61
62// HEZCallerSession is an auto generated read-only Go binding around an Ethereum contract,
63// with pre-set call options.
64type HEZCallerSession struct {
65 Contract *HEZCaller // Generic contract caller binding to set the session for
66 CallOpts bind.CallOpts // Call options to use throughout this session
67}
68
69// HEZTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
70// with pre-set transact options.
71type HEZTransactorSession struct {
72 Contract *HEZTransactor // Generic contract transactor binding to set the session for
73 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
74}
75
76// HEZRaw is an auto generated low-level Go binding around an Ethereum contract.
77type HEZRaw struct {
78 Contract *HEZ // Generic contract binding to access the raw methods on
79}
80
81// HEZCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
82type HEZCallerRaw struct {
83 Contract *HEZCaller // Generic read-only contract binding to access the raw methods on
84}
85
86// HEZTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
87type HEZTransactorRaw struct {
88 Contract *HEZTransactor // Generic write-only contract binding to access the raw methods on
89}
90
91// NewHEZ creates a new instance of HEZ, bound to a specific deployed contract.
92func NewHEZ(address common.Address, backend bind.ContractBackend) (*HEZ, error) {
93 contract, err := bindHEZ(address, backend, backend, backend)
94 if err != nil {
95 return nil, err
96 }
97 return &HEZ{HEZCaller: HEZCaller{contract: contract}, HEZTransactor: HEZTransactor{contract: contract}, HEZFilterer: HEZFilterer{contract: contract}}, nil
98}
99
100// NewHEZCaller creates a new read-only instance of HEZ, bound to a specific deployed contract.
101func NewHEZCaller(address common.Address, caller bind.ContractCaller) (*HEZCaller, error) {
102 contract, err := bindHEZ(address, caller, nil, nil)
103 if err != nil {
104 return nil, err
105 }
106 return &HEZCaller{contract: contract}, nil
107}
108
109// NewHEZTransactor creates a new write-only instance of HEZ, bound to a specific deployed contract.
110func NewHEZTransactor(address common.Address, transactor bind.ContractTransactor) (*HEZTransactor, error) {
111 contract, err := bindHEZ(address, nil, transactor, nil)
112 if err != nil {
113 return nil, err
114 }
115 return &HEZTransactor{contract: contract}, nil
116}
117
118// NewHEZFilterer creates a new log filterer instance of HEZ, bound to a specific deployed contract.
119func NewHEZFilterer(address common.Address, filterer bind.ContractFilterer) (*HEZFilterer, error) {
120 contract, err := bindHEZ(address, nil, nil, filterer)
121 if err != nil {
122 return nil, err
123 }
124 return &HEZFilterer{contract: contract}, nil
125}
126
127// bindHEZ binds a generic wrapper to an already deployed contract.
128func bindHEZ(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
129 parsed, err := abi.JSON(strings.NewReader(HEZABI))
130 if err != nil {
131 return nil, err
132 }
133 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
134}
135
136// Call invokes the (constant) contract method with params as input values and
137// sets the output to result. The result type might be a single field for simple
138// returns, a slice of interfaces for anonymous returns and a struct for named
139// returns.
140func (_HEZ *HEZRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
141 return _HEZ.Contract.HEZCaller.contract.Call(opts, result, method, params...)
142}
143
144// Transfer initiates a plain transaction to move funds to the contract, calling
145// its default method if one is available.
146func (_HEZ *HEZRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
147 return _HEZ.Contract.HEZTransactor.contract.Transfer(opts)
148}
149
150// Transact invokes the (paid) contract method with params as input values.
151func (_HEZ *HEZRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
152 return _HEZ.Contract.HEZTransactor.contract.Transact(opts, method, params...)
153}
154
155// Call invokes the (constant) contract method with params as input values and
156// sets the output to result. The result type might be a single field for simple
157// returns, a slice of interfaces for anonymous returns and a struct for named
158// returns.
159func (_HEZ *HEZCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
160 return _HEZ.Contract.contract.Call(opts, result, method, params...)
161}
162
163// Transfer initiates a plain transaction to move funds to the contract, calling
164// its default method if one is available.
165func (_HEZ *HEZTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
166 return _HEZ.Contract.contract.Transfer(opts)
167}
168
169// Transact invokes the (paid) contract method with params as input values.
170func (_HEZ *HEZTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
171 return _HEZ.Contract.contract.Transact(opts, method, params...)
172}
173
174// EIP712DOMAINHASH is a free data retrieval call binding the contract method 0xc473af33.
175//
176// Solidity: function EIP712DOMAIN_HASH() view returns(bytes32)
177func (_HEZ *HEZCaller) EIP712DOMAINHASH(opts *bind.CallOpts) ([32]byte, error) {
178 var out []interface{}
179 err := _HEZ.contract.Call(opts, &out, "EIP712DOMAIN_HASH")
180
181 if err != nil {
182 return *new([32]byte), err
183 }
184
185 out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
186
187 return out0, err
188
189}
190
191// EIP712DOMAINHASH is a free data retrieval call binding the contract method 0xc473af33.
192//
193// Solidity: function EIP712DOMAIN_HASH() view returns(bytes32)
194func (_HEZ *HEZSession) EIP712DOMAINHASH() ([32]byte, error) {
195 return _HEZ.Contract.EIP712DOMAINHASH(&_HEZ.CallOpts)
196}
197
198// EIP712DOMAINHASH is a free data retrieval call binding the contract method 0xc473af33.
199//
200// Solidity: function EIP712DOMAIN_HASH() view returns(bytes32)
201func (_HEZ *HEZCallerSession) EIP712DOMAINHASH() ([32]byte, error) {
202 return _HEZ.Contract.EIP712DOMAINHASH(&_HEZ.CallOpts)
203}
204
205// NAMEHASH is a free data retrieval call binding the contract method 0x04622c2e.
206//
207// Solidity: function NAME_HASH() view returns(bytes32)
208func (_HEZ *HEZCaller) NAMEHASH(opts *bind.CallOpts) ([32]byte, error) {
209 var out []interface{}
210 err := _HEZ.contract.Call(opts, &out, "NAME_HASH")
211
212 if err != nil {
213 return *new([32]byte), err
214 }
215
216 out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
217
218 return out0, err
219
220}
221
222// NAMEHASH is a free data retrieval call binding the contract method 0x04622c2e.
223//
224// Solidity: function NAME_HASH() view returns(bytes32)
225func (_HEZ *HEZSession) NAMEHASH() ([32]byte, error) {
226 return _HEZ.Contract.NAMEHASH(&_HEZ.CallOpts)
227}
228
229// NAMEHASH is a free data retrieval call binding the contract method 0x04622c2e.
230//
231// Solidity: function NAME_HASH() view returns(bytes32)
232func (_HEZ *HEZCallerSession) NAMEHASH() ([32]byte, error) {
233 return _HEZ.Contract.NAMEHASH(&_HEZ.CallOpts)
234}
235
236// PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f.
237//
238// Solidity: function PERMIT_TYPEHASH() view returns(bytes32)
239func (_HEZ *HEZCaller) PERMITTYPEHASH(opts *bind.CallOpts) ([32]byte, error) {
240 var out []interface{}
241 err := _HEZ.contract.Call(opts, &out, "PERMIT_TYPEHASH")
242
243 if err != nil {
244 return *new([32]byte), err
245 }
246
247 out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
248
249 return out0, err
250
251}
252
253// PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f.
254//
255// Solidity: function PERMIT_TYPEHASH() view returns(bytes32)
256func (_HEZ *HEZSession) PERMITTYPEHASH() ([32]byte, error) {
257 return _HEZ.Contract.PERMITTYPEHASH(&_HEZ.CallOpts)
258}
259
260// PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f.
261//
262// Solidity: function PERMIT_TYPEHASH() view returns(bytes32)
263func (_HEZ *HEZCallerSession) PERMITTYPEHASH() ([32]byte, error) {
264 return _HEZ.Contract.PERMITTYPEHASH(&_HEZ.CallOpts)
265}
266
267// TRANSFERWITHAUTHORIZATIONTYPEHASH is a free data retrieval call binding the contract method 0xa0cc6a68.
268//
269// Solidity: function TRANSFER_WITH_AUTHORIZATION_TYPEHASH() view returns(bytes32)
270func (_HEZ *HEZCaller) TRANSFERWITHAUTHORIZATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error) {
271 var out []interface{}
272 err := _HEZ.contract.Call(opts, &out, "TRANSFER_WITH_AUTHORIZATION_TYPEHASH")
273
274 if err != nil {
275 return *new([32]byte), err
276 }
277
278 out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
279
280 return out0, err
281
282}
283
284// TRANSFERWITHAUTHORIZATIONTYPEHASH is a free data retrieval call binding the contract method 0xa0cc6a68.
285//
286// Solidity: function TRANSFER_WITH_AUTHORIZATION_TYPEHASH() view returns(bytes32)
287func (_HEZ *HEZSession) TRANSFERWITHAUTHORIZATIONTYPEHASH() ([32]byte, error) {
288 return _HEZ.Contract.TRANSFERWITHAUTHORIZATIONTYPEHASH(&_HEZ.CallOpts)
289}
290
291// TRANSFERWITHAUTHORIZATIONTYPEHASH is a free data retrieval call binding the contract method 0xa0cc6a68.
292//
293// Solidity: function TRANSFER_WITH_AUTHORIZATION_TYPEHASH() view returns(bytes32)
294func (_HEZ *HEZCallerSession) TRANSFERWITHAUTHORIZATIONTYPEHASH() ([32]byte, error) {
295 return _HEZ.Contract.TRANSFERWITHAUTHORIZATIONTYPEHASH(&_HEZ.CallOpts)
296}
297
298// VERSIONHASH is a free data retrieval call binding the contract method 0x9e4e7318.
299//
300// Solidity: function VERSION_HASH() view returns(bytes32)
301func (_HEZ *HEZCaller) VERSIONHASH(opts *bind.CallOpts) ([32]byte, error) {
302 var out []interface{}
303 err := _HEZ.contract.Call(opts, &out, "VERSION_HASH")
304
305 if err != nil {
306 return *new([32]byte), err
307 }
308
309 out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
310
311 return out0, err
312
313}
314
315// VERSIONHASH is a free data retrieval call binding the contract method 0x9e4e7318.
316//
317// Solidity: function VERSION_HASH() view returns(bytes32)
318func (_HEZ *HEZSession) VERSIONHASH() ([32]byte, error) {
319 return _HEZ.Contract.VERSIONHASH(&_HEZ.CallOpts)
320}
321
322// VERSIONHASH is a free data retrieval call binding the contract method 0x9e4e7318.
323//
324// Solidity: function VERSION_HASH() view returns(bytes32)
325func (_HEZ *HEZCallerSession) VERSIONHASH() ([32]byte, error) {
326 return _HEZ.Contract.VERSIONHASH(&_HEZ.CallOpts)
327}
328
329// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
330//
331// Solidity: function allowance(address , address ) view returns(uint256)
332func (_HEZ *HEZCaller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) {
333 var out []interface{}
334 err := _HEZ.contract.Call(opts, &out, "allowance", arg0, arg1)
335
336 if err != nil {
337 return *new(*big.Int), err
338 }
339
340 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
341
342 return out0, err
343
344}
345
346// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
347//
348// Solidity: function allowance(address , address ) view returns(uint256)
349func (_HEZ *HEZSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error) {
350 return _HEZ.Contract.Allowance(&_HEZ.CallOpts, arg0, arg1)
351}
352
353// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
354//
355// Solidity: function allowance(address , address ) view returns(uint256)
356func (_HEZ *HEZCallerSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error) {
357 return _HEZ.Contract.Allowance(&_HEZ.CallOpts, arg0, arg1)
358}
359
360// AuthorizationState is a free data retrieval call binding the contract method 0xe94a0102.
361//
362// Solidity: function authorizationState(address , bytes32 ) view returns(bool)
363func (_HEZ *HEZCaller) AuthorizationState(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (bool, error) {
364 var out []interface{}
365 err := _HEZ.contract.Call(opts, &out, "authorizationState", arg0, arg1)
366
367 if err != nil {
368 return *new(bool), err
369 }
370
371 out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
372
373 return out0, err
374
375}
376
377// AuthorizationState is a free data retrieval call binding the contract method 0xe94a0102.
378//
379// Solidity: function authorizationState(address , bytes32 ) view returns(bool)
380func (_HEZ *HEZSession) AuthorizationState(arg0 common.Address, arg1 [32]byte) (bool, error) {
381 return _HEZ.Contract.AuthorizationState(&_HEZ.CallOpts, arg0, arg1)
382}
383
384// AuthorizationState is a free data retrieval call binding the contract method 0xe94a0102.
385//
386// Solidity: function authorizationState(address , bytes32 ) view returns(bool)
387func (_HEZ *HEZCallerSession) AuthorizationState(arg0 common.Address, arg1 [32]byte) (bool, error) {
388 return _HEZ.Contract.AuthorizationState(&_HEZ.CallOpts, arg0, arg1)
389}
390
391// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
392//
393// Solidity: function balanceOf(address ) view returns(uint256)
394func (_HEZ *HEZCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
395 var out []interface{}
396 err := _HEZ.contract.Call(opts, &out, "balanceOf", arg0)
397
398 if err != nil {
399 return *new(*big.Int), err
400 }
401
402 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
403
404 return out0, err
405
406}
407
408// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
409//
410// Solidity: function balanceOf(address ) view returns(uint256)
411func (_HEZ *HEZSession) BalanceOf(arg0 common.Address) (*big.Int, error) {
412 return _HEZ.Contract.BalanceOf(&_HEZ.CallOpts, arg0)
413}
414
415// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
416//
417// Solidity: function balanceOf(address ) view returns(uint256)
418func (_HEZ *HEZCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error) {
419 return _HEZ.Contract.BalanceOf(&_HEZ.CallOpts, arg0)
420}
421
422// Decimals is a free data retrieval call binding the contract method 0x313ce567.
423//
424// Solidity: function decimals() view returns(uint8)
425func (_HEZ *HEZCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
426 var out []interface{}
427 err := _HEZ.contract.Call(opts, &out, "decimals")
428
429 if err != nil {
430 return *new(uint8), err
431 }
432
433 out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8)
434
435 return out0, err
436
437}
438
439// Decimals is a free data retrieval call binding the contract method 0x313ce567.
440//
441// Solidity: function decimals() view returns(uint8)
442func (_HEZ *HEZSession) Decimals() (uint8, error) {
443 return _HEZ.Contract.Decimals(&_HEZ.CallOpts)
444}
445
446// Decimals is a free data retrieval call binding the contract method 0x313ce567.
447//
448// Solidity: function decimals() view returns(uint8)
449func (_HEZ *HEZCallerSession) Decimals() (uint8, error) {
450 return _HEZ.Contract.Decimals(&_HEZ.CallOpts)
451}
452
453// GetChainId is a free data retrieval call binding the contract method 0x3408e470.
454//
455// Solidity: function getChainId() pure returns(uint256 chainId)
456func (_HEZ *HEZCaller) GetChainId(opts *bind.CallOpts) (*big.Int, error) {
457 var out []interface{}
458 err := _HEZ.contract.Call(opts, &out, "getChainId")
459
460 if err != nil {
461 return *new(*big.Int), err
462 }
463
464 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
465
466 return out0, err
467
468}
469
470// GetChainId is a free data retrieval call binding the contract method 0x3408e470.
471//
472// Solidity: function getChainId() pure returns(uint256 chainId)
473func (_HEZ *HEZSession) GetChainId() (*big.Int, error) {
474 return _HEZ.Contract.GetChainId(&_HEZ.CallOpts)
475}
476
477// GetChainId is a free data retrieval call binding the contract method 0x3408e470.
478//
479// Solidity: function getChainId() pure returns(uint256 chainId)
480func (_HEZ *HEZCallerSession) GetChainId() (*big.Int, error) {
481 return _HEZ.Contract.GetChainId(&_HEZ.CallOpts)
482}
483
484// InitialBalance is a free data retrieval call binding the contract method 0x18369a2a.
485//
486// Solidity: function initialBalance() view returns(uint256)
487func (_HEZ *HEZCaller) InitialBalance(opts *bind.CallOpts) (*big.Int, error) {
488 var out []interface{}
489 err := _HEZ.contract.Call(opts, &out, "initialBalance")
490
491 if err != nil {
492 return *new(*big.Int), err
493 }
494
495 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
496
497 return out0, err
498
499}
500
501// InitialBalance is a free data retrieval call binding the contract method 0x18369a2a.
502//
503// Solidity: function initialBalance() view returns(uint256)
504func (_HEZ *HEZSession) InitialBalance() (*big.Int, error) {
505 return _HEZ.Contract.InitialBalance(&_HEZ.CallOpts)
506}
507
508// InitialBalance is a free data retrieval call binding the contract method 0x18369a2a.
509//
510// Solidity: function initialBalance() view returns(uint256)
511func (_HEZ *HEZCallerSession) InitialBalance() (*big.Int, error) {
512 return _HEZ.Contract.InitialBalance(&_HEZ.CallOpts)
513}
514
515// Name is a free data retrieval call binding the contract method 0x06fdde03.
516//
517// Solidity: function name() view returns(string)
518func (_HEZ *HEZCaller) Name(opts *bind.CallOpts) (string, error) {
519 var out []interface{}
520 err := _HEZ.contract.Call(opts, &out, "name")
521
522 if err != nil {
523 return *new(string), err
524 }
525
526 out0 := *abi.ConvertType(out[0], new(string)).(*string)
527
528 return out0, err
529
530}
531
532// Name is a free data retrieval call binding the contract method 0x06fdde03.
533//
534// Solidity: function name() view returns(string)
535func (_HEZ *HEZSession) Name() (string, error) {
536 return _HEZ.Contract.Name(&_HEZ.CallOpts)
537}
538
539// Name is a free data retrieval call binding the contract method 0x06fdde03.
540//
541// Solidity: function name() view returns(string)
542func (_HEZ *HEZCallerSession) Name() (string, error) {
543 return _HEZ.Contract.Name(&_HEZ.CallOpts)
544}
545
546// Nonces is a free data retrieval call binding the contract method 0x7ecebe00.
547//
548// Solidity: function nonces(address ) view returns(uint256)
549func (_HEZ *HEZCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
550 var out []interface{}
551 err := _HEZ.contract.Call(opts, &out, "nonces", arg0)
552
553 if err != nil {
554 return *new(*big.Int), err
555 }
556
557 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
558
559 return out0, err
560
561}
562
563// Nonces is a free data retrieval call binding the contract method 0x7ecebe00.
564//
565// Solidity: function nonces(address ) view returns(uint256)
566func (_HEZ *HEZSession) Nonces(arg0 common.Address) (*big.Int, error) {
567 return _HEZ.Contract.Nonces(&_HEZ.CallOpts, arg0)
568}
569
570// Nonces is a free data retrieval call binding the contract method 0x7ecebe00.
571//
572// Solidity: function nonces(address ) view returns(uint256)
573func (_HEZ *HEZCallerSession) Nonces(arg0 common.Address) (*big.Int, error) {
574 return _HEZ.Contract.Nonces(&_HEZ.CallOpts, arg0)
575}
576
577// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
578//
579// Solidity: function symbol() view returns(string)
580func (_HEZ *HEZCaller) Symbol(opts *bind.CallOpts) (string, error) {
581 var out []interface{}
582 err := _HEZ.contract.Call(opts, &out, "symbol")
583
584 if err != nil {
585 return *new(string), err
586 }
587
588 out0 := *abi.ConvertType(out[0], new(string)).(*string)
589
590 return out0, err
591
592}
593
594// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
595//
596// Solidity: function symbol() view returns(string)
597func (_HEZ *HEZSession) Symbol() (string, error) {
598 return _HEZ.Contract.Symbol(&_HEZ.CallOpts)
599}
600
601// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
602//
603// Solidity: function symbol() view returns(string)
604func (_HEZ *HEZCallerSession) Symbol() (string, error) {
605 return _HEZ.Contract.Symbol(&_HEZ.CallOpts)
606}
607
608// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
609//
610// Solidity: function totalSupply() view returns(uint256)
611func (_HEZ *HEZCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
612 var out []interface{}
613 err := _HEZ.contract.Call(opts, &out, "totalSupply")
614
615 if err != nil {
616 return *new(*big.Int), err
617 }
618
619 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
620
621 return out0, err
622
623}
624
625// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
626//
627// Solidity: function totalSupply() view returns(uint256)
628func (_HEZ *HEZSession) TotalSupply() (*big.Int, error) {
629 return _HEZ.Contract.TotalSupply(&_HEZ.CallOpts)
630}
631
632// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
633//
634// Solidity: function totalSupply() view returns(uint256)
635func (_HEZ *HEZCallerSession) TotalSupply() (*big.Int, error) {
636 return _HEZ.Contract.TotalSupply(&_HEZ.CallOpts)
637}
638
639// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
640//
641// Solidity: function approve(address spender, uint256 value) returns(bool)
642func (_HEZ *HEZTransactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error) {
643 return _HEZ.contract.Transact(opts, "approve", spender, value)
644}
645
646// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
647//
648// Solidity: function approve(address spender, uint256 value) returns(bool)
649func (_HEZ *HEZSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) {
650 return _HEZ.Contract.Approve(&_HEZ.TransactOpts, spender, value)
651}
652
653// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
654//
655// Solidity: function approve(address spender, uint256 value) returns(bool)
656func (_HEZ *HEZTransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) {
657 return _HEZ.Contract.Approve(&_HEZ.TransactOpts, spender, value)
658}
659
660// Burn is a paid mutator transaction binding the contract method 0x42966c68.
661//
662// Solidity: function burn(uint256 value) returns(bool)
663func (_HEZ *HEZTransactor) Burn(opts *bind.TransactOpts, value *big.Int) (*types.Transaction, error) {
664 return _HEZ.contract.Transact(opts, "burn", value)
665}
666
667// Burn is a paid mutator transaction binding the contract method 0x42966c68.
668//
669// Solidity: function burn(uint256 value) returns(bool)
670func (_HEZ *HEZSession) Burn(value *big.Int) (*types.Transaction, error) {
671 return _HEZ.Contract.Burn(&_HEZ.TransactOpts, value)
672}
673
674// Burn is a paid mutator transaction binding the contract method 0x42966c68.
675//
676// Solidity: function burn(uint256 value) returns(bool)
677func (_HEZ *HEZTransactorSession) Burn(value *big.Int) (*types.Transaction, error) {
678 return _HEZ.Contract.Burn(&_HEZ.TransactOpts, value)
679}
680
681// Permit is a paid mutator transaction binding the contract method 0xd505accf.
682//
683// Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns()
684func (_HEZ *HEZTransactor) Permit(opts *bind.TransactOpts, owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
685 return _HEZ.contract.Transact(opts, "permit", owner, spender, value, deadline, v, r, s)
686}
687
688// Permit is a paid mutator transaction binding the contract method 0xd505accf.
689//
690// Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns()
691func (_HEZ *HEZSession) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
692 return _HEZ.Contract.Permit(&_HEZ.TransactOpts, owner, spender, value, deadline, v, r, s)
693}
694
695// Permit is a paid mutator transaction binding the contract method 0xd505accf.
696//
697// Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns()
698func (_HEZ *HEZTransactorSession) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
699 return _HEZ.Contract.Permit(&_HEZ.TransactOpts, owner, spender, value, deadline, v, r, s)
700}
701
702// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
703//
704// Solidity: function transfer(address to, uint256 value) returns(bool)
705func (_HEZ *HEZTransactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error) {
706 return _HEZ.contract.Transact(opts, "transfer", to, value)
707}
708
709// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
710//
711// Solidity: function transfer(address to, uint256 value) returns(bool)
712func (_HEZ *HEZSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) {
713 return _HEZ.Contract.Transfer(&_HEZ.TransactOpts, to, value)
714}
715
716// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
717//
718// Solidity: function transfer(address to, uint256 value) returns(bool)
719func (_HEZ *HEZTransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) {
720 return _HEZ.Contract.Transfer(&_HEZ.TransactOpts, to, value)
721}
722
723// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
724//
725// Solidity: function transferFrom(address from, address to, uint256 value) returns(bool)
726func (_HEZ *HEZTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) {
727 return _HEZ.contract.Transact(opts, "transferFrom", from, to, value)
728}
729
730// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
731//
732// Solidity: function transferFrom(address from, address to, uint256 value) returns(bool)
733func (_HEZ *HEZSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) {
734 return _HEZ.Contract.TransferFrom(&_HEZ.TransactOpts, from, to, value)
735}
736
737// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
738//
739// Solidity: function transferFrom(address from, address to, uint256 value) returns(bool)
740func (_HEZ *HEZTransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) {
741 return _HEZ.Contract.TransferFrom(&_HEZ.TransactOpts, from, to, value)
742}
743
744// TransferWithAuthorization is a paid mutator transaction binding the contract method 0xe3ee160e.
745//
746// Solidity: function transferWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) returns()
747func (_HEZ *HEZTransactor) TransferWithAuthorization(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int, validAfter *big.Int, validBefore *big.Int, nonce [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
748 return _HEZ.contract.Transact(opts, "transferWithAuthorization", from, to, value, validAfter, validBefore, nonce, v, r, s)
749}
750
751// TransferWithAuthorization is a paid mutator transaction binding the contract method 0xe3ee160e.
752//
753// Solidity: function transferWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) returns()
754func (_HEZ *HEZSession) TransferWithAuthorization(from common.Address, to common.Address, value *big.Int, validAfter *big.Int, validBefore *big.Int, nonce [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
755 return _HEZ.Contract.TransferWithAuthorization(&_HEZ.TransactOpts, from, to, value, validAfter, validBefore, nonce, v, r, s)
756}
757
758// TransferWithAuthorization is a paid mutator transaction binding the contract method 0xe3ee160e.
759//
760// Solidity: function transferWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) returns()
761func (_HEZ *HEZTransactorSession) TransferWithAuthorization(from common.Address, to common.Address, value *big.Int, validAfter *big.Int, validBefore *big.Int, nonce [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
762 return _HEZ.Contract.TransferWithAuthorization(&_HEZ.TransactOpts, from, to, value, validAfter, validBefore, nonce, v, r, s)
763}
764
765// HEZApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the HEZ contract.
766type HEZApprovalIterator struct {
767 Event *HEZApproval // Event containing the contract specifics and raw log
768
769 contract *bind.BoundContract // Generic contract to use for unpacking event data
770 event string // Event name to use for unpacking event data
771
772 logs chan types.Log // Log channel receiving the found contract events
773 sub ethereum.Subscription // Subscription for errors, completion and termination
774 done bool // Whether the subscription completed delivering logs
775 fail error // Occurred error to stop iteration
776}
777
778// Next advances the iterator to the subsequent event, returning whether there
779// are any more events found. In case of a retrieval or parsing error, false is
780// returned and Error() can be queried for the exact failure.
781func (it *HEZApprovalIterator) Next() bool {
782 // If the iterator failed, stop iterating
783 if it.fail != nil {
784 return false
785 }
786 // If the iterator completed, deliver directly whatever's available
787 if it.done {
788 select {
789 case log := <-it.logs:
790 it.Event = new(HEZApproval)
791 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
792 it.fail = err
793 return false
794 }
795 it.Event.Raw = log
796 return true
797
798 default:
799 return false
800 }
801 }
802 // Iterator still in progress, wait for either a data or an error event
803 select {
804 case log := <-it.logs:
805 it.Event = new(HEZApproval)
806 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
807 it.fail = err
808 return false
809 }
810 it.Event.Raw = log
811 return true
812
813 case err := <-it.sub.Err():
814 it.done = true
815 it.fail = err
816 return it.Next()
817 }
818}
819
820// Error returns any retrieval or parsing error occurred during filtering.
821func (it *HEZApprovalIterator) Error() error {
822 return it.fail
823}
824
825// Close terminates the iteration process, releasing any pending underlying
826// resources.
827func (it *HEZApprovalIterator) Close() error {
828 it.sub.Unsubscribe()
829 return nil
830}
831
832// HEZApproval represents a Approval event raised by the HEZ contract.
833type HEZApproval struct {
834 Owner common.Address
835 Spender common.Address
836 Value *big.Int
837 Raw types.Log // Blockchain specific contextual infos
838}
839
840// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
841//
842// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
843func (_HEZ *HEZFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*HEZApprovalIterator, error) {
844
845 var ownerRule []interface{}
846 for _, ownerItem := range owner {
847 ownerRule = append(ownerRule, ownerItem)
848 }
849 var spenderRule []interface{}
850 for _, spenderItem := range spender {
851 spenderRule = append(spenderRule, spenderItem)
852 }
853
854 logs, sub, err := _HEZ.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
855 if err != nil {
856 return nil, err
857 }
858 return &HEZApprovalIterator{contract: _HEZ.contract, event: "Approval", logs: logs, sub: sub}, nil
859}
860
861// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
862//
863// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
864func (_HEZ *HEZFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *HEZApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
865
866 var ownerRule []interface{}
867 for _, ownerItem := range owner {
868 ownerRule = append(ownerRule, ownerItem)
869 }
870 var spenderRule []interface{}
871 for _, spenderItem := range spender {
872 spenderRule = append(spenderRule, spenderItem)
873 }
874
875 logs, sub, err := _HEZ.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
876 if err != nil {
877 return nil, err
878 }
879 return event.NewSubscription(func(quit <-chan struct{}) error {
880 defer sub.Unsubscribe()
881 for {
882 select {
883 case log := <-logs:
884 // New log arrived, parse the event and forward to the user
885 event := new(HEZApproval)
886 if err := _HEZ.contract.UnpackLog(event, "Approval", log); err != nil {
887 return err
888 }
889 event.Raw = log
890
891 select {
892 case sink <- event:
893 case err := <-sub.Err():
894 return err
895 case <-quit:
896 return nil
897 }
898 case err := <-sub.Err():
899 return err
900 case <-quit:
901 return nil
902 }
903 }
904 }), nil
905}
906
907// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
908//
909// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
910func (_HEZ *HEZFilterer) ParseApproval(log types.Log) (*HEZApproval, error) {
911 event := new(HEZApproval)
912 if err := _HEZ.contract.UnpackLog(event, "Approval", log); err != nil {
913 return nil, err
914 }
915 event.Raw = log
916 return event, nil
917}
918
919// HEZAuthorizationUsedIterator is returned from FilterAuthorizationUsed and is used to iterate over the raw logs and unpacked data for AuthorizationUsed events raised by the HEZ contract.
920type HEZAuthorizationUsedIterator struct {
921 Event *HEZAuthorizationUsed // Event containing the contract specifics and raw log
922
923 contract *bind.BoundContract // Generic contract to use for unpacking event data
924 event string // Event name to use for unpacking event data
925
926 logs chan types.Log // Log channel receiving the found contract events
927 sub ethereum.Subscription // Subscription for errors, completion and termination
928 done bool // Whether the subscription completed delivering logs
929 fail error // Occurred error to stop iteration
930}
931
932// Next advances the iterator to the subsequent event, returning whether there
933// are any more events found. In case of a retrieval or parsing error, false is
934// returned and Error() can be queried for the exact failure.
935func (it *HEZAuthorizationUsedIterator) Next() bool {
936 // If the iterator failed, stop iterating
937 if it.fail != nil {
938 return false
939 }
940 // If the iterator completed, deliver directly whatever's available
941 if it.done {
942 select {
943 case log := <-it.logs:
944 it.Event = new(HEZAuthorizationUsed)
945 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
946 it.fail = err
947 return false
948 }
949 it.Event.Raw = log
950 return true
951
952 default:
953 return false
954 }
955 }
956 // Iterator still in progress, wait for either a data or an error event
957 select {
958 case log := <-it.logs:
959 it.Event = new(HEZAuthorizationUsed)
960 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
961 it.fail = err
962 return false
963 }
964 it.Event.Raw = log
965 return true
966
967 case err := <-it.sub.Err():
968 it.done = true
969 it.fail = err
970 return it.Next()
971 }
972}
973
974// Error returns any retrieval or parsing error occurred during filtering.
975func (it *HEZAuthorizationUsedIterator) Error() error {
976 return it.fail
977}
978
979// Close terminates the iteration process, releasing any pending underlying
980// resources.
981func (it *HEZAuthorizationUsedIterator) Close() error {
982 it.sub.Unsubscribe()
983 return nil
984}
985
986// HEZAuthorizationUsed represents a AuthorizationUsed event raised by the HEZ contract.
987type HEZAuthorizationUsed struct {
988 Authorizer common.Address
989 Nonce [32]byte
990 Raw types.Log // Blockchain specific contextual infos
991}
992
993// FilterAuthorizationUsed is a free log retrieval operation binding the contract event 0x98de503528ee59b575ef0c0a2576a82497bfc029a5685b209e9ec333479b10a5.
994//
995// Solidity: event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce)
996func (_HEZ *HEZFilterer) FilterAuthorizationUsed(opts *bind.FilterOpts, authorizer []common.Address, nonce [][32]byte) (*HEZAuthorizationUsedIterator, error) {
997
998 var authorizerRule []interface{}
999 for _, authorizerItem := range authorizer {
1000 authorizerRule = append(authorizerRule, authorizerItem)
1001 }
1002 var nonceRule []interface{}
1003 for _, nonceItem := range nonce {
1004 nonceRule = append(nonceRule, nonceItem)
1005 }
1006
1007 logs, sub, err := _HEZ.contract.FilterLogs(opts, "AuthorizationUsed", authorizerRule, nonceRule)
1008 if err != nil {
1009 return nil, err
1010 }
1011 return &HEZAuthorizationUsedIterator{contract: _HEZ.contract, event: "AuthorizationUsed", logs: logs, sub: sub}, nil
1012}
1013
1014// WatchAuthorizationUsed is a free log subscription operation binding the contract event 0x98de503528ee59b575ef0c0a2576a82497bfc029a5685b209e9ec333479b10a5.
1015//
1016// Solidity: event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce)
1017func (_HEZ *HEZFilterer) WatchAuthorizationUsed(opts *bind.WatchOpts, sink chan<- *HEZAuthorizationUsed, authorizer []common.Address, nonce [][32]byte) (event.Subscription, error) {
1018
1019 var authorizerRule []interface{}
1020 for _, authorizerItem := range authorizer {
1021 authorizerRule = append(authorizerRule, authorizerItem)
1022 }
1023 var nonceRule []interface{}
1024 for _, nonceItem := range nonce {
1025 nonceRule = append(nonceRule, nonceItem)
1026 }
1027
1028 logs, sub, err := _HEZ.contract.WatchLogs(opts, "AuthorizationUsed", authorizerRule, nonceRule)
1029 if err != nil {
1030 return nil, err
1031 }
1032 return event.NewSubscription(func(quit <-chan struct{}) error {
1033 defer sub.Unsubscribe()
1034 for {
1035 select {
1036 case log := <-logs:
1037 // New log arrived, parse the event and forward to the user
1038 event := new(HEZAuthorizationUsed)
1039 if err := _HEZ.contract.UnpackLog(event, "AuthorizationUsed", log); err != nil {
1040 return err
1041 }
1042 event.Raw = log
1043
1044 select {
1045 case sink <- event:
1046 case err := <-sub.Err():
1047 return err
1048 case <-quit:
1049 return nil
1050 }
1051 case err := <-sub.Err():
1052 return err
1053 case <-quit:
1054 return nil
1055 }
1056 }
1057 }), nil
1058}
1059
1060// ParseAuthorizationUsed is a log parse operation binding the contract event 0x98de503528ee59b575ef0c0a2576a82497bfc029a5685b209e9ec333479b10a5.
1061//
1062// Solidity: event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce)
1063func (_HEZ *HEZFilterer) ParseAuthorizationUsed(log types.Log) (*HEZAuthorizationUsed, error) {
1064 event := new(HEZAuthorizationUsed)
1065 if err := _HEZ.contract.UnpackLog(event, "AuthorizationUsed", log); err != nil {
1066 return nil, err
1067 }
1068 event.Raw = log
1069 return event, nil
1070}
1071
1072// HEZTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the HEZ contract.
1073type HEZTransferIterator struct {
1074 Event *HEZTransfer // Event containing the contract specifics and raw log
1075
1076 contract *bind.BoundContract // Generic contract to use for unpacking event data
1077 event string // Event name to use for unpacking event data
1078
1079 logs chan types.Log // Log channel receiving the found contract events
1080 sub ethereum.Subscription // Subscription for errors, completion and termination
1081 done bool // Whether the subscription completed delivering logs
1082 fail error // Occurred error to stop iteration
1083}
1084
1085// Next advances the iterator to the subsequent event, returning whether there
1086// are any more events found. In case of a retrieval or parsing error, false is
1087// returned and Error() can be queried for the exact failure.
1088func (it *HEZTransferIterator) Next() bool {
1089 // If the iterator failed, stop iterating
1090 if it.fail != nil {
1091 return false
1092 }
1093 // If the iterator completed, deliver directly whatever's available
1094 if it.done {
1095 select {
1096 case log := <-it.logs:
1097 it.Event = new(HEZTransfer)
1098 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
1099 it.fail = err
1100 return false
1101 }
1102 it.Event.Raw = log
1103 return true
1104
1105 default:
1106 return false
1107 }
1108 }
1109 // Iterator still in progress, wait for either a data or an error event
1110 select {
1111 case log := <-it.logs:
1112 it.Event = new(HEZTransfer)
1113 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
1114 it.fail = err
1115 return false
1116 }
1117 it.Event.Raw = log
1118 return true
1119
1120 case err := <-it.sub.Err():
1121 it.done = true
1122 it.fail = err
1123 return it.Next()
1124 }
1125}
1126
1127// Error returns any retrieval or parsing error occurred during filtering.
1128func (it *HEZTransferIterator) Error() error {
1129 return it.fail
1130}
1131
1132// Close terminates the iteration process, releasing any pending underlying
1133// resources.
1134func (it *HEZTransferIterator) Close() error {
1135 it.sub.Unsubscribe()
1136 return nil
1137}
1138
1139// HEZTransfer represents a Transfer event raised by the HEZ contract.
1140type HEZTransfer struct {
1141 From common.Address
1142 To common.Address
1143 Value *big.Int
1144 Raw types.Log // Blockchain specific contextual infos
1145}
1146
1147// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
1148//
1149// Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
1150func (_HEZ *HEZFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*HEZTransferIterator, error) {
1151
1152 var fromRule []interface{}
1153 for _, fromItem := range from {
1154 fromRule = append(fromRule, fromItem)
1155 }
1156 var toRule []interface{}
1157 for _, toItem := range to {
1158 toRule = append(toRule, toItem)
1159 }
1160
1161 logs, sub, err := _HEZ.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
1162 if err != nil {
1163 return nil, err
1164 }
1165 return &HEZTransferIterator{contract: _HEZ.contract, event: "Transfer", logs: logs, sub: sub}, nil
1166}
1167
1168// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
1169//
1170// Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
1171func (_HEZ *HEZFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *HEZTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
1172
1173 var fromRule []interface{}
1174 for _, fromItem := range from {
1175 fromRule = append(fromRule, fromItem)
1176 }
1177 var toRule []interface{}
1178 for _, toItem := range to {
1179 toRule = append(toRule, toItem)
1180 }
1181
1182 logs, sub, err := _HEZ.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
1183 if err != nil {
1184 return nil, err
1185 }
1186 return event.NewSubscription(func(quit <-chan struct{}) error {
1187 defer sub.Unsubscribe()
1188 for {
1189 select {
1190 case log := <-logs:
1191 // New log arrived, parse the event and forward to the user
1192 event := new(HEZTransfer)
1193 if err := _HEZ.contract.UnpackLog(event, "Transfer", log); err != nil {
1194 return err
1195 }
1196 event.Raw = log
1197
1198 select {
1199 case sink <- event:
1200 case err := <-sub.Err():
1201 return err
1202 case <-quit:
1203 return nil
1204 }
1205 case err := <-sub.Err():
1206 return err
1207 case <-quit:
1208 return nil
1209 }
1210 }
1211 }), nil
1212}
1213
1214// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
1215//
1216// Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
1217func (_HEZ *HEZFilterer) ParseTransfer(log types.Log) (*HEZTransfer, error) {
1218 event := new(HEZTransfer)
1219 if err := _HEZ.contract.UnpackLog(event, "Transfer", log); err != nil {
1220 return nil, err
1221 }
1222 event.Raw = log
1223 return event, nil
1224}