From 56d890f8a12daac527bf543dc76ba7a1a6bd1693 Mon Sep 17 00:00:00 2001 From: hvthhien Date: Thu, 23 May 2024 02:54:53 +0000 Subject: [PATCH] Generate ABIs for PR #41 --- go-binding/feralfile-token/abi.go | 1143 +++++++++++++++++++++++++++++ 1 file changed, 1143 insertions(+) create mode 100644 go-binding/feralfile-token/abi.go diff --git a/go-binding/feralfile-token/abi.go b/go-binding/feralfile-token/abi.go new file mode 100644 index 0000000..d12291d --- /dev/null +++ b/go-binding/feralfile-token/abi.go @@ -0,0 +1,1143 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package feralfiletoken + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// FeralfileTokenMetaData contains all meta data concerning the FeralfileToken contract. +var FeralfileTokenMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"InvalidOwnersAndAmounts\",\"type\":\"error\"},{\"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\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"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\":[{\"internalType\":\"address\",\"name\":\"_trustee\",\"type\":\"address\"}],\"name\":\"addTrustee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_trustee\",\"type\":\"address\"}],\"name\":\"removeTrustee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"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\":\"amount\",\"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\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"trustees\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"owners\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"name\":\"batchMint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// FeralfileTokenABI is the input ABI used to generate the binding from. +// Deprecated: Use FeralfileTokenMetaData.ABI instead. +var FeralfileTokenABI = FeralfileTokenMetaData.ABI + +// FeralfileTokenBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use FeralfileTokenMetaData.Bin instead. +var FeralfileTokenBin = FeralfileTokenMetaData.Bin + +// DeployFeralfileToken deploys a new Ethereum contract, binding an instance of FeralfileToken to it. +func DeployFeralfileToken(auth *bind.TransactOpts, backend bind.ContractBackend, name_ string, symbol_ string) (common.Address, *types.Transaction, *FeralfileToken, error) { + parsed, err := FeralfileTokenMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(FeralfileTokenBin), backend, name_, symbol_) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &FeralfileToken{FeralfileTokenCaller: FeralfileTokenCaller{contract: contract}, FeralfileTokenTransactor: FeralfileTokenTransactor{contract: contract}, FeralfileTokenFilterer: FeralfileTokenFilterer{contract: contract}}, nil +} + +// FeralfileToken is an auto generated Go binding around an Ethereum contract. +type FeralfileToken struct { + FeralfileTokenCaller // Read-only binding to the contract + FeralfileTokenTransactor // Write-only binding to the contract + FeralfileTokenFilterer // Log filterer for contract events +} + +// FeralfileTokenCaller is an auto generated read-only Go binding around an Ethereum contract. +type FeralfileTokenCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// FeralfileTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. +type FeralfileTokenTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// FeralfileTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type FeralfileTokenFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// FeralfileTokenSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type FeralfileTokenSession struct { + Contract *FeralfileToken // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// FeralfileTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type FeralfileTokenCallerSession struct { + Contract *FeralfileTokenCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// FeralfileTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type FeralfileTokenTransactorSession struct { + Contract *FeralfileTokenTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// FeralfileTokenRaw is an auto generated low-level Go binding around an Ethereum contract. +type FeralfileTokenRaw struct { + Contract *FeralfileToken // Generic contract binding to access the raw methods on +} + +// FeralfileTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type FeralfileTokenCallerRaw struct { + Contract *FeralfileTokenCaller // Generic read-only contract binding to access the raw methods on +} + +// FeralfileTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type FeralfileTokenTransactorRaw struct { + Contract *FeralfileTokenTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewFeralfileToken creates a new instance of FeralfileToken, bound to a specific deployed contract. +func NewFeralfileToken(address common.Address, backend bind.ContractBackend) (*FeralfileToken, error) { + contract, err := bindFeralfileToken(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &FeralfileToken{FeralfileTokenCaller: FeralfileTokenCaller{contract: contract}, FeralfileTokenTransactor: FeralfileTokenTransactor{contract: contract}, FeralfileTokenFilterer: FeralfileTokenFilterer{contract: contract}}, nil +} + +// NewFeralfileTokenCaller creates a new read-only instance of FeralfileToken, bound to a specific deployed contract. +func NewFeralfileTokenCaller(address common.Address, caller bind.ContractCaller) (*FeralfileTokenCaller, error) { + contract, err := bindFeralfileToken(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &FeralfileTokenCaller{contract: contract}, nil +} + +// NewFeralfileTokenTransactor creates a new write-only instance of FeralfileToken, bound to a specific deployed contract. +func NewFeralfileTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*FeralfileTokenTransactor, error) { + contract, err := bindFeralfileToken(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &FeralfileTokenTransactor{contract: contract}, nil +} + +// NewFeralfileTokenFilterer creates a new log filterer instance of FeralfileToken, bound to a specific deployed contract. +func NewFeralfileTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*FeralfileTokenFilterer, error) { + contract, err := bindFeralfileToken(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &FeralfileTokenFilterer{contract: contract}, nil +} + +// bindFeralfileToken binds a generic wrapper to an already deployed contract. +func bindFeralfileToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := FeralfileTokenMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_FeralfileToken *FeralfileTokenRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _FeralfileToken.Contract.FeralfileTokenCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_FeralfileToken *FeralfileTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _FeralfileToken.Contract.FeralfileTokenTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_FeralfileToken *FeralfileTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _FeralfileToken.Contract.FeralfileTokenTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_FeralfileToken *FeralfileTokenCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _FeralfileToken.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_FeralfileToken *FeralfileTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _FeralfileToken.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_FeralfileToken *FeralfileTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _FeralfileToken.Contract.contract.Transact(opts, method, params...) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_FeralfileToken *FeralfileTokenCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _FeralfileToken.contract.Call(opts, &out, "allowance", owner, spender) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_FeralfileToken *FeralfileTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _FeralfileToken.Contract.Allowance(&_FeralfileToken.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_FeralfileToken *FeralfileTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _FeralfileToken.Contract.Allowance(&_FeralfileToken.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_FeralfileToken *FeralfileTokenCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _FeralfileToken.contract.Call(opts, &out, "balanceOf", account) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_FeralfileToken *FeralfileTokenSession) BalanceOf(account common.Address) (*big.Int, error) { + return _FeralfileToken.Contract.BalanceOf(&_FeralfileToken.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_FeralfileToken *FeralfileTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _FeralfileToken.Contract.BalanceOf(&_FeralfileToken.CallOpts, account) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_FeralfileToken *FeralfileTokenCaller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _FeralfileToken.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_FeralfileToken *FeralfileTokenSession) Decimals() (uint8, error) { + return _FeralfileToken.Contract.Decimals(&_FeralfileToken.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_FeralfileToken *FeralfileTokenCallerSession) Decimals() (uint8, error) { + return _FeralfileToken.Contract.Decimals(&_FeralfileToken.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_FeralfileToken *FeralfileTokenCaller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _FeralfileToken.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_FeralfileToken *FeralfileTokenSession) Name() (string, error) { + return _FeralfileToken.Contract.Name(&_FeralfileToken.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_FeralfileToken *FeralfileTokenCallerSession) Name() (string, error) { + return _FeralfileToken.Contract.Name(&_FeralfileToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_FeralfileToken *FeralfileTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _FeralfileToken.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_FeralfileToken *FeralfileTokenSession) Owner() (common.Address, error) { + return _FeralfileToken.Contract.Owner(&_FeralfileToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_FeralfileToken *FeralfileTokenCallerSession) Owner() (common.Address, error) { + return _FeralfileToken.Contract.Owner(&_FeralfileToken.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_FeralfileToken *FeralfileTokenCaller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _FeralfileToken.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_FeralfileToken *FeralfileTokenSession) Symbol() (string, error) { + return _FeralfileToken.Contract.Symbol(&_FeralfileToken.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_FeralfileToken *FeralfileTokenCallerSession) Symbol() (string, error) { + return _FeralfileToken.Contract.Symbol(&_FeralfileToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_FeralfileToken *FeralfileTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _FeralfileToken.contract.Call(opts, &out, "totalSupply") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_FeralfileToken *FeralfileTokenSession) TotalSupply() (*big.Int, error) { + return _FeralfileToken.Contract.TotalSupply(&_FeralfileToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_FeralfileToken *FeralfileTokenCallerSession) TotalSupply() (*big.Int, error) { + return _FeralfileToken.Contract.TotalSupply(&_FeralfileToken.CallOpts) +} + +// Trustees is a free data retrieval call binding the contract method 0xeee608a4. +// +// Solidity: function trustees(address ) view returns(bool) +func (_FeralfileToken *FeralfileTokenCaller) Trustees(opts *bind.CallOpts, arg0 common.Address) (bool, error) { + var out []interface{} + err := _FeralfileToken.contract.Call(opts, &out, "trustees", arg0) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Trustees is a free data retrieval call binding the contract method 0xeee608a4. +// +// Solidity: function trustees(address ) view returns(bool) +func (_FeralfileToken *FeralfileTokenSession) Trustees(arg0 common.Address) (bool, error) { + return _FeralfileToken.Contract.Trustees(&_FeralfileToken.CallOpts, arg0) +} + +// Trustees is a free data retrieval call binding the contract method 0xeee608a4. +// +// Solidity: function trustees(address ) view returns(bool) +func (_FeralfileToken *FeralfileTokenCallerSession) Trustees(arg0 common.Address) (bool, error) { + return _FeralfileToken.Contract.Trustees(&_FeralfileToken.CallOpts, arg0) +} + +// AddTrustee is a paid mutator transaction binding the contract method 0xdc78ac1c. +// +// Solidity: function addTrustee(address _trustee) returns() +func (_FeralfileToken *FeralfileTokenTransactor) AddTrustee(opts *bind.TransactOpts, _trustee common.Address) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "addTrustee", _trustee) +} + +// AddTrustee is a paid mutator transaction binding the contract method 0xdc78ac1c. +// +// Solidity: function addTrustee(address _trustee) returns() +func (_FeralfileToken *FeralfileTokenSession) AddTrustee(_trustee common.Address) (*types.Transaction, error) { + return _FeralfileToken.Contract.AddTrustee(&_FeralfileToken.TransactOpts, _trustee) +} + +// AddTrustee is a paid mutator transaction binding the contract method 0xdc78ac1c. +// +// Solidity: function addTrustee(address _trustee) returns() +func (_FeralfileToken *FeralfileTokenTransactorSession) AddTrustee(_trustee common.Address) (*types.Transaction, error) { + return _FeralfileToken.Contract.AddTrustee(&_FeralfileToken.TransactOpts, _trustee) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_FeralfileToken *FeralfileTokenSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.Approve(&_FeralfileToken.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.Approve(&_FeralfileToken.TransactOpts, spender, amount) +} + +// BatchMint is a paid mutator transaction binding the contract method 0x68573107. +// +// Solidity: function batchMint(address[] owners, uint256[] amounts) returns() +func (_FeralfileToken *FeralfileTokenTransactor) BatchMint(opts *bind.TransactOpts, owners []common.Address, amounts []*big.Int) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "batchMint", owners, amounts) +} + +// BatchMint is a paid mutator transaction binding the contract method 0x68573107. +// +// Solidity: function batchMint(address[] owners, uint256[] amounts) returns() +func (_FeralfileToken *FeralfileTokenSession) BatchMint(owners []common.Address, amounts []*big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.BatchMint(&_FeralfileToken.TransactOpts, owners, amounts) +} + +// BatchMint is a paid mutator transaction binding the contract method 0x68573107. +// +// Solidity: function batchMint(address[] owners, uint256[] amounts) returns() +func (_FeralfileToken *FeralfileTokenTransactorSession) BatchMint(owners []common.Address, amounts []*big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.BatchMint(&_FeralfileToken.TransactOpts, owners, amounts) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_FeralfileToken *FeralfileTokenSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.DecreaseAllowance(&_FeralfileToken.TransactOpts, spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.DecreaseAllowance(&_FeralfileToken.TransactOpts, spender, subtractedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "increaseAllowance", spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_FeralfileToken *FeralfileTokenSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.IncreaseAllowance(&_FeralfileToken.TransactOpts, spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.IncreaseAllowance(&_FeralfileToken.TransactOpts, spender, addedValue) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address owner, uint256 amount) returns() +func (_FeralfileToken *FeralfileTokenTransactor) Mint(opts *bind.TransactOpts, owner common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "mint", owner, amount) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address owner, uint256 amount) returns() +func (_FeralfileToken *FeralfileTokenSession) Mint(owner common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.Mint(&_FeralfileToken.TransactOpts, owner, amount) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address owner, uint256 amount) returns() +func (_FeralfileToken *FeralfileTokenTransactorSession) Mint(owner common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.Mint(&_FeralfileToken.TransactOpts, owner, amount) +} + +// RemoveTrustee is a paid mutator transaction binding the contract method 0x03120506. +// +// Solidity: function removeTrustee(address _trustee) returns() +func (_FeralfileToken *FeralfileTokenTransactor) RemoveTrustee(opts *bind.TransactOpts, _trustee common.Address) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "removeTrustee", _trustee) +} + +// RemoveTrustee is a paid mutator transaction binding the contract method 0x03120506. +// +// Solidity: function removeTrustee(address _trustee) returns() +func (_FeralfileToken *FeralfileTokenSession) RemoveTrustee(_trustee common.Address) (*types.Transaction, error) { + return _FeralfileToken.Contract.RemoveTrustee(&_FeralfileToken.TransactOpts, _trustee) +} + +// RemoveTrustee is a paid mutator transaction binding the contract method 0x03120506. +// +// Solidity: function removeTrustee(address _trustee) returns() +func (_FeralfileToken *FeralfileTokenTransactorSession) RemoveTrustee(_trustee common.Address) (*types.Transaction, error) { + return _FeralfileToken.Contract.RemoveTrustee(&_FeralfileToken.TransactOpts, _trustee) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_FeralfileToken *FeralfileTokenTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_FeralfileToken *FeralfileTokenSession) RenounceOwnership() (*types.Transaction, error) { + return _FeralfileToken.Contract.RenounceOwnership(&_FeralfileToken.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_FeralfileToken *FeralfileTokenTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _FeralfileToken.Contract.RenounceOwnership(&_FeralfileToken.TransactOpts) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "transfer", to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_FeralfileToken *FeralfileTokenSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.Transfer(&_FeralfileToken.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.Transfer(&_FeralfileToken.TransactOpts, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "transferFrom", from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_FeralfileToken *FeralfileTokenSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.TransferFrom(&_FeralfileToken.TransactOpts, from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_FeralfileToken *FeralfileTokenTransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _FeralfileToken.Contract.TransferFrom(&_FeralfileToken.TransactOpts, from, to, amount) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_FeralfileToken *FeralfileTokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _FeralfileToken.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_FeralfileToken *FeralfileTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _FeralfileToken.Contract.TransferOwnership(&_FeralfileToken.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_FeralfileToken *FeralfileTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _FeralfileToken.Contract.TransferOwnership(&_FeralfileToken.TransactOpts, newOwner) +} + +// FeralfileTokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the FeralfileToken contract. +type FeralfileTokenApprovalIterator struct { + Event *FeralfileTokenApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *FeralfileTokenApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(FeralfileTokenApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(FeralfileTokenApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *FeralfileTokenApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *FeralfileTokenApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// FeralfileTokenApproval represents a Approval event raised by the FeralfileToken contract. +type FeralfileTokenApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_FeralfileToken *FeralfileTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*FeralfileTokenApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _FeralfileToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &FeralfileTokenApprovalIterator{contract: _FeralfileToken.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_FeralfileToken *FeralfileTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *FeralfileTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _FeralfileToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(FeralfileTokenApproval) + if err := _FeralfileToken.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_FeralfileToken *FeralfileTokenFilterer) ParseApproval(log types.Log) (*FeralfileTokenApproval, error) { + event := new(FeralfileTokenApproval) + if err := _FeralfileToken.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// FeralfileTokenOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the FeralfileToken contract. +type FeralfileTokenOwnershipTransferredIterator struct { + Event *FeralfileTokenOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *FeralfileTokenOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(FeralfileTokenOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(FeralfileTokenOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *FeralfileTokenOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *FeralfileTokenOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// FeralfileTokenOwnershipTransferred represents a OwnershipTransferred event raised by the FeralfileToken contract. +type FeralfileTokenOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_FeralfileToken *FeralfileTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*FeralfileTokenOwnershipTransferredIterator, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _FeralfileToken.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &FeralfileTokenOwnershipTransferredIterator{contract: _FeralfileToken.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_FeralfileToken *FeralfileTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *FeralfileTokenOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _FeralfileToken.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(FeralfileTokenOwnershipTransferred) + if err := _FeralfileToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_FeralfileToken *FeralfileTokenFilterer) ParseOwnershipTransferred(log types.Log) (*FeralfileTokenOwnershipTransferred, error) { + event := new(FeralfileTokenOwnershipTransferred) + if err := _FeralfileToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// FeralfileTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the FeralfileToken contract. +type FeralfileTokenTransferIterator struct { + Event *FeralfileTokenTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *FeralfileTokenTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(FeralfileTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(FeralfileTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *FeralfileTokenTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *FeralfileTokenTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// FeralfileTokenTransfer represents a Transfer event raised by the FeralfileToken contract. +type FeralfileTokenTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_FeralfileToken *FeralfileTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*FeralfileTokenTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _FeralfileToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &FeralfileTokenTransferIterator{contract: _FeralfileToken.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_FeralfileToken *FeralfileTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *FeralfileTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _FeralfileToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(FeralfileTokenTransfer) + if err := _FeralfileToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_FeralfileToken *FeralfileTokenFilterer) ParseTransfer(log types.Log) (*FeralfileTokenTransfer, error) { + event := new(FeralfileTokenTransfer) + if err := _FeralfileToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +}