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