github.com/fff-chain/go-fff@v0.0.0-20220726032732-1c84420b8a99/global_config/token/token.go (about) 1 // Code generated - DO NOT EDIT. 2 // This file is a generated binding and any manual changes will be lost. 3 4 package token 5 6 import ( 7 "errors" 8 "math/big" 9 "strings" 10 11 ethereum "github.com/fff-chain/go-fff" 12 "github.com/fff-chain/go-fff/accounts/abi" 13 "github.com/fff-chain/go-fff/accounts/abi/bind" 14 "github.com/fff-chain/go-fff/common" 15 "github.com/fff-chain/go-fff/core/types" 16 "github.com/fff-chain/go-fff/event" 17 ) 18 19 // Reference imports to suppress errors if they are not otherwise used. 20 var ( 21 _ = errors.New 22 _ = big.NewInt 23 _ = strings.NewReader 24 _ = ethereum.NotFound 25 _ = bind.Bind 26 _ = common.Big1 27 _ = types.BloomLookup 28 _ = event.NewSubscription 29 ) 30 31 // BEP20TokenMetaData contains all meta data concerning the BEP20Token contract. 32 var BEP20TokenMetaData = &bind.MetaData{ 33 ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"payable\":false,\"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\":\"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\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"z_decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"z_name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"z_symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]", 34 Sigs: map[string]string{ 35 "dd62ed3e": "allowance(address,address)", 36 "095ea7b3": "approve(address,uint256)", 37 "70a08231": "balanceOf(address)", 38 "42966c68": "burn(uint256)", 39 "313ce567": "decimals()", 40 "a457c2d7": "decreaseAllowance(address,uint256)", 41 "893d20e8": "getOwner()", 42 "39509351": "increaseAllowance(address,uint256)", 43 "a0712d68": "mint(uint256)", 44 "06fdde03": "name()", 45 "8da5cb5b": "owner()", 46 "715018a6": "renounceOwnership()", 47 "95d89b41": "symbol()", 48 "18160ddd": "totalSupply()", 49 "a9059cbb": "transfer(address,uint256)", 50 "23b872dd": "transferFrom(address,address,uint256)", 51 "f2fde38b": "transferOwnership(address)", 52 "a63022fc": "z_decimals()", 53 "e15a11c8": "z_name()", 54 "831eafc1": "z_symbol()", 55 }, 56 Bin: "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", 57 } 58 59 // BEP20TokenABI is the input ABI used to generate the binding from. 60 // Deprecated: Use BEP20TokenMetaData.ABI instead. 61 var BEP20TokenABI = BEP20TokenMetaData.ABI 62 63 // Deprecated: Use BEP20TokenMetaData.Sigs instead. 64 // BEP20TokenFuncSigs maps the 4-byte function signature to its string representation. 65 var BEP20TokenFuncSigs = BEP20TokenMetaData.Sigs 66 67 // BEP20TokenBin is the compiled bytecode used for deploying new contracts. 68 // Deprecated: Use BEP20TokenMetaData.Bin instead. 69 var BEP20TokenBin = BEP20TokenMetaData.Bin 70 71 // DeployBEP20Token deploys a new Ethereum contract, binding an instance of BEP20Token to it. 72 func DeployBEP20Token(auth *bind.TransactOpts, backend bind.ContractBackend, name string) (common.Address, *types.Transaction, *BEP20Token, error) { 73 parsed, err := BEP20TokenMetaData.GetAbi() 74 if err != nil { 75 return common.Address{}, nil, nil, err 76 } 77 if parsed == nil { 78 return common.Address{}, nil, nil, errors.New("GetABI returned nil") 79 } 80 81 address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(BEP20TokenBin), backend, name) 82 if err != nil { 83 return common.Address{}, nil, nil, err 84 } 85 return address, tx, &BEP20Token{BEP20TokenCaller: BEP20TokenCaller{contract: contract}, BEP20TokenTransactor: BEP20TokenTransactor{contract: contract}, BEP20TokenFilterer: BEP20TokenFilterer{contract: contract}}, nil 86 } 87 88 // BEP20Token is an auto generated Go binding around an Ethereum contract. 89 type BEP20Token struct { 90 BEP20TokenCaller // Read-only binding to the contract 91 BEP20TokenTransactor // Write-only binding to the contract 92 BEP20TokenFilterer // Log filterer for contract events 93 } 94 95 // BEP20TokenCaller is an auto generated read-only Go binding around an Ethereum contract. 96 type BEP20TokenCaller struct { 97 contract *bind.BoundContract // Generic contract wrapper for the low level calls 98 } 99 100 // BEP20TokenTransactor is an auto generated write-only Go binding around an Ethereum contract. 101 type BEP20TokenTransactor struct { 102 contract *bind.BoundContract // Generic contract wrapper for the low level calls 103 } 104 105 // BEP20TokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 106 type BEP20TokenFilterer struct { 107 contract *bind.BoundContract // Generic contract wrapper for the low level calls 108 } 109 110 // BEP20TokenSession is an auto generated Go binding around an Ethereum contract, 111 // with pre-set call and transact options. 112 type BEP20TokenSession struct { 113 Contract *BEP20Token // Generic contract binding to set the session for 114 CallOpts bind.CallOpts // Call options to use throughout this session 115 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 116 } 117 118 // BEP20TokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, 119 // with pre-set call options. 120 type BEP20TokenCallerSession struct { 121 Contract *BEP20TokenCaller // Generic contract caller binding to set the session for 122 CallOpts bind.CallOpts // Call options to use throughout this session 123 } 124 125 // BEP20TokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 126 // with pre-set transact options. 127 type BEP20TokenTransactorSession struct { 128 Contract *BEP20TokenTransactor // Generic contract transactor binding to set the session for 129 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 130 } 131 132 // BEP20TokenRaw is an auto generated low-level Go binding around an Ethereum contract. 133 type BEP20TokenRaw struct { 134 Contract *BEP20Token // Generic contract binding to access the raw methods on 135 } 136 137 // BEP20TokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 138 type BEP20TokenCallerRaw struct { 139 Contract *BEP20TokenCaller // Generic read-only contract binding to access the raw methods on 140 } 141 142 // BEP20TokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 143 type BEP20TokenTransactorRaw struct { 144 Contract *BEP20TokenTransactor // Generic write-only contract binding to access the raw methods on 145 } 146 147 // NewBEP20Token creates a new instance of BEP20Token, bound to a specific deployed contract. 148 func NewBEP20Token(address common.Address, backend bind.ContractBackend) (*BEP20Token, error) { 149 contract, err := bindBEP20Token(address, backend, backend, backend) 150 if err != nil { 151 return nil, err 152 } 153 return &BEP20Token{BEP20TokenCaller: BEP20TokenCaller{contract: contract}, BEP20TokenTransactor: BEP20TokenTransactor{contract: contract}, BEP20TokenFilterer: BEP20TokenFilterer{contract: contract}}, nil 154 } 155 156 // NewBEP20TokenCaller creates a new read-only instance of BEP20Token, bound to a specific deployed contract. 157 func NewBEP20TokenCaller(address common.Address, caller bind.ContractCaller) (*BEP20TokenCaller, error) { 158 contract, err := bindBEP20Token(address, caller, nil, nil) 159 if err != nil { 160 return nil, err 161 } 162 return &BEP20TokenCaller{contract: contract}, nil 163 } 164 165 // NewBEP20TokenTransactor creates a new write-only instance of BEP20Token, bound to a specific deployed contract. 166 func NewBEP20TokenTransactor(address common.Address, transactor bind.ContractTransactor) (*BEP20TokenTransactor, error) { 167 contract, err := bindBEP20Token(address, nil, transactor, nil) 168 if err != nil { 169 return nil, err 170 } 171 return &BEP20TokenTransactor{contract: contract}, nil 172 } 173 174 // NewBEP20TokenFilterer creates a new log filterer instance of BEP20Token, bound to a specific deployed contract. 175 func NewBEP20TokenFilterer(address common.Address, filterer bind.ContractFilterer) (*BEP20TokenFilterer, error) { 176 contract, err := bindBEP20Token(address, nil, nil, filterer) 177 if err != nil { 178 return nil, err 179 } 180 return &BEP20TokenFilterer{contract: contract}, nil 181 } 182 183 // bindBEP20Token binds a generic wrapper to an already deployed contract. 184 func bindBEP20Token(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 185 parsed, err := abi.JSON(strings.NewReader(BEP20TokenABI)) 186 if err != nil { 187 return nil, err 188 } 189 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 190 } 191 192 // Call invokes the (constant) contract method with params as input values and 193 // sets the output to result. The result type might be a single field for simple 194 // returns, a slice of interfaces for anonymous returns and a struct for named 195 // returns. 196 func (_BEP20Token *BEP20TokenRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 197 return _BEP20Token.Contract.BEP20TokenCaller.contract.Call(opts, result, method, params...) 198 } 199 200 // Transfer initiates a plain transaction to move funds to the contract, calling 201 // its default method if one is available. 202 func (_BEP20Token *BEP20TokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 203 return _BEP20Token.Contract.BEP20TokenTransactor.contract.Transfer(opts) 204 } 205 206 // Transact invokes the (paid) contract method with params as input values. 207 func (_BEP20Token *BEP20TokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 208 return _BEP20Token.Contract.BEP20TokenTransactor.contract.Transact(opts, method, params...) 209 } 210 211 // Call invokes the (constant) contract method with params as input values and 212 // sets the output to result. The result type might be a single field for simple 213 // returns, a slice of interfaces for anonymous returns and a struct for named 214 // returns. 215 func (_BEP20Token *BEP20TokenCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 216 return _BEP20Token.Contract.contract.Call(opts, result, method, params...) 217 } 218 219 // Transfer initiates a plain transaction to move funds to the contract, calling 220 // its default method if one is available. 221 func (_BEP20Token *BEP20TokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 222 return _BEP20Token.Contract.contract.Transfer(opts) 223 } 224 225 // Transact invokes the (paid) contract method with params as input values. 226 func (_BEP20Token *BEP20TokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 227 return _BEP20Token.Contract.contract.Transact(opts, method, params...) 228 } 229 230 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 231 // 232 // Solidity: function allowance(address owner, address spender) view returns(uint256) 233 func (_BEP20Token *BEP20TokenCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 234 var out []interface{} 235 err := _BEP20Token.contract.Call(opts, &out, "allowance", owner, spender) 236 237 if err != nil { 238 return *new(*big.Int), err 239 } 240 241 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 242 243 return out0, err 244 245 } 246 247 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 248 // 249 // Solidity: function allowance(address owner, address spender) view returns(uint256) 250 func (_BEP20Token *BEP20TokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 251 return _BEP20Token.Contract.Allowance(&_BEP20Token.CallOpts, owner, spender) 252 } 253 254 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 255 // 256 // Solidity: function allowance(address owner, address spender) view returns(uint256) 257 func (_BEP20Token *BEP20TokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 258 return _BEP20Token.Contract.Allowance(&_BEP20Token.CallOpts, owner, spender) 259 } 260 261 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 262 // 263 // Solidity: function balanceOf(address account) view returns(uint256) 264 func (_BEP20Token *BEP20TokenCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 265 var out []interface{} 266 err := _BEP20Token.contract.Call(opts, &out, "balanceOf", account) 267 268 if err != nil { 269 return *new(*big.Int), err 270 } 271 272 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 273 274 return out0, err 275 276 } 277 278 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 279 // 280 // Solidity: function balanceOf(address account) view returns(uint256) 281 func (_BEP20Token *BEP20TokenSession) BalanceOf(account common.Address) (*big.Int, error) { 282 return _BEP20Token.Contract.BalanceOf(&_BEP20Token.CallOpts, account) 283 } 284 285 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 286 // 287 // Solidity: function balanceOf(address account) view returns(uint256) 288 func (_BEP20Token *BEP20TokenCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 289 return _BEP20Token.Contract.BalanceOf(&_BEP20Token.CallOpts, account) 290 } 291 292 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 293 // 294 // Solidity: function decimals() view returns(uint8) 295 func (_BEP20Token *BEP20TokenCaller) Decimals(opts *bind.CallOpts) (uint8, error) { 296 var out []interface{} 297 err := _BEP20Token.contract.Call(opts, &out, "decimals") 298 299 if err != nil { 300 return *new(uint8), err 301 } 302 303 out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) 304 305 return out0, err 306 307 } 308 309 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 310 // 311 // Solidity: function decimals() view returns(uint8) 312 func (_BEP20Token *BEP20TokenSession) Decimals() (uint8, error) { 313 return _BEP20Token.Contract.Decimals(&_BEP20Token.CallOpts) 314 } 315 316 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 317 // 318 // Solidity: function decimals() view returns(uint8) 319 func (_BEP20Token *BEP20TokenCallerSession) Decimals() (uint8, error) { 320 return _BEP20Token.Contract.Decimals(&_BEP20Token.CallOpts) 321 } 322 323 // GetOwner is a free data retrieval call binding the contract method 0x893d20e8. 324 // 325 // Solidity: function getOwner() view returns(address) 326 func (_BEP20Token *BEP20TokenCaller) GetOwner(opts *bind.CallOpts) (common.Address, error) { 327 var out []interface{} 328 err := _BEP20Token.contract.Call(opts, &out, "getOwner") 329 330 if err != nil { 331 return *new(common.Address), err 332 } 333 334 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 335 336 return out0, err 337 338 } 339 340 // GetOwner is a free data retrieval call binding the contract method 0x893d20e8. 341 // 342 // Solidity: function getOwner() view returns(address) 343 func (_BEP20Token *BEP20TokenSession) GetOwner() (common.Address, error) { 344 return _BEP20Token.Contract.GetOwner(&_BEP20Token.CallOpts) 345 } 346 347 // GetOwner is a free data retrieval call binding the contract method 0x893d20e8. 348 // 349 // Solidity: function getOwner() view returns(address) 350 func (_BEP20Token *BEP20TokenCallerSession) GetOwner() (common.Address, error) { 351 return _BEP20Token.Contract.GetOwner(&_BEP20Token.CallOpts) 352 } 353 354 // Name is a free data retrieval call binding the contract method 0x06fdde03. 355 // 356 // Solidity: function name() view returns(string) 357 func (_BEP20Token *BEP20TokenCaller) Name(opts *bind.CallOpts) (string, error) { 358 var out []interface{} 359 err := _BEP20Token.contract.Call(opts, &out, "name") 360 361 if err != nil { 362 return *new(string), err 363 } 364 365 out0 := *abi.ConvertType(out[0], new(string)).(*string) 366 367 return out0, err 368 369 } 370 371 // Name is a free data retrieval call binding the contract method 0x06fdde03. 372 // 373 // Solidity: function name() view returns(string) 374 func (_BEP20Token *BEP20TokenSession) Name() (string, error) { 375 return _BEP20Token.Contract.Name(&_BEP20Token.CallOpts) 376 } 377 378 // Name is a free data retrieval call binding the contract method 0x06fdde03. 379 // 380 // Solidity: function name() view returns(string) 381 func (_BEP20Token *BEP20TokenCallerSession) Name() (string, error) { 382 return _BEP20Token.Contract.Name(&_BEP20Token.CallOpts) 383 } 384 385 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 386 // 387 // Solidity: function owner() view returns(address) 388 func (_BEP20Token *BEP20TokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 389 var out []interface{} 390 err := _BEP20Token.contract.Call(opts, &out, "owner") 391 392 if err != nil { 393 return *new(common.Address), err 394 } 395 396 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 397 398 return out0, err 399 400 } 401 402 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 403 // 404 // Solidity: function owner() view returns(address) 405 func (_BEP20Token *BEP20TokenSession) Owner() (common.Address, error) { 406 return _BEP20Token.Contract.Owner(&_BEP20Token.CallOpts) 407 } 408 409 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 410 // 411 // Solidity: function owner() view returns(address) 412 func (_BEP20Token *BEP20TokenCallerSession) Owner() (common.Address, error) { 413 return _BEP20Token.Contract.Owner(&_BEP20Token.CallOpts) 414 } 415 416 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 417 // 418 // Solidity: function symbol() view returns(string) 419 func (_BEP20Token *BEP20TokenCaller) Symbol(opts *bind.CallOpts) (string, error) { 420 var out []interface{} 421 err := _BEP20Token.contract.Call(opts, &out, "symbol") 422 423 if err != nil { 424 return *new(string), err 425 } 426 427 out0 := *abi.ConvertType(out[0], new(string)).(*string) 428 429 return out0, err 430 431 } 432 433 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 434 // 435 // Solidity: function symbol() view returns(string) 436 func (_BEP20Token *BEP20TokenSession) Symbol() (string, error) { 437 return _BEP20Token.Contract.Symbol(&_BEP20Token.CallOpts) 438 } 439 440 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 441 // 442 // Solidity: function symbol() view returns(string) 443 func (_BEP20Token *BEP20TokenCallerSession) Symbol() (string, error) { 444 return _BEP20Token.Contract.Symbol(&_BEP20Token.CallOpts) 445 } 446 447 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 448 // 449 // Solidity: function totalSupply() view returns(uint256) 450 func (_BEP20Token *BEP20TokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 451 var out []interface{} 452 err := _BEP20Token.contract.Call(opts, &out, "totalSupply") 453 454 if err != nil { 455 return *new(*big.Int), err 456 } 457 458 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 459 460 return out0, err 461 462 } 463 464 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 465 // 466 // Solidity: function totalSupply() view returns(uint256) 467 func (_BEP20Token *BEP20TokenSession) TotalSupply() (*big.Int, error) { 468 return _BEP20Token.Contract.TotalSupply(&_BEP20Token.CallOpts) 469 } 470 471 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 472 // 473 // Solidity: function totalSupply() view returns(uint256) 474 func (_BEP20Token *BEP20TokenCallerSession) TotalSupply() (*big.Int, error) { 475 return _BEP20Token.Contract.TotalSupply(&_BEP20Token.CallOpts) 476 } 477 478 // ZDecimals is a free data retrieval call binding the contract method 0xa63022fc. 479 // 480 // Solidity: function z_decimals() view returns(uint8) 481 func (_BEP20Token *BEP20TokenCaller) ZDecimals(opts *bind.CallOpts) (uint8, error) { 482 var out []interface{} 483 err := _BEP20Token.contract.Call(opts, &out, "z_decimals") 484 485 if err != nil { 486 return *new(uint8), err 487 } 488 489 out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) 490 491 return out0, err 492 493 } 494 495 // ZDecimals is a free data retrieval call binding the contract method 0xa63022fc. 496 // 497 // Solidity: function z_decimals() view returns(uint8) 498 func (_BEP20Token *BEP20TokenSession) ZDecimals() (uint8, error) { 499 return _BEP20Token.Contract.ZDecimals(&_BEP20Token.CallOpts) 500 } 501 502 // ZDecimals is a free data retrieval call binding the contract method 0xa63022fc. 503 // 504 // Solidity: function z_decimals() view returns(uint8) 505 func (_BEP20Token *BEP20TokenCallerSession) ZDecimals() (uint8, error) { 506 return _BEP20Token.Contract.ZDecimals(&_BEP20Token.CallOpts) 507 } 508 509 // ZName is a free data retrieval call binding the contract method 0xe15a11c8. 510 // 511 // Solidity: function z_name() view returns(string) 512 func (_BEP20Token *BEP20TokenCaller) ZName(opts *bind.CallOpts) (string, error) { 513 var out []interface{} 514 err := _BEP20Token.contract.Call(opts, &out, "z_name") 515 516 if err != nil { 517 return *new(string), err 518 } 519 520 out0 := *abi.ConvertType(out[0], new(string)).(*string) 521 522 return out0, err 523 524 } 525 526 // ZName is a free data retrieval call binding the contract method 0xe15a11c8. 527 // 528 // Solidity: function z_name() view returns(string) 529 func (_BEP20Token *BEP20TokenSession) ZName() (string, error) { 530 return _BEP20Token.Contract.ZName(&_BEP20Token.CallOpts) 531 } 532 533 // ZName is a free data retrieval call binding the contract method 0xe15a11c8. 534 // 535 // Solidity: function z_name() view returns(string) 536 func (_BEP20Token *BEP20TokenCallerSession) ZName() (string, error) { 537 return _BEP20Token.Contract.ZName(&_BEP20Token.CallOpts) 538 } 539 540 // ZSymbol is a free data retrieval call binding the contract method 0x831eafc1. 541 // 542 // Solidity: function z_symbol() view returns(string) 543 func (_BEP20Token *BEP20TokenCaller) ZSymbol(opts *bind.CallOpts) (string, error) { 544 var out []interface{} 545 err := _BEP20Token.contract.Call(opts, &out, "z_symbol") 546 547 if err != nil { 548 return *new(string), err 549 } 550 551 out0 := *abi.ConvertType(out[0], new(string)).(*string) 552 553 return out0, err 554 555 } 556 557 // ZSymbol is a free data retrieval call binding the contract method 0x831eafc1. 558 // 559 // Solidity: function z_symbol() view returns(string) 560 func (_BEP20Token *BEP20TokenSession) ZSymbol() (string, error) { 561 return _BEP20Token.Contract.ZSymbol(&_BEP20Token.CallOpts) 562 } 563 564 // ZSymbol is a free data retrieval call binding the contract method 0x831eafc1. 565 // 566 // Solidity: function z_symbol() view returns(string) 567 func (_BEP20Token *BEP20TokenCallerSession) ZSymbol() (string, error) { 568 return _BEP20Token.Contract.ZSymbol(&_BEP20Token.CallOpts) 569 } 570 571 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 572 // 573 // Solidity: function approve(address spender, uint256 amount) returns(bool) 574 func (_BEP20Token *BEP20TokenTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 575 return _BEP20Token.contract.Transact(opts, "approve", spender, amount) 576 } 577 578 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 579 // 580 // Solidity: function approve(address spender, uint256 amount) returns(bool) 581 func (_BEP20Token *BEP20TokenSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 582 return _BEP20Token.Contract.Approve(&_BEP20Token.TransactOpts, spender, amount) 583 } 584 585 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 586 // 587 // Solidity: function approve(address spender, uint256 amount) returns(bool) 588 func (_BEP20Token *BEP20TokenTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 589 return _BEP20Token.Contract.Approve(&_BEP20Token.TransactOpts, spender, amount) 590 } 591 592 // Burn is a paid mutator transaction binding the contract method 0x42966c68. 593 // 594 // Solidity: function burn(uint256 amount) returns(bool) 595 func (_BEP20Token *BEP20TokenTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { 596 return _BEP20Token.contract.Transact(opts, "burn", amount) 597 } 598 599 // Burn is a paid mutator transaction binding the contract method 0x42966c68. 600 // 601 // Solidity: function burn(uint256 amount) returns(bool) 602 func (_BEP20Token *BEP20TokenSession) Burn(amount *big.Int) (*types.Transaction, error) { 603 return _BEP20Token.Contract.Burn(&_BEP20Token.TransactOpts, amount) 604 } 605 606 // Burn is a paid mutator transaction binding the contract method 0x42966c68. 607 // 608 // Solidity: function burn(uint256 amount) returns(bool) 609 func (_BEP20Token *BEP20TokenTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) { 610 return _BEP20Token.Contract.Burn(&_BEP20Token.TransactOpts, amount) 611 } 612 613 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 614 // 615 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 616 func (_BEP20Token *BEP20TokenTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 617 return _BEP20Token.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 618 } 619 620 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 621 // 622 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 623 func (_BEP20Token *BEP20TokenSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 624 return _BEP20Token.Contract.DecreaseAllowance(&_BEP20Token.TransactOpts, spender, subtractedValue) 625 } 626 627 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 628 // 629 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 630 func (_BEP20Token *BEP20TokenTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 631 return _BEP20Token.Contract.DecreaseAllowance(&_BEP20Token.TransactOpts, spender, subtractedValue) 632 } 633 634 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 635 // 636 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 637 func (_BEP20Token *BEP20TokenTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 638 return _BEP20Token.contract.Transact(opts, "increaseAllowance", spender, addedValue) 639 } 640 641 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 642 // 643 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 644 func (_BEP20Token *BEP20TokenSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 645 return _BEP20Token.Contract.IncreaseAllowance(&_BEP20Token.TransactOpts, spender, addedValue) 646 } 647 648 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 649 // 650 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 651 func (_BEP20Token *BEP20TokenTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 652 return _BEP20Token.Contract.IncreaseAllowance(&_BEP20Token.TransactOpts, spender, addedValue) 653 } 654 655 // Mint is a paid mutator transaction binding the contract method 0xa0712d68. 656 // 657 // Solidity: function mint(uint256 amount) returns(bool) 658 func (_BEP20Token *BEP20TokenTransactor) Mint(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { 659 return _BEP20Token.contract.Transact(opts, "mint", amount) 660 } 661 662 // Mint is a paid mutator transaction binding the contract method 0xa0712d68. 663 // 664 // Solidity: function mint(uint256 amount) returns(bool) 665 func (_BEP20Token *BEP20TokenSession) Mint(amount *big.Int) (*types.Transaction, error) { 666 return _BEP20Token.Contract.Mint(&_BEP20Token.TransactOpts, amount) 667 } 668 669 // Mint is a paid mutator transaction binding the contract method 0xa0712d68. 670 // 671 // Solidity: function mint(uint256 amount) returns(bool) 672 func (_BEP20Token *BEP20TokenTransactorSession) Mint(amount *big.Int) (*types.Transaction, error) { 673 return _BEP20Token.Contract.Mint(&_BEP20Token.TransactOpts, amount) 674 } 675 676 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 677 // 678 // Solidity: function renounceOwnership() returns() 679 func (_BEP20Token *BEP20TokenTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 680 return _BEP20Token.contract.Transact(opts, "renounceOwnership") 681 } 682 683 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 684 // 685 // Solidity: function renounceOwnership() returns() 686 func (_BEP20Token *BEP20TokenSession) RenounceOwnership() (*types.Transaction, error) { 687 return _BEP20Token.Contract.RenounceOwnership(&_BEP20Token.TransactOpts) 688 } 689 690 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 691 // 692 // Solidity: function renounceOwnership() returns() 693 func (_BEP20Token *BEP20TokenTransactorSession) RenounceOwnership() (*types.Transaction, error) { 694 return _BEP20Token.Contract.RenounceOwnership(&_BEP20Token.TransactOpts) 695 } 696 697 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 698 // 699 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 700 func (_BEP20Token *BEP20TokenTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 701 return _BEP20Token.contract.Transact(opts, "transfer", recipient, amount) 702 } 703 704 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 705 // 706 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 707 func (_BEP20Token *BEP20TokenSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 708 return _BEP20Token.Contract.Transfer(&_BEP20Token.TransactOpts, recipient, amount) 709 } 710 711 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 712 // 713 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 714 func (_BEP20Token *BEP20TokenTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 715 return _BEP20Token.Contract.Transfer(&_BEP20Token.TransactOpts, recipient, amount) 716 } 717 718 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 719 // 720 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 721 func (_BEP20Token *BEP20TokenTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 722 return _BEP20Token.contract.Transact(opts, "transferFrom", sender, recipient, amount) 723 } 724 725 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 726 // 727 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 728 func (_BEP20Token *BEP20TokenSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 729 return _BEP20Token.Contract.TransferFrom(&_BEP20Token.TransactOpts, sender, recipient, amount) 730 } 731 732 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 733 // 734 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 735 func (_BEP20Token *BEP20TokenTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 736 return _BEP20Token.Contract.TransferFrom(&_BEP20Token.TransactOpts, sender, recipient, amount) 737 } 738 739 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 740 // 741 // Solidity: function transferOwnership(address newOwner) returns() 742 func (_BEP20Token *BEP20TokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 743 return _BEP20Token.contract.Transact(opts, "transferOwnership", newOwner) 744 } 745 746 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 747 // 748 // Solidity: function transferOwnership(address newOwner) returns() 749 func (_BEP20Token *BEP20TokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 750 return _BEP20Token.Contract.TransferOwnership(&_BEP20Token.TransactOpts, newOwner) 751 } 752 753 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 754 // 755 // Solidity: function transferOwnership(address newOwner) returns() 756 func (_BEP20Token *BEP20TokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 757 return _BEP20Token.Contract.TransferOwnership(&_BEP20Token.TransactOpts, newOwner) 758 } 759 760 // BEP20TokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the BEP20Token contract. 761 type BEP20TokenApprovalIterator struct { 762 Event *BEP20TokenApproval // Event containing the contract specifics and raw log 763 764 contract *bind.BoundContract // Generic contract to use for unpacking event data 765 event string // Event name to use for unpacking event data 766 767 logs chan types.Log // Log channel receiving the found contract events 768 sub ethereum.Subscription // Subscription for errors, completion and termination 769 done bool // Whether the subscription completed delivering logs 770 fail error // Occurred error to stop iteration 771 } 772 773 // Next advances the iterator to the subsequent event, returning whether there 774 // are any more events found. In case of a retrieval or parsing error, false is 775 // returned and Error() can be queried for the exact failure. 776 func (it *BEP20TokenApprovalIterator) Next() bool { 777 // If the iterator failed, stop iterating 778 if it.fail != nil { 779 return false 780 } 781 // If the iterator completed, deliver directly whatever's available 782 if it.done { 783 select { 784 case log := <-it.logs: 785 it.Event = new(BEP20TokenApproval) 786 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 787 it.fail = err 788 return false 789 } 790 it.Event.Raw = log 791 return true 792 793 default: 794 return false 795 } 796 } 797 // Iterator still in progress, wait for either a data or an error event 798 select { 799 case log := <-it.logs: 800 it.Event = new(BEP20TokenApproval) 801 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 802 it.fail = err 803 return false 804 } 805 it.Event.Raw = log 806 return true 807 808 case err := <-it.sub.Err(): 809 it.done = true 810 it.fail = err 811 return it.Next() 812 } 813 } 814 815 // Error returns any retrieval or parsing error occurred during filtering. 816 func (it *BEP20TokenApprovalIterator) Error() error { 817 return it.fail 818 } 819 820 // Close terminates the iteration process, releasing any pending underlying 821 // resources. 822 func (it *BEP20TokenApprovalIterator) Close() error { 823 it.sub.Unsubscribe() 824 return nil 825 } 826 827 // BEP20TokenApproval represents a Approval event raised by the BEP20Token contract. 828 type BEP20TokenApproval struct { 829 Owner common.Address 830 Spender common.Address 831 Value *big.Int 832 Raw types.Log // Blockchain specific contextual infos 833 } 834 835 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 836 // 837 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 838 func (_BEP20Token *BEP20TokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*BEP20TokenApprovalIterator, error) { 839 840 var ownerRule []interface{} 841 for _, ownerItem := range owner { 842 ownerRule = append(ownerRule, ownerItem) 843 } 844 var spenderRule []interface{} 845 for _, spenderItem := range spender { 846 spenderRule = append(spenderRule, spenderItem) 847 } 848 849 logs, sub, err := _BEP20Token.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 850 if err != nil { 851 return nil, err 852 } 853 return &BEP20TokenApprovalIterator{contract: _BEP20Token.contract, event: "Approval", logs: logs, sub: sub}, nil 854 } 855 856 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 857 // 858 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 859 func (_BEP20Token *BEP20TokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *BEP20TokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 860 861 var ownerRule []interface{} 862 for _, ownerItem := range owner { 863 ownerRule = append(ownerRule, ownerItem) 864 } 865 var spenderRule []interface{} 866 for _, spenderItem := range spender { 867 spenderRule = append(spenderRule, spenderItem) 868 } 869 870 logs, sub, err := _BEP20Token.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 871 if err != nil { 872 return nil, err 873 } 874 return event.NewSubscription(func(quit <-chan struct{}) error { 875 defer sub.Unsubscribe() 876 for { 877 select { 878 case log := <-logs: 879 // New log arrived, parse the event and forward to the user 880 event := new(BEP20TokenApproval) 881 if err := _BEP20Token.contract.UnpackLog(event, "Approval", log); err != nil { 882 return err 883 } 884 event.Raw = log 885 886 select { 887 case sink <- event: 888 case err := <-sub.Err(): 889 return err 890 case <-quit: 891 return nil 892 } 893 case err := <-sub.Err(): 894 return err 895 case <-quit: 896 return nil 897 } 898 } 899 }), nil 900 } 901 902 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 903 // 904 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 905 func (_BEP20Token *BEP20TokenFilterer) ParseApproval(log types.Log) (*BEP20TokenApproval, error) { 906 event := new(BEP20TokenApproval) 907 if err := _BEP20Token.contract.UnpackLog(event, "Approval", log); err != nil { 908 return nil, err 909 } 910 event.Raw = log 911 return event, nil 912 } 913 914 // BEP20TokenOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the BEP20Token contract. 915 type BEP20TokenOwnershipTransferredIterator struct { 916 Event *BEP20TokenOwnershipTransferred // Event containing the contract specifics and raw log 917 918 contract *bind.BoundContract // Generic contract to use for unpacking event data 919 event string // Event name to use for unpacking event data 920 921 logs chan types.Log // Log channel receiving the found contract events 922 sub ethereum.Subscription // Subscription for errors, completion and termination 923 done bool // Whether the subscription completed delivering logs 924 fail error // Occurred error to stop iteration 925 } 926 927 // Next advances the iterator to the subsequent event, returning whether there 928 // are any more events found. In case of a retrieval or parsing error, false is 929 // returned and Error() can be queried for the exact failure. 930 func (it *BEP20TokenOwnershipTransferredIterator) Next() bool { 931 // If the iterator failed, stop iterating 932 if it.fail != nil { 933 return false 934 } 935 // If the iterator completed, deliver directly whatever's available 936 if it.done { 937 select { 938 case log := <-it.logs: 939 it.Event = new(BEP20TokenOwnershipTransferred) 940 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 941 it.fail = err 942 return false 943 } 944 it.Event.Raw = log 945 return true 946 947 default: 948 return false 949 } 950 } 951 // Iterator still in progress, wait for either a data or an error event 952 select { 953 case log := <-it.logs: 954 it.Event = new(BEP20TokenOwnershipTransferred) 955 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 956 it.fail = err 957 return false 958 } 959 it.Event.Raw = log 960 return true 961 962 case err := <-it.sub.Err(): 963 it.done = true 964 it.fail = err 965 return it.Next() 966 } 967 } 968 969 // Error returns any retrieval or parsing error occurred during filtering. 970 func (it *BEP20TokenOwnershipTransferredIterator) Error() error { 971 return it.fail 972 } 973 974 // Close terminates the iteration process, releasing any pending underlying 975 // resources. 976 func (it *BEP20TokenOwnershipTransferredIterator) Close() error { 977 it.sub.Unsubscribe() 978 return nil 979 } 980 981 // BEP20TokenOwnershipTransferred represents a OwnershipTransferred event raised by the BEP20Token contract. 982 type BEP20TokenOwnershipTransferred struct { 983 PreviousOwner common.Address 984 NewOwner common.Address 985 Raw types.Log // Blockchain specific contextual infos 986 } 987 988 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 989 // 990 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 991 func (_BEP20Token *BEP20TokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*BEP20TokenOwnershipTransferredIterator, error) { 992 993 var previousOwnerRule []interface{} 994 for _, previousOwnerItem := range previousOwner { 995 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 996 } 997 var newOwnerRule []interface{} 998 for _, newOwnerItem := range newOwner { 999 newOwnerRule = append(newOwnerRule, newOwnerItem) 1000 } 1001 1002 logs, sub, err := _BEP20Token.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 1003 if err != nil { 1004 return nil, err 1005 } 1006 return &BEP20TokenOwnershipTransferredIterator{contract: _BEP20Token.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 1007 } 1008 1009 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 1010 // 1011 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 1012 func (_BEP20Token *BEP20TokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *BEP20TokenOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 1013 1014 var previousOwnerRule []interface{} 1015 for _, previousOwnerItem := range previousOwner { 1016 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 1017 } 1018 var newOwnerRule []interface{} 1019 for _, newOwnerItem := range newOwner { 1020 newOwnerRule = append(newOwnerRule, newOwnerItem) 1021 } 1022 1023 logs, sub, err := _BEP20Token.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 1024 if err != nil { 1025 return nil, err 1026 } 1027 return event.NewSubscription(func(quit <-chan struct{}) error { 1028 defer sub.Unsubscribe() 1029 for { 1030 select { 1031 case log := <-logs: 1032 // New log arrived, parse the event and forward to the user 1033 event := new(BEP20TokenOwnershipTransferred) 1034 if err := _BEP20Token.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 1035 return err 1036 } 1037 event.Raw = log 1038 1039 select { 1040 case sink <- event: 1041 case err := <-sub.Err(): 1042 return err 1043 case <-quit: 1044 return nil 1045 } 1046 case err := <-sub.Err(): 1047 return err 1048 case <-quit: 1049 return nil 1050 } 1051 } 1052 }), nil 1053 } 1054 1055 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 1056 // 1057 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 1058 func (_BEP20Token *BEP20TokenFilterer) ParseOwnershipTransferred(log types.Log) (*BEP20TokenOwnershipTransferred, error) { 1059 event := new(BEP20TokenOwnershipTransferred) 1060 if err := _BEP20Token.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 1061 return nil, err 1062 } 1063 event.Raw = log 1064 return event, nil 1065 } 1066 1067 // BEP20TokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the BEP20Token contract. 1068 type BEP20TokenTransferIterator struct { 1069 Event *BEP20TokenTransfer // Event containing the contract specifics and raw log 1070 1071 contract *bind.BoundContract // Generic contract to use for unpacking event data 1072 event string // Event name to use for unpacking event data 1073 1074 logs chan types.Log // Log channel receiving the found contract events 1075 sub ethereum.Subscription // Subscription for errors, completion and termination 1076 done bool // Whether the subscription completed delivering logs 1077 fail error // Occurred error to stop iteration 1078 } 1079 1080 // Next advances the iterator to the subsequent event, returning whether there 1081 // are any more events found. In case of a retrieval or parsing error, false is 1082 // returned and Error() can be queried for the exact failure. 1083 func (it *BEP20TokenTransferIterator) Next() bool { 1084 // If the iterator failed, stop iterating 1085 if it.fail != nil { 1086 return false 1087 } 1088 // If the iterator completed, deliver directly whatever's available 1089 if it.done { 1090 select { 1091 case log := <-it.logs: 1092 it.Event = new(BEP20TokenTransfer) 1093 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1094 it.fail = err 1095 return false 1096 } 1097 it.Event.Raw = log 1098 return true 1099 1100 default: 1101 return false 1102 } 1103 } 1104 // Iterator still in progress, wait for either a data or an error event 1105 select { 1106 case log := <-it.logs: 1107 it.Event = new(BEP20TokenTransfer) 1108 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1109 it.fail = err 1110 return false 1111 } 1112 it.Event.Raw = log 1113 return true 1114 1115 case err := <-it.sub.Err(): 1116 it.done = true 1117 it.fail = err 1118 return it.Next() 1119 } 1120 } 1121 1122 // Error returns any retrieval or parsing error occurred during filtering. 1123 func (it *BEP20TokenTransferIterator) Error() error { 1124 return it.fail 1125 } 1126 1127 // Close terminates the iteration process, releasing any pending underlying 1128 // resources. 1129 func (it *BEP20TokenTransferIterator) Close() error { 1130 it.sub.Unsubscribe() 1131 return nil 1132 } 1133 1134 // BEP20TokenTransfer represents a Transfer event raised by the BEP20Token contract. 1135 type BEP20TokenTransfer struct { 1136 From common.Address 1137 To common.Address 1138 Value *big.Int 1139 Raw types.Log // Blockchain specific contextual infos 1140 } 1141 1142 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1143 // 1144 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1145 func (_BEP20Token *BEP20TokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*BEP20TokenTransferIterator, error) { 1146 1147 var fromRule []interface{} 1148 for _, fromItem := range from { 1149 fromRule = append(fromRule, fromItem) 1150 } 1151 var toRule []interface{} 1152 for _, toItem := range to { 1153 toRule = append(toRule, toItem) 1154 } 1155 1156 logs, sub, err := _BEP20Token.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 1157 if err != nil { 1158 return nil, err 1159 } 1160 return &BEP20TokenTransferIterator{contract: _BEP20Token.contract, event: "Transfer", logs: logs, sub: sub}, nil 1161 } 1162 1163 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1164 // 1165 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1166 func (_BEP20Token *BEP20TokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *BEP20TokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 1167 1168 var fromRule []interface{} 1169 for _, fromItem := range from { 1170 fromRule = append(fromRule, fromItem) 1171 } 1172 var toRule []interface{} 1173 for _, toItem := range to { 1174 toRule = append(toRule, toItem) 1175 } 1176 1177 logs, sub, err := _BEP20Token.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 1178 if err != nil { 1179 return nil, err 1180 } 1181 return event.NewSubscription(func(quit <-chan struct{}) error { 1182 defer sub.Unsubscribe() 1183 for { 1184 select { 1185 case log := <-logs: 1186 // New log arrived, parse the event and forward to the user 1187 event := new(BEP20TokenTransfer) 1188 if err := _BEP20Token.contract.UnpackLog(event, "Transfer", log); err != nil { 1189 return err 1190 } 1191 event.Raw = log 1192 1193 select { 1194 case sink <- event: 1195 case err := <-sub.Err(): 1196 return err 1197 case <-quit: 1198 return nil 1199 } 1200 case err := <-sub.Err(): 1201 return err 1202 case <-quit: 1203 return nil 1204 } 1205 } 1206 }), nil 1207 } 1208 1209 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1210 // 1211 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1212 func (_BEP20Token *BEP20TokenFilterer) ParseTransfer(log types.Log) (*BEP20TokenTransfer, error) { 1213 event := new(BEP20TokenTransfer) 1214 if err := _BEP20Token.contract.UnpackLog(event, "Transfer", log); err != nil { 1215 return nil, err 1216 } 1217 event.Raw = log 1218 return event, nil 1219 } 1220 1221 // ContextMetaData contains all meta data concerning the Context contract. 1222 var ContextMetaData = &bind.MetaData{ 1223 ABI: "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]", 1224 } 1225 1226 // ContextABI is the input ABI used to generate the binding from. 1227 // Deprecated: Use ContextMetaData.ABI instead. 1228 var ContextABI = ContextMetaData.ABI 1229 1230 // Context is an auto generated Go binding around an Ethereum contract. 1231 type Context struct { 1232 ContextCaller // Read-only binding to the contract 1233 ContextTransactor // Write-only binding to the contract 1234 ContextFilterer // Log filterer for contract events 1235 } 1236 1237 // ContextCaller is an auto generated read-only Go binding around an Ethereum contract. 1238 type ContextCaller struct { 1239 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1240 } 1241 1242 // ContextTransactor is an auto generated write-only Go binding around an Ethereum contract. 1243 type ContextTransactor struct { 1244 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1245 } 1246 1247 // ContextFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 1248 type ContextFilterer struct { 1249 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1250 } 1251 1252 // ContextSession is an auto generated Go binding around an Ethereum contract, 1253 // with pre-set call and transact options. 1254 type ContextSession struct { 1255 Contract *Context // Generic contract binding to set the session for 1256 CallOpts bind.CallOpts // Call options to use throughout this session 1257 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1258 } 1259 1260 // ContextCallerSession is an auto generated read-only Go binding around an Ethereum contract, 1261 // with pre-set call options. 1262 type ContextCallerSession struct { 1263 Contract *ContextCaller // Generic contract caller binding to set the session for 1264 CallOpts bind.CallOpts // Call options to use throughout this session 1265 } 1266 1267 // ContextTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 1268 // with pre-set transact options. 1269 type ContextTransactorSession struct { 1270 Contract *ContextTransactor // Generic contract transactor binding to set the session for 1271 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1272 } 1273 1274 // ContextRaw is an auto generated low-level Go binding around an Ethereum contract. 1275 type ContextRaw struct { 1276 Contract *Context // Generic contract binding to access the raw methods on 1277 } 1278 1279 // ContextCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 1280 type ContextCallerRaw struct { 1281 Contract *ContextCaller // Generic read-only contract binding to access the raw methods on 1282 } 1283 1284 // ContextTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 1285 type ContextTransactorRaw struct { 1286 Contract *ContextTransactor // Generic write-only contract binding to access the raw methods on 1287 } 1288 1289 // NewContext creates a new instance of Context, bound to a specific deployed contract. 1290 func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error) { 1291 contract, err := bindContext(address, backend, backend, backend) 1292 if err != nil { 1293 return nil, err 1294 } 1295 return &Context{ContextCaller: ContextCaller{contract: contract}, ContextTransactor: ContextTransactor{contract: contract}, ContextFilterer: ContextFilterer{contract: contract}}, nil 1296 } 1297 1298 // NewContextCaller creates a new read-only instance of Context, bound to a specific deployed contract. 1299 func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error) { 1300 contract, err := bindContext(address, caller, nil, nil) 1301 if err != nil { 1302 return nil, err 1303 } 1304 return &ContextCaller{contract: contract}, nil 1305 } 1306 1307 // NewContextTransactor creates a new write-only instance of Context, bound to a specific deployed contract. 1308 func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error) { 1309 contract, err := bindContext(address, nil, transactor, nil) 1310 if err != nil { 1311 return nil, err 1312 } 1313 return &ContextTransactor{contract: contract}, nil 1314 } 1315 1316 // NewContextFilterer creates a new log filterer instance of Context, bound to a specific deployed contract. 1317 func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error) { 1318 contract, err := bindContext(address, nil, nil, filterer) 1319 if err != nil { 1320 return nil, err 1321 } 1322 return &ContextFilterer{contract: contract}, nil 1323 } 1324 1325 // bindContext binds a generic wrapper to an already deployed contract. 1326 func bindContext(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 1327 parsed, err := abi.JSON(strings.NewReader(ContextABI)) 1328 if err != nil { 1329 return nil, err 1330 } 1331 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 1332 } 1333 1334 // Call invokes the (constant) contract method with params as input values and 1335 // sets the output to result. The result type might be a single field for simple 1336 // returns, a slice of interfaces for anonymous returns and a struct for named 1337 // returns. 1338 func (_Context *ContextRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 1339 return _Context.Contract.ContextCaller.contract.Call(opts, result, method, params...) 1340 } 1341 1342 // Transfer initiates a plain transaction to move funds to the contract, calling 1343 // its default method if one is available. 1344 func (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1345 return _Context.Contract.ContextTransactor.contract.Transfer(opts) 1346 } 1347 1348 // Transact invokes the (paid) contract method with params as input values. 1349 func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1350 return _Context.Contract.ContextTransactor.contract.Transact(opts, method, params...) 1351 } 1352 1353 // Call invokes the (constant) contract method with params as input values and 1354 // sets the output to result. The result type might be a single field for simple 1355 // returns, a slice of interfaces for anonymous returns and a struct for named 1356 // returns. 1357 func (_Context *ContextCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 1358 return _Context.Contract.contract.Call(opts, result, method, params...) 1359 } 1360 1361 // Transfer initiates a plain transaction to move funds to the contract, calling 1362 // its default method if one is available. 1363 func (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1364 return _Context.Contract.contract.Transfer(opts) 1365 } 1366 1367 // Transact invokes the (paid) contract method with params as input values. 1368 func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1369 return _Context.Contract.contract.Transact(opts, method, params...) 1370 } 1371 1372 // IBEP20MetaData contains all meta data concerning the IBEP20 contract. 1373 var IBEP20MetaData = &bind.MetaData{ 1374 ABI: "[{\"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\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", 1375 Sigs: map[string]string{ 1376 "dd62ed3e": "allowance(address,address)", 1377 "095ea7b3": "approve(address,uint256)", 1378 "70a08231": "balanceOf(address)", 1379 "313ce567": "decimals()", 1380 "893d20e8": "getOwner()", 1381 "06fdde03": "name()", 1382 "95d89b41": "symbol()", 1383 "18160ddd": "totalSupply()", 1384 "a9059cbb": "transfer(address,uint256)", 1385 "23b872dd": "transferFrom(address,address,uint256)", 1386 }, 1387 } 1388 1389 // IBEP20ABI is the input ABI used to generate the binding from. 1390 // Deprecated: Use IBEP20MetaData.ABI instead. 1391 var IBEP20ABI = IBEP20MetaData.ABI 1392 1393 // Deprecated: Use IBEP20MetaData.Sigs instead. 1394 // IBEP20FuncSigs maps the 4-byte function signature to its string representation. 1395 var IBEP20FuncSigs = IBEP20MetaData.Sigs 1396 1397 // IBEP20 is an auto generated Go binding around an Ethereum contract. 1398 type IBEP20 struct { 1399 IBEP20Caller // Read-only binding to the contract 1400 IBEP20Transactor // Write-only binding to the contract 1401 IBEP20Filterer // Log filterer for contract events 1402 } 1403 1404 // IBEP20Caller is an auto generated read-only Go binding around an Ethereum contract. 1405 type IBEP20Caller struct { 1406 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1407 } 1408 1409 // IBEP20Transactor is an auto generated write-only Go binding around an Ethereum contract. 1410 type IBEP20Transactor struct { 1411 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1412 } 1413 1414 // IBEP20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. 1415 type IBEP20Filterer struct { 1416 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1417 } 1418 1419 // IBEP20Session is an auto generated Go binding around an Ethereum contract, 1420 // with pre-set call and transact options. 1421 type IBEP20Session struct { 1422 Contract *IBEP20 // Generic contract binding to set the session for 1423 CallOpts bind.CallOpts // Call options to use throughout this session 1424 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1425 } 1426 1427 // IBEP20CallerSession is an auto generated read-only Go binding around an Ethereum contract, 1428 // with pre-set call options. 1429 type IBEP20CallerSession struct { 1430 Contract *IBEP20Caller // Generic contract caller binding to set the session for 1431 CallOpts bind.CallOpts // Call options to use throughout this session 1432 } 1433 1434 // IBEP20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, 1435 // with pre-set transact options. 1436 type IBEP20TransactorSession struct { 1437 Contract *IBEP20Transactor // Generic contract transactor binding to set the session for 1438 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1439 } 1440 1441 // IBEP20Raw is an auto generated low-level Go binding around an Ethereum contract. 1442 type IBEP20Raw struct { 1443 Contract *IBEP20 // Generic contract binding to access the raw methods on 1444 } 1445 1446 // IBEP20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 1447 type IBEP20CallerRaw struct { 1448 Contract *IBEP20Caller // Generic read-only contract binding to access the raw methods on 1449 } 1450 1451 // IBEP20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 1452 type IBEP20TransactorRaw struct { 1453 Contract *IBEP20Transactor // Generic write-only contract binding to access the raw methods on 1454 } 1455 1456 // NewIBEP20 creates a new instance of IBEP20, bound to a specific deployed contract. 1457 func NewIBEP20(address common.Address, backend bind.ContractBackend) (*IBEP20, error) { 1458 contract, err := bindIBEP20(address, backend, backend, backend) 1459 if err != nil { 1460 return nil, err 1461 } 1462 return &IBEP20{IBEP20Caller: IBEP20Caller{contract: contract}, IBEP20Transactor: IBEP20Transactor{contract: contract}, IBEP20Filterer: IBEP20Filterer{contract: contract}}, nil 1463 } 1464 1465 // NewIBEP20Caller creates a new read-only instance of IBEP20, bound to a specific deployed contract. 1466 func NewIBEP20Caller(address common.Address, caller bind.ContractCaller) (*IBEP20Caller, error) { 1467 contract, err := bindIBEP20(address, caller, nil, nil) 1468 if err != nil { 1469 return nil, err 1470 } 1471 return &IBEP20Caller{contract: contract}, nil 1472 } 1473 1474 // NewIBEP20Transactor creates a new write-only instance of IBEP20, bound to a specific deployed contract. 1475 func NewIBEP20Transactor(address common.Address, transactor bind.ContractTransactor) (*IBEP20Transactor, error) { 1476 contract, err := bindIBEP20(address, nil, transactor, nil) 1477 if err != nil { 1478 return nil, err 1479 } 1480 return &IBEP20Transactor{contract: contract}, nil 1481 } 1482 1483 // NewIBEP20Filterer creates a new log filterer instance of IBEP20, bound to a specific deployed contract. 1484 func NewIBEP20Filterer(address common.Address, filterer bind.ContractFilterer) (*IBEP20Filterer, error) { 1485 contract, err := bindIBEP20(address, nil, nil, filterer) 1486 if err != nil { 1487 return nil, err 1488 } 1489 return &IBEP20Filterer{contract: contract}, nil 1490 } 1491 1492 // bindIBEP20 binds a generic wrapper to an already deployed contract. 1493 func bindIBEP20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 1494 parsed, err := abi.JSON(strings.NewReader(IBEP20ABI)) 1495 if err != nil { 1496 return nil, err 1497 } 1498 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 1499 } 1500 1501 // Call invokes the (constant) contract method with params as input values and 1502 // sets the output to result. The result type might be a single field for simple 1503 // returns, a slice of interfaces for anonymous returns and a struct for named 1504 // returns. 1505 func (_IBEP20 *IBEP20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 1506 return _IBEP20.Contract.IBEP20Caller.contract.Call(opts, result, method, params...) 1507 } 1508 1509 // Transfer initiates a plain transaction to move funds to the contract, calling 1510 // its default method if one is available. 1511 func (_IBEP20 *IBEP20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1512 return _IBEP20.Contract.IBEP20Transactor.contract.Transfer(opts) 1513 } 1514 1515 // Transact invokes the (paid) contract method with params as input values. 1516 func (_IBEP20 *IBEP20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1517 return _IBEP20.Contract.IBEP20Transactor.contract.Transact(opts, method, params...) 1518 } 1519 1520 // Call invokes the (constant) contract method with params as input values and 1521 // sets the output to result. The result type might be a single field for simple 1522 // returns, a slice of interfaces for anonymous returns and a struct for named 1523 // returns. 1524 func (_IBEP20 *IBEP20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 1525 return _IBEP20.Contract.contract.Call(opts, result, method, params...) 1526 } 1527 1528 // Transfer initiates a plain transaction to move funds to the contract, calling 1529 // its default method if one is available. 1530 func (_IBEP20 *IBEP20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1531 return _IBEP20.Contract.contract.Transfer(opts) 1532 } 1533 1534 // Transact invokes the (paid) contract method with params as input values. 1535 func (_IBEP20 *IBEP20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1536 return _IBEP20.Contract.contract.Transact(opts, method, params...) 1537 } 1538 1539 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1540 // 1541 // Solidity: function allowance(address _owner, address spender) view returns(uint256) 1542 func (_IBEP20 *IBEP20Caller) Allowance(opts *bind.CallOpts, _owner common.Address, spender common.Address) (*big.Int, error) { 1543 var out []interface{} 1544 err := _IBEP20.contract.Call(opts, &out, "allowance", _owner, spender) 1545 1546 if err != nil { 1547 return *new(*big.Int), err 1548 } 1549 1550 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 1551 1552 return out0, err 1553 1554 } 1555 1556 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1557 // 1558 // Solidity: function allowance(address _owner, address spender) view returns(uint256) 1559 func (_IBEP20 *IBEP20Session) Allowance(_owner common.Address, spender common.Address) (*big.Int, error) { 1560 return _IBEP20.Contract.Allowance(&_IBEP20.CallOpts, _owner, spender) 1561 } 1562 1563 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1564 // 1565 // Solidity: function allowance(address _owner, address spender) view returns(uint256) 1566 func (_IBEP20 *IBEP20CallerSession) Allowance(_owner common.Address, spender common.Address) (*big.Int, error) { 1567 return _IBEP20.Contract.Allowance(&_IBEP20.CallOpts, _owner, spender) 1568 } 1569 1570 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1571 // 1572 // Solidity: function balanceOf(address account) view returns(uint256) 1573 func (_IBEP20 *IBEP20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 1574 var out []interface{} 1575 err := _IBEP20.contract.Call(opts, &out, "balanceOf", account) 1576 1577 if err != nil { 1578 return *new(*big.Int), err 1579 } 1580 1581 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 1582 1583 return out0, err 1584 1585 } 1586 1587 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1588 // 1589 // Solidity: function balanceOf(address account) view returns(uint256) 1590 func (_IBEP20 *IBEP20Session) BalanceOf(account common.Address) (*big.Int, error) { 1591 return _IBEP20.Contract.BalanceOf(&_IBEP20.CallOpts, account) 1592 } 1593 1594 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1595 // 1596 // Solidity: function balanceOf(address account) view returns(uint256) 1597 func (_IBEP20 *IBEP20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { 1598 return _IBEP20.Contract.BalanceOf(&_IBEP20.CallOpts, account) 1599 } 1600 1601 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 1602 // 1603 // Solidity: function decimals() view returns(uint8) 1604 func (_IBEP20 *IBEP20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { 1605 var out []interface{} 1606 err := _IBEP20.contract.Call(opts, &out, "decimals") 1607 1608 if err != nil { 1609 return *new(uint8), err 1610 } 1611 1612 out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) 1613 1614 return out0, err 1615 1616 } 1617 1618 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 1619 // 1620 // Solidity: function decimals() view returns(uint8) 1621 func (_IBEP20 *IBEP20Session) Decimals() (uint8, error) { 1622 return _IBEP20.Contract.Decimals(&_IBEP20.CallOpts) 1623 } 1624 1625 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 1626 // 1627 // Solidity: function decimals() view returns(uint8) 1628 func (_IBEP20 *IBEP20CallerSession) Decimals() (uint8, error) { 1629 return _IBEP20.Contract.Decimals(&_IBEP20.CallOpts) 1630 } 1631 1632 // GetOwner is a free data retrieval call binding the contract method 0x893d20e8. 1633 // 1634 // Solidity: function getOwner() view returns(address) 1635 func (_IBEP20 *IBEP20Caller) GetOwner(opts *bind.CallOpts) (common.Address, error) { 1636 var out []interface{} 1637 err := _IBEP20.contract.Call(opts, &out, "getOwner") 1638 1639 if err != nil { 1640 return *new(common.Address), err 1641 } 1642 1643 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 1644 1645 return out0, err 1646 1647 } 1648 1649 // GetOwner is a free data retrieval call binding the contract method 0x893d20e8. 1650 // 1651 // Solidity: function getOwner() view returns(address) 1652 func (_IBEP20 *IBEP20Session) GetOwner() (common.Address, error) { 1653 return _IBEP20.Contract.GetOwner(&_IBEP20.CallOpts) 1654 } 1655 1656 // GetOwner is a free data retrieval call binding the contract method 0x893d20e8. 1657 // 1658 // Solidity: function getOwner() view returns(address) 1659 func (_IBEP20 *IBEP20CallerSession) GetOwner() (common.Address, error) { 1660 return _IBEP20.Contract.GetOwner(&_IBEP20.CallOpts) 1661 } 1662 1663 // Name is a free data retrieval call binding the contract method 0x06fdde03. 1664 // 1665 // Solidity: function name() view returns(string) 1666 func (_IBEP20 *IBEP20Caller) Name(opts *bind.CallOpts) (string, error) { 1667 var out []interface{} 1668 err := _IBEP20.contract.Call(opts, &out, "name") 1669 1670 if err != nil { 1671 return *new(string), err 1672 } 1673 1674 out0 := *abi.ConvertType(out[0], new(string)).(*string) 1675 1676 return out0, err 1677 1678 } 1679 1680 // Name is a free data retrieval call binding the contract method 0x06fdde03. 1681 // 1682 // Solidity: function name() view returns(string) 1683 func (_IBEP20 *IBEP20Session) Name() (string, error) { 1684 return _IBEP20.Contract.Name(&_IBEP20.CallOpts) 1685 } 1686 1687 // Name is a free data retrieval call binding the contract method 0x06fdde03. 1688 // 1689 // Solidity: function name() view returns(string) 1690 func (_IBEP20 *IBEP20CallerSession) Name() (string, error) { 1691 return _IBEP20.Contract.Name(&_IBEP20.CallOpts) 1692 } 1693 1694 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 1695 // 1696 // Solidity: function symbol() view returns(string) 1697 func (_IBEP20 *IBEP20Caller) Symbol(opts *bind.CallOpts) (string, error) { 1698 var out []interface{} 1699 err := _IBEP20.contract.Call(opts, &out, "symbol") 1700 1701 if err != nil { 1702 return *new(string), err 1703 } 1704 1705 out0 := *abi.ConvertType(out[0], new(string)).(*string) 1706 1707 return out0, err 1708 1709 } 1710 1711 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 1712 // 1713 // Solidity: function symbol() view returns(string) 1714 func (_IBEP20 *IBEP20Session) Symbol() (string, error) { 1715 return _IBEP20.Contract.Symbol(&_IBEP20.CallOpts) 1716 } 1717 1718 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 1719 // 1720 // Solidity: function symbol() view returns(string) 1721 func (_IBEP20 *IBEP20CallerSession) Symbol() (string, error) { 1722 return _IBEP20.Contract.Symbol(&_IBEP20.CallOpts) 1723 } 1724 1725 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1726 // 1727 // Solidity: function totalSupply() view returns(uint256) 1728 func (_IBEP20 *IBEP20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 1729 var out []interface{} 1730 err := _IBEP20.contract.Call(opts, &out, "totalSupply") 1731 1732 if err != nil { 1733 return *new(*big.Int), err 1734 } 1735 1736 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 1737 1738 return out0, err 1739 1740 } 1741 1742 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1743 // 1744 // Solidity: function totalSupply() view returns(uint256) 1745 func (_IBEP20 *IBEP20Session) TotalSupply() (*big.Int, error) { 1746 return _IBEP20.Contract.TotalSupply(&_IBEP20.CallOpts) 1747 } 1748 1749 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1750 // 1751 // Solidity: function totalSupply() view returns(uint256) 1752 func (_IBEP20 *IBEP20CallerSession) TotalSupply() (*big.Int, error) { 1753 return _IBEP20.Contract.TotalSupply(&_IBEP20.CallOpts) 1754 } 1755 1756 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1757 // 1758 // Solidity: function approve(address spender, uint256 amount) returns(bool) 1759 func (_IBEP20 *IBEP20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 1760 return _IBEP20.contract.Transact(opts, "approve", spender, amount) 1761 } 1762 1763 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1764 // 1765 // Solidity: function approve(address spender, uint256 amount) returns(bool) 1766 func (_IBEP20 *IBEP20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 1767 return _IBEP20.Contract.Approve(&_IBEP20.TransactOpts, spender, amount) 1768 } 1769 1770 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1771 // 1772 // Solidity: function approve(address spender, uint256 amount) returns(bool) 1773 func (_IBEP20 *IBEP20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 1774 return _IBEP20.Contract.Approve(&_IBEP20.TransactOpts, spender, amount) 1775 } 1776 1777 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1778 // 1779 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 1780 func (_IBEP20 *IBEP20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1781 return _IBEP20.contract.Transact(opts, "transfer", recipient, amount) 1782 } 1783 1784 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1785 // 1786 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 1787 func (_IBEP20 *IBEP20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1788 return _IBEP20.Contract.Transfer(&_IBEP20.TransactOpts, recipient, amount) 1789 } 1790 1791 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1792 // 1793 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 1794 func (_IBEP20 *IBEP20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1795 return _IBEP20.Contract.Transfer(&_IBEP20.TransactOpts, recipient, amount) 1796 } 1797 1798 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 1799 // 1800 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 1801 func (_IBEP20 *IBEP20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1802 return _IBEP20.contract.Transact(opts, "transferFrom", sender, recipient, amount) 1803 } 1804 1805 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 1806 // 1807 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 1808 func (_IBEP20 *IBEP20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1809 return _IBEP20.Contract.TransferFrom(&_IBEP20.TransactOpts, sender, recipient, amount) 1810 } 1811 1812 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 1813 // 1814 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 1815 func (_IBEP20 *IBEP20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1816 return _IBEP20.Contract.TransferFrom(&_IBEP20.TransactOpts, sender, recipient, amount) 1817 } 1818 1819 // IBEP20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IBEP20 contract. 1820 type IBEP20ApprovalIterator struct { 1821 Event *IBEP20Approval // Event containing the contract specifics and raw log 1822 1823 contract *bind.BoundContract // Generic contract to use for unpacking event data 1824 event string // Event name to use for unpacking event data 1825 1826 logs chan types.Log // Log channel receiving the found contract events 1827 sub ethereum.Subscription // Subscription for errors, completion and termination 1828 done bool // Whether the subscription completed delivering logs 1829 fail error // Occurred error to stop iteration 1830 } 1831 1832 // Next advances the iterator to the subsequent event, returning whether there 1833 // are any more events found. In case of a retrieval or parsing error, false is 1834 // returned and Error() can be queried for the exact failure. 1835 func (it *IBEP20ApprovalIterator) Next() bool { 1836 // If the iterator failed, stop iterating 1837 if it.fail != nil { 1838 return false 1839 } 1840 // If the iterator completed, deliver directly whatever's available 1841 if it.done { 1842 select { 1843 case log := <-it.logs: 1844 it.Event = new(IBEP20Approval) 1845 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1846 it.fail = err 1847 return false 1848 } 1849 it.Event.Raw = log 1850 return true 1851 1852 default: 1853 return false 1854 } 1855 } 1856 // Iterator still in progress, wait for either a data or an error event 1857 select { 1858 case log := <-it.logs: 1859 it.Event = new(IBEP20Approval) 1860 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1861 it.fail = err 1862 return false 1863 } 1864 it.Event.Raw = log 1865 return true 1866 1867 case err := <-it.sub.Err(): 1868 it.done = true 1869 it.fail = err 1870 return it.Next() 1871 } 1872 } 1873 1874 // Error returns any retrieval or parsing error occurred during filtering. 1875 func (it *IBEP20ApprovalIterator) Error() error { 1876 return it.fail 1877 } 1878 1879 // Close terminates the iteration process, releasing any pending underlying 1880 // resources. 1881 func (it *IBEP20ApprovalIterator) Close() error { 1882 it.sub.Unsubscribe() 1883 return nil 1884 } 1885 1886 // IBEP20Approval represents a Approval event raised by the IBEP20 contract. 1887 type IBEP20Approval struct { 1888 Owner common.Address 1889 Spender common.Address 1890 Value *big.Int 1891 Raw types.Log // Blockchain specific contextual infos 1892 } 1893 1894 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 1895 // 1896 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 1897 func (_IBEP20 *IBEP20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IBEP20ApprovalIterator, error) { 1898 1899 var ownerRule []interface{} 1900 for _, ownerItem := range owner { 1901 ownerRule = append(ownerRule, ownerItem) 1902 } 1903 var spenderRule []interface{} 1904 for _, spenderItem := range spender { 1905 spenderRule = append(spenderRule, spenderItem) 1906 } 1907 1908 logs, sub, err := _IBEP20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 1909 if err != nil { 1910 return nil, err 1911 } 1912 return &IBEP20ApprovalIterator{contract: _IBEP20.contract, event: "Approval", logs: logs, sub: sub}, nil 1913 } 1914 1915 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 1916 // 1917 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 1918 func (_IBEP20 *IBEP20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IBEP20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 1919 1920 var ownerRule []interface{} 1921 for _, ownerItem := range owner { 1922 ownerRule = append(ownerRule, ownerItem) 1923 } 1924 var spenderRule []interface{} 1925 for _, spenderItem := range spender { 1926 spenderRule = append(spenderRule, spenderItem) 1927 } 1928 1929 logs, sub, err := _IBEP20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 1930 if err != nil { 1931 return nil, err 1932 } 1933 return event.NewSubscription(func(quit <-chan struct{}) error { 1934 defer sub.Unsubscribe() 1935 for { 1936 select { 1937 case log := <-logs: 1938 // New log arrived, parse the event and forward to the user 1939 event := new(IBEP20Approval) 1940 if err := _IBEP20.contract.UnpackLog(event, "Approval", log); err != nil { 1941 return err 1942 } 1943 event.Raw = log 1944 1945 select { 1946 case sink <- event: 1947 case err := <-sub.Err(): 1948 return err 1949 case <-quit: 1950 return nil 1951 } 1952 case err := <-sub.Err(): 1953 return err 1954 case <-quit: 1955 return nil 1956 } 1957 } 1958 }), nil 1959 } 1960 1961 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 1962 // 1963 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 1964 func (_IBEP20 *IBEP20Filterer) ParseApproval(log types.Log) (*IBEP20Approval, error) { 1965 event := new(IBEP20Approval) 1966 if err := _IBEP20.contract.UnpackLog(event, "Approval", log); err != nil { 1967 return nil, err 1968 } 1969 event.Raw = log 1970 return event, nil 1971 } 1972 1973 // IBEP20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IBEP20 contract. 1974 type IBEP20TransferIterator struct { 1975 Event *IBEP20Transfer // Event containing the contract specifics and raw log 1976 1977 contract *bind.BoundContract // Generic contract to use for unpacking event data 1978 event string // Event name to use for unpacking event data 1979 1980 logs chan types.Log // Log channel receiving the found contract events 1981 sub ethereum.Subscription // Subscription for errors, completion and termination 1982 done bool // Whether the subscription completed delivering logs 1983 fail error // Occurred error to stop iteration 1984 } 1985 1986 // Next advances the iterator to the subsequent event, returning whether there 1987 // are any more events found. In case of a retrieval or parsing error, false is 1988 // returned and Error() can be queried for the exact failure. 1989 func (it *IBEP20TransferIterator) Next() bool { 1990 // If the iterator failed, stop iterating 1991 if it.fail != nil { 1992 return false 1993 } 1994 // If the iterator completed, deliver directly whatever's available 1995 if it.done { 1996 select { 1997 case log := <-it.logs: 1998 it.Event = new(IBEP20Transfer) 1999 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2000 it.fail = err 2001 return false 2002 } 2003 it.Event.Raw = log 2004 return true 2005 2006 default: 2007 return false 2008 } 2009 } 2010 // Iterator still in progress, wait for either a data or an error event 2011 select { 2012 case log := <-it.logs: 2013 it.Event = new(IBEP20Transfer) 2014 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2015 it.fail = err 2016 return false 2017 } 2018 it.Event.Raw = log 2019 return true 2020 2021 case err := <-it.sub.Err(): 2022 it.done = true 2023 it.fail = err 2024 return it.Next() 2025 } 2026 } 2027 2028 // Error returns any retrieval or parsing error occurred during filtering. 2029 func (it *IBEP20TransferIterator) Error() error { 2030 return it.fail 2031 } 2032 2033 // Close terminates the iteration process, releasing any pending underlying 2034 // resources. 2035 func (it *IBEP20TransferIterator) Close() error { 2036 it.sub.Unsubscribe() 2037 return nil 2038 } 2039 2040 // IBEP20Transfer represents a Transfer event raised by the IBEP20 contract. 2041 type IBEP20Transfer struct { 2042 From common.Address 2043 To common.Address 2044 Value *big.Int 2045 Raw types.Log // Blockchain specific contextual infos 2046 } 2047 2048 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2049 // 2050 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2051 func (_IBEP20 *IBEP20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IBEP20TransferIterator, error) { 2052 2053 var fromRule []interface{} 2054 for _, fromItem := range from { 2055 fromRule = append(fromRule, fromItem) 2056 } 2057 var toRule []interface{} 2058 for _, toItem := range to { 2059 toRule = append(toRule, toItem) 2060 } 2061 2062 logs, sub, err := _IBEP20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 2063 if err != nil { 2064 return nil, err 2065 } 2066 return &IBEP20TransferIterator{contract: _IBEP20.contract, event: "Transfer", logs: logs, sub: sub}, nil 2067 } 2068 2069 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2070 // 2071 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2072 func (_IBEP20 *IBEP20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IBEP20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { 2073 2074 var fromRule []interface{} 2075 for _, fromItem := range from { 2076 fromRule = append(fromRule, fromItem) 2077 } 2078 var toRule []interface{} 2079 for _, toItem := range to { 2080 toRule = append(toRule, toItem) 2081 } 2082 2083 logs, sub, err := _IBEP20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 2084 if err != nil { 2085 return nil, err 2086 } 2087 return event.NewSubscription(func(quit <-chan struct{}) error { 2088 defer sub.Unsubscribe() 2089 for { 2090 select { 2091 case log := <-logs: 2092 // New log arrived, parse the event and forward to the user 2093 event := new(IBEP20Transfer) 2094 if err := _IBEP20.contract.UnpackLog(event, "Transfer", log); err != nil { 2095 return err 2096 } 2097 event.Raw = log 2098 2099 select { 2100 case sink <- event: 2101 case err := <-sub.Err(): 2102 return err 2103 case <-quit: 2104 return nil 2105 } 2106 case err := <-sub.Err(): 2107 return err 2108 case <-quit: 2109 return nil 2110 } 2111 } 2112 }), nil 2113 } 2114 2115 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2116 // 2117 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2118 func (_IBEP20 *IBEP20Filterer) ParseTransfer(log types.Log) (*IBEP20Transfer, error) { 2119 event := new(IBEP20Transfer) 2120 if err := _IBEP20.contract.UnpackLog(event, "Transfer", log); err != nil { 2121 return nil, err 2122 } 2123 event.Raw = log 2124 return event, nil 2125 } 2126 2127 // OwnableMetaData contains all meta data concerning the Ownable contract. 2128 var OwnableMetaData = &bind.MetaData{ 2129 ABI: "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", 2130 Sigs: map[string]string{ 2131 "8da5cb5b": "owner()", 2132 "715018a6": "renounceOwnership()", 2133 "f2fde38b": "transferOwnership(address)", 2134 }, 2135 } 2136 2137 // OwnableABI is the input ABI used to generate the binding from. 2138 // Deprecated: Use OwnableMetaData.ABI instead. 2139 var OwnableABI = OwnableMetaData.ABI 2140 2141 // Deprecated: Use OwnableMetaData.Sigs instead. 2142 // OwnableFuncSigs maps the 4-byte function signature to its string representation. 2143 var OwnableFuncSigs = OwnableMetaData.Sigs 2144 2145 // Ownable is an auto generated Go binding around an Ethereum contract. 2146 type Ownable struct { 2147 OwnableCaller // Read-only binding to the contract 2148 OwnableTransactor // Write-only binding to the contract 2149 OwnableFilterer // Log filterer for contract events 2150 } 2151 2152 // OwnableCaller is an auto generated read-only Go binding around an Ethereum contract. 2153 type OwnableCaller struct { 2154 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2155 } 2156 2157 // OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract. 2158 type OwnableTransactor struct { 2159 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2160 } 2161 2162 // OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 2163 type OwnableFilterer struct { 2164 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2165 } 2166 2167 // OwnableSession is an auto generated Go binding around an Ethereum contract, 2168 // with pre-set call and transact options. 2169 type OwnableSession struct { 2170 Contract *Ownable // Generic contract binding to set the session for 2171 CallOpts bind.CallOpts // Call options to use throughout this session 2172 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2173 } 2174 2175 // OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, 2176 // with pre-set call options. 2177 type OwnableCallerSession struct { 2178 Contract *OwnableCaller // Generic contract caller binding to set the session for 2179 CallOpts bind.CallOpts // Call options to use throughout this session 2180 } 2181 2182 // OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 2183 // with pre-set transact options. 2184 type OwnableTransactorSession struct { 2185 Contract *OwnableTransactor // Generic contract transactor binding to set the session for 2186 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2187 } 2188 2189 // OwnableRaw is an auto generated low-level Go binding around an Ethereum contract. 2190 type OwnableRaw struct { 2191 Contract *Ownable // Generic contract binding to access the raw methods on 2192 } 2193 2194 // OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 2195 type OwnableCallerRaw struct { 2196 Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on 2197 } 2198 2199 // OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 2200 type OwnableTransactorRaw struct { 2201 Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on 2202 } 2203 2204 // NewOwnable creates a new instance of Ownable, bound to a specific deployed contract. 2205 func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) { 2206 contract, err := bindOwnable(address, backend, backend, backend) 2207 if err != nil { 2208 return nil, err 2209 } 2210 return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil 2211 } 2212 2213 // NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract. 2214 func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) { 2215 contract, err := bindOwnable(address, caller, nil, nil) 2216 if err != nil { 2217 return nil, err 2218 } 2219 return &OwnableCaller{contract: contract}, nil 2220 } 2221 2222 // NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract. 2223 func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) { 2224 contract, err := bindOwnable(address, nil, transactor, nil) 2225 if err != nil { 2226 return nil, err 2227 } 2228 return &OwnableTransactor{contract: contract}, nil 2229 } 2230 2231 // NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract. 2232 func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) { 2233 contract, err := bindOwnable(address, nil, nil, filterer) 2234 if err != nil { 2235 return nil, err 2236 } 2237 return &OwnableFilterer{contract: contract}, nil 2238 } 2239 2240 // bindOwnable binds a generic wrapper to an already deployed contract. 2241 func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 2242 parsed, err := abi.JSON(strings.NewReader(OwnableABI)) 2243 if err != nil { 2244 return nil, err 2245 } 2246 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 2247 } 2248 2249 // Call invokes the (constant) contract method with params as input values and 2250 // sets the output to result. The result type might be a single field for simple 2251 // returns, a slice of interfaces for anonymous returns and a struct for named 2252 // returns. 2253 func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 2254 return _Ownable.Contract.OwnableCaller.contract.Call(opts, result, method, params...) 2255 } 2256 2257 // Transfer initiates a plain transaction to move funds to the contract, calling 2258 // its default method if one is available. 2259 func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2260 return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts) 2261 } 2262 2263 // Transact invokes the (paid) contract method with params as input values. 2264 func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2265 return _Ownable.Contract.OwnableTransactor.contract.Transact(opts, method, params...) 2266 } 2267 2268 // Call invokes the (constant) contract method with params as input values and 2269 // sets the output to result. The result type might be a single field for simple 2270 // returns, a slice of interfaces for anonymous returns and a struct for named 2271 // returns. 2272 func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 2273 return _Ownable.Contract.contract.Call(opts, result, method, params...) 2274 } 2275 2276 // Transfer initiates a plain transaction to move funds to the contract, calling 2277 // its default method if one is available. 2278 func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2279 return _Ownable.Contract.contract.Transfer(opts) 2280 } 2281 2282 // Transact invokes the (paid) contract method with params as input values. 2283 func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2284 return _Ownable.Contract.contract.Transact(opts, method, params...) 2285 } 2286 2287 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 2288 // 2289 // Solidity: function owner() view returns(address) 2290 func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 2291 var out []interface{} 2292 err := _Ownable.contract.Call(opts, &out, "owner") 2293 2294 if err != nil { 2295 return *new(common.Address), err 2296 } 2297 2298 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 2299 2300 return out0, err 2301 2302 } 2303 2304 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 2305 // 2306 // Solidity: function owner() view returns(address) 2307 func (_Ownable *OwnableSession) Owner() (common.Address, error) { 2308 return _Ownable.Contract.Owner(&_Ownable.CallOpts) 2309 } 2310 2311 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 2312 // 2313 // Solidity: function owner() view returns(address) 2314 func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) { 2315 return _Ownable.Contract.Owner(&_Ownable.CallOpts) 2316 } 2317 2318 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 2319 // 2320 // Solidity: function renounceOwnership() returns() 2321 func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 2322 return _Ownable.contract.Transact(opts, "renounceOwnership") 2323 } 2324 2325 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 2326 // 2327 // Solidity: function renounceOwnership() returns() 2328 func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) { 2329 return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) 2330 } 2331 2332 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 2333 // 2334 // Solidity: function renounceOwnership() returns() 2335 func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) { 2336 return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) 2337 } 2338 2339 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 2340 // 2341 // Solidity: function transferOwnership(address newOwner) returns() 2342 func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 2343 return _Ownable.contract.Transact(opts, "transferOwnership", newOwner) 2344 } 2345 2346 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 2347 // 2348 // Solidity: function transferOwnership(address newOwner) returns() 2349 func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 2350 return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) 2351 } 2352 2353 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 2354 // 2355 // Solidity: function transferOwnership(address newOwner) returns() 2356 func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 2357 return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) 2358 } 2359 2360 // OwnableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable contract. 2361 type OwnableOwnershipTransferredIterator struct { 2362 Event *OwnableOwnershipTransferred // Event containing the contract specifics and raw log 2363 2364 contract *bind.BoundContract // Generic contract to use for unpacking event data 2365 event string // Event name to use for unpacking event data 2366 2367 logs chan types.Log // Log channel receiving the found contract events 2368 sub ethereum.Subscription // Subscription for errors, completion and termination 2369 done bool // Whether the subscription completed delivering logs 2370 fail error // Occurred error to stop iteration 2371 } 2372 2373 // Next advances the iterator to the subsequent event, returning whether there 2374 // are any more events found. In case of a retrieval or parsing error, false is 2375 // returned and Error() can be queried for the exact failure. 2376 func (it *OwnableOwnershipTransferredIterator) Next() bool { 2377 // If the iterator failed, stop iterating 2378 if it.fail != nil { 2379 return false 2380 } 2381 // If the iterator completed, deliver directly whatever's available 2382 if it.done { 2383 select { 2384 case log := <-it.logs: 2385 it.Event = new(OwnableOwnershipTransferred) 2386 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2387 it.fail = err 2388 return false 2389 } 2390 it.Event.Raw = log 2391 return true 2392 2393 default: 2394 return false 2395 } 2396 } 2397 // Iterator still in progress, wait for either a data or an error event 2398 select { 2399 case log := <-it.logs: 2400 it.Event = new(OwnableOwnershipTransferred) 2401 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2402 it.fail = err 2403 return false 2404 } 2405 it.Event.Raw = log 2406 return true 2407 2408 case err := <-it.sub.Err(): 2409 it.done = true 2410 it.fail = err 2411 return it.Next() 2412 } 2413 } 2414 2415 // Error returns any retrieval or parsing error occurred during filtering. 2416 func (it *OwnableOwnershipTransferredIterator) Error() error { 2417 return it.fail 2418 } 2419 2420 // Close terminates the iteration process, releasing any pending underlying 2421 // resources. 2422 func (it *OwnableOwnershipTransferredIterator) Close() error { 2423 it.sub.Unsubscribe() 2424 return nil 2425 } 2426 2427 // OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract. 2428 type OwnableOwnershipTransferred struct { 2429 PreviousOwner common.Address 2430 NewOwner common.Address 2431 Raw types.Log // Blockchain specific contextual infos 2432 } 2433 2434 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 2435 // 2436 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 2437 func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error) { 2438 2439 var previousOwnerRule []interface{} 2440 for _, previousOwnerItem := range previousOwner { 2441 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 2442 } 2443 var newOwnerRule []interface{} 2444 for _, newOwnerItem := range newOwner { 2445 newOwnerRule = append(newOwnerRule, newOwnerItem) 2446 } 2447 2448 logs, sub, err := _Ownable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 2449 if err != nil { 2450 return nil, err 2451 } 2452 return &OwnableOwnershipTransferredIterator{contract: _Ownable.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 2453 } 2454 2455 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 2456 // 2457 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 2458 func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 2459 2460 var previousOwnerRule []interface{} 2461 for _, previousOwnerItem := range previousOwner { 2462 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 2463 } 2464 var newOwnerRule []interface{} 2465 for _, newOwnerItem := range newOwner { 2466 newOwnerRule = append(newOwnerRule, newOwnerItem) 2467 } 2468 2469 logs, sub, err := _Ownable.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 2470 if err != nil { 2471 return nil, err 2472 } 2473 return event.NewSubscription(func(quit <-chan struct{}) error { 2474 defer sub.Unsubscribe() 2475 for { 2476 select { 2477 case log := <-logs: 2478 // New log arrived, parse the event and forward to the user 2479 event := new(OwnableOwnershipTransferred) 2480 if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 2481 return err 2482 } 2483 event.Raw = log 2484 2485 select { 2486 case sink <- event: 2487 case err := <-sub.Err(): 2488 return err 2489 case <-quit: 2490 return nil 2491 } 2492 case err := <-sub.Err(): 2493 return err 2494 case <-quit: 2495 return nil 2496 } 2497 } 2498 }), nil 2499 } 2500 2501 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 2502 // 2503 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 2504 func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error) { 2505 event := new(OwnableOwnershipTransferred) 2506 if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 2507 return nil, err 2508 } 2509 event.Raw = log 2510 return event, nil 2511 } 2512 2513 // SafeMathMetaData contains all meta data concerning the SafeMath contract. 2514 var SafeMathMetaData = &bind.MetaData{ 2515 ABI: "[]", 2516 Bin: "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820169a4667cae94cd37f46f2ca9f8c074d25b320eec88ea3b0074e6557912067d964736f6c63430005100032", 2517 } 2518 2519 // SafeMathABI is the input ABI used to generate the binding from. 2520 // Deprecated: Use SafeMathMetaData.ABI instead. 2521 var SafeMathABI = SafeMathMetaData.ABI 2522 2523 // SafeMathBin is the compiled bytecode used for deploying new contracts. 2524 // Deprecated: Use SafeMathMetaData.Bin instead. 2525 var SafeMathBin = SafeMathMetaData.Bin 2526 2527 // DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it. 2528 func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) { 2529 parsed, err := SafeMathMetaData.GetAbi() 2530 if err != nil { 2531 return common.Address{}, nil, nil, err 2532 } 2533 if parsed == nil { 2534 return common.Address{}, nil, nil, errors.New("GetABI returned nil") 2535 } 2536 2537 address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(SafeMathBin), backend) 2538 if err != nil { 2539 return common.Address{}, nil, nil, err 2540 } 2541 return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 2542 } 2543 2544 // SafeMath is an auto generated Go binding around an Ethereum contract. 2545 type SafeMath struct { 2546 SafeMathCaller // Read-only binding to the contract 2547 SafeMathTransactor // Write-only binding to the contract 2548 SafeMathFilterer // Log filterer for contract events 2549 } 2550 2551 // SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract. 2552 type SafeMathCaller struct { 2553 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2554 } 2555 2556 // SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract. 2557 type SafeMathTransactor struct { 2558 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2559 } 2560 2561 // SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 2562 type SafeMathFilterer struct { 2563 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2564 } 2565 2566 // SafeMathSession is an auto generated Go binding around an Ethereum contract, 2567 // with pre-set call and transact options. 2568 type SafeMathSession struct { 2569 Contract *SafeMath // Generic contract binding to set the session for 2570 CallOpts bind.CallOpts // Call options to use throughout this session 2571 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2572 } 2573 2574 // SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, 2575 // with pre-set call options. 2576 type SafeMathCallerSession struct { 2577 Contract *SafeMathCaller // Generic contract caller binding to set the session for 2578 CallOpts bind.CallOpts // Call options to use throughout this session 2579 } 2580 2581 // SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 2582 // with pre-set transact options. 2583 type SafeMathTransactorSession struct { 2584 Contract *SafeMathTransactor // Generic contract transactor binding to set the session for 2585 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2586 } 2587 2588 // SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract. 2589 type SafeMathRaw struct { 2590 Contract *SafeMath // Generic contract binding to access the raw methods on 2591 } 2592 2593 // SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 2594 type SafeMathCallerRaw struct { 2595 Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on 2596 } 2597 2598 // SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 2599 type SafeMathTransactorRaw struct { 2600 Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on 2601 } 2602 2603 // NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract. 2604 func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) { 2605 contract, err := bindSafeMath(address, backend, backend, backend) 2606 if err != nil { 2607 return nil, err 2608 } 2609 return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 2610 } 2611 2612 // NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract. 2613 func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) { 2614 contract, err := bindSafeMath(address, caller, nil, nil) 2615 if err != nil { 2616 return nil, err 2617 } 2618 return &SafeMathCaller{contract: contract}, nil 2619 } 2620 2621 // NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract. 2622 func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) { 2623 contract, err := bindSafeMath(address, nil, transactor, nil) 2624 if err != nil { 2625 return nil, err 2626 } 2627 return &SafeMathTransactor{contract: contract}, nil 2628 } 2629 2630 // NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract. 2631 func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) { 2632 contract, err := bindSafeMath(address, nil, nil, filterer) 2633 if err != nil { 2634 return nil, err 2635 } 2636 return &SafeMathFilterer{contract: contract}, nil 2637 } 2638 2639 // bindSafeMath binds a generic wrapper to an already deployed contract. 2640 func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 2641 parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) 2642 if err != nil { 2643 return nil, err 2644 } 2645 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 2646 } 2647 2648 // Call invokes the (constant) contract method with params as input values and 2649 // sets the output to result. The result type might be a single field for simple 2650 // returns, a slice of interfaces for anonymous returns and a struct for named 2651 // returns. 2652 func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 2653 return _SafeMath.Contract.SafeMathCaller.contract.Call(opts, result, method, params...) 2654 } 2655 2656 // Transfer initiates a plain transaction to move funds to the contract, calling 2657 // its default method if one is available. 2658 func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2659 return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts) 2660 } 2661 2662 // Transact invokes the (paid) contract method with params as input values. 2663 func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2664 return _SafeMath.Contract.SafeMathTransactor.contract.Transact(opts, method, params...) 2665 } 2666 2667 // Call invokes the (constant) contract method with params as input values and 2668 // sets the output to result. The result type might be a single field for simple 2669 // returns, a slice of interfaces for anonymous returns and a struct for named 2670 // returns. 2671 func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 2672 return _SafeMath.Contract.contract.Call(opts, result, method, params...) 2673 } 2674 2675 // Transfer initiates a plain transaction to move funds to the contract, calling 2676 // its default method if one is available. 2677 func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2678 return _SafeMath.Contract.contract.Transfer(opts) 2679 } 2680 2681 // Transact invokes the (paid) contract method with params as input values. 2682 func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2683 return _SafeMath.Contract.contract.Transact(opts, method, params...) 2684 }