github.com/smartcontractkit/chainlink-testing-framework/libs@v0.0.0-20240227141906-ec710b4eb1a3/contracts/ethereum/OptimismGas.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 ethereum 5 6 import ( 7 "errors" 8 "math/big" 9 "strings" 10 11 ethereum "github.com/ethereum/go-ethereum" 12 "github.com/ethereum/go-ethereum/accounts/abi" 13 "github.com/ethereum/go-ethereum/accounts/abi/bind" 14 "github.com/ethereum/go-ethereum/common" 15 "github.com/ethereum/go-ethereum/core/types" 16 "github.com/ethereum/go-ethereum/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 // OptimismGasMetaData contains all meta data concerning the OptimismGas contract. 32 var OptimismGasMetaData = &bind.MetaData{ 33 ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"DecimalsUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"GasPriceUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"L1BaseFeeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"OverheadUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"ScalarUpdated\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gasPrice\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"getL1Fee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"getL1GasUsed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1BaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"overhead\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"scalar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_decimals\",\"type\":\"uint256\"}],\"name\":\"setDecimals\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_gasPrice\",\"type\":\"uint256\"}],\"name\":\"setGasPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_baseFee\",\"type\":\"uint256\"}],\"name\":\"setL1BaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_overhead\",\"type\":\"uint256\"}],\"name\":\"setOverhead\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_scalar\",\"type\":\"uint256\"}],\"name\":\"setScalar\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", 34 } 35 36 // OptimismGasABI is the input ABI used to generate the binding from. 37 // Deprecated: Use OptimismGasMetaData.ABI instead. 38 var OptimismGasABI = OptimismGasMetaData.ABI 39 40 // OptimismGas is an auto generated Go binding around an Ethereum contract. 41 type OptimismGas struct { 42 OptimismGasCaller // Read-only binding to the contract 43 OptimismGasTransactor // Write-only binding to the contract 44 OptimismGasFilterer // Log filterer for contract events 45 } 46 47 // OptimismGasCaller is an auto generated read-only Go binding around an Ethereum contract. 48 type OptimismGasCaller struct { 49 contract *bind.BoundContract // Generic contract wrapper for the low level calls 50 } 51 52 // OptimismGasTransactor is an auto generated write-only Go binding around an Ethereum contract. 53 type OptimismGasTransactor struct { 54 contract *bind.BoundContract // Generic contract wrapper for the low level calls 55 } 56 57 // OptimismGasFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 58 type OptimismGasFilterer struct { 59 contract *bind.BoundContract // Generic contract wrapper for the low level calls 60 } 61 62 // OptimismGasSession is an auto generated Go binding around an Ethereum contract, 63 // with pre-set call and transact options. 64 type OptimismGasSession struct { 65 Contract *OptimismGas // Generic contract binding to set the session for 66 CallOpts bind.CallOpts // Call options to use throughout this session 67 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 68 } 69 70 // OptimismGasCallerSession is an auto generated read-only Go binding around an Ethereum contract, 71 // with pre-set call options. 72 type OptimismGasCallerSession struct { 73 Contract *OptimismGasCaller // Generic contract caller binding to set the session for 74 CallOpts bind.CallOpts // Call options to use throughout this session 75 } 76 77 // OptimismGasTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 78 // with pre-set transact options. 79 type OptimismGasTransactorSession struct { 80 Contract *OptimismGasTransactor // Generic contract transactor binding to set the session for 81 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 82 } 83 84 // OptimismGasRaw is an auto generated low-level Go binding around an Ethereum contract. 85 type OptimismGasRaw struct { 86 Contract *OptimismGas // Generic contract binding to access the raw methods on 87 } 88 89 // OptimismGasCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 90 type OptimismGasCallerRaw struct { 91 Contract *OptimismGasCaller // Generic read-only contract binding to access the raw methods on 92 } 93 94 // OptimismGasTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 95 type OptimismGasTransactorRaw struct { 96 Contract *OptimismGasTransactor // Generic write-only contract binding to access the raw methods on 97 } 98 99 // NewOptimismGas creates a new instance of OptimismGas, bound to a specific deployed contract. 100 func NewOptimismGas(address common.Address, backend bind.ContractBackend) (*OptimismGas, error) { 101 contract, err := bindOptimismGas(address, backend, backend, backend) 102 if err != nil { 103 return nil, err 104 } 105 return &OptimismGas{OptimismGasCaller: OptimismGasCaller{contract: contract}, OptimismGasTransactor: OptimismGasTransactor{contract: contract}, OptimismGasFilterer: OptimismGasFilterer{contract: contract}}, nil 106 } 107 108 // NewOptimismGasCaller creates a new read-only instance of OptimismGas, bound to a specific deployed contract. 109 func NewOptimismGasCaller(address common.Address, caller bind.ContractCaller) (*OptimismGasCaller, error) { 110 contract, err := bindOptimismGas(address, caller, nil, nil) 111 if err != nil { 112 return nil, err 113 } 114 return &OptimismGasCaller{contract: contract}, nil 115 } 116 117 // NewOptimismGasTransactor creates a new write-only instance of OptimismGas, bound to a specific deployed contract. 118 func NewOptimismGasTransactor(address common.Address, transactor bind.ContractTransactor) (*OptimismGasTransactor, error) { 119 contract, err := bindOptimismGas(address, nil, transactor, nil) 120 if err != nil { 121 return nil, err 122 } 123 return &OptimismGasTransactor{contract: contract}, nil 124 } 125 126 // NewOptimismGasFilterer creates a new log filterer instance of OptimismGas, bound to a specific deployed contract. 127 func NewOptimismGasFilterer(address common.Address, filterer bind.ContractFilterer) (*OptimismGasFilterer, error) { 128 contract, err := bindOptimismGas(address, nil, nil, filterer) 129 if err != nil { 130 return nil, err 131 } 132 return &OptimismGasFilterer{contract: contract}, nil 133 } 134 135 // bindOptimismGas binds a generic wrapper to an already deployed contract. 136 func bindOptimismGas(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 137 parsed, err := abi.JSON(strings.NewReader(OptimismGasABI)) 138 if err != nil { 139 return nil, err 140 } 141 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 142 } 143 144 // Call invokes the (constant) contract method with params as input values and 145 // sets the output to result. The result type might be a single field for simple 146 // returns, a slice of interfaces for anonymous returns and a struct for named 147 // returns. 148 func (_OptimismGas *OptimismGasRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 149 return _OptimismGas.Contract.OptimismGasCaller.contract.Call(opts, result, method, params...) 150 } 151 152 // Transfer initiates a plain transaction to move funds to the contract, calling 153 // its default method if one is available. 154 func (_OptimismGas *OptimismGasRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 155 return _OptimismGas.Contract.OptimismGasTransactor.contract.Transfer(opts) 156 } 157 158 // Transact invokes the (paid) contract method with params as input values. 159 func (_OptimismGas *OptimismGasRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 160 return _OptimismGas.Contract.OptimismGasTransactor.contract.Transact(opts, method, params...) 161 } 162 163 // Call invokes the (constant) contract method with params as input values and 164 // sets the output to result. The result type might be a single field for simple 165 // returns, a slice of interfaces for anonymous returns and a struct for named 166 // returns. 167 func (_OptimismGas *OptimismGasCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 168 return _OptimismGas.Contract.contract.Call(opts, result, method, params...) 169 } 170 171 // Transfer initiates a plain transaction to move funds to the contract, calling 172 // its default method if one is available. 173 func (_OptimismGas *OptimismGasTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 174 return _OptimismGas.Contract.contract.Transfer(opts) 175 } 176 177 // Transact invokes the (paid) contract method with params as input values. 178 func (_OptimismGas *OptimismGasTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 179 return _OptimismGas.Contract.contract.Transact(opts, method, params...) 180 } 181 182 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 183 // 184 // Solidity: function decimals() view returns(uint256) 185 func (_OptimismGas *OptimismGasCaller) Decimals(opts *bind.CallOpts) (*big.Int, error) { 186 var out []interface{} 187 err := _OptimismGas.contract.Call(opts, &out, "decimals") 188 189 if err != nil { 190 return *new(*big.Int), err 191 } 192 193 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 194 195 return out0, err 196 197 } 198 199 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 200 // 201 // Solidity: function decimals() view returns(uint256) 202 func (_OptimismGas *OptimismGasSession) Decimals() (*big.Int, error) { 203 return _OptimismGas.Contract.Decimals(&_OptimismGas.CallOpts) 204 } 205 206 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 207 // 208 // Solidity: function decimals() view returns(uint256) 209 func (_OptimismGas *OptimismGasCallerSession) Decimals() (*big.Int, error) { 210 return _OptimismGas.Contract.Decimals(&_OptimismGas.CallOpts) 211 } 212 213 // GasPrice is a free data retrieval call binding the contract method 0xfe173b97. 214 // 215 // Solidity: function gasPrice() view returns(uint256) 216 func (_OptimismGas *OptimismGasCaller) GasPrice(opts *bind.CallOpts) (*big.Int, error) { 217 var out []interface{} 218 err := _OptimismGas.contract.Call(opts, &out, "gasPrice") 219 220 if err != nil { 221 return *new(*big.Int), err 222 } 223 224 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 225 226 return out0, err 227 228 } 229 230 // GasPrice is a free data retrieval call binding the contract method 0xfe173b97. 231 // 232 // Solidity: function gasPrice() view returns(uint256) 233 func (_OptimismGas *OptimismGasSession) GasPrice() (*big.Int, error) { 234 return _OptimismGas.Contract.GasPrice(&_OptimismGas.CallOpts) 235 } 236 237 // GasPrice is a free data retrieval call binding the contract method 0xfe173b97. 238 // 239 // Solidity: function gasPrice() view returns(uint256) 240 func (_OptimismGas *OptimismGasCallerSession) GasPrice() (*big.Int, error) { 241 return _OptimismGas.Contract.GasPrice(&_OptimismGas.CallOpts) 242 } 243 244 // GetL1Fee is a free data retrieval call binding the contract method 0x49948e0e. 245 // 246 // Solidity: function getL1Fee(bytes _data) view returns(uint256) 247 func (_OptimismGas *OptimismGasCaller) GetL1Fee(opts *bind.CallOpts, _data []byte) (*big.Int, error) { 248 var out []interface{} 249 err := _OptimismGas.contract.Call(opts, &out, "getL1Fee", _data) 250 251 if err != nil { 252 return *new(*big.Int), err 253 } 254 255 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 256 257 return out0, err 258 259 } 260 261 // GetL1Fee is a free data retrieval call binding the contract method 0x49948e0e. 262 // 263 // Solidity: function getL1Fee(bytes _data) view returns(uint256) 264 func (_OptimismGas *OptimismGasSession) GetL1Fee(_data []byte) (*big.Int, error) { 265 return _OptimismGas.Contract.GetL1Fee(&_OptimismGas.CallOpts, _data) 266 } 267 268 // GetL1Fee is a free data retrieval call binding the contract method 0x49948e0e. 269 // 270 // Solidity: function getL1Fee(bytes _data) view returns(uint256) 271 func (_OptimismGas *OptimismGasCallerSession) GetL1Fee(_data []byte) (*big.Int, error) { 272 return _OptimismGas.Contract.GetL1Fee(&_OptimismGas.CallOpts, _data) 273 } 274 275 // GetL1GasUsed is a free data retrieval call binding the contract method 0xde26c4a1. 276 // 277 // Solidity: function getL1GasUsed(bytes _data) view returns(uint256) 278 func (_OptimismGas *OptimismGasCaller) GetL1GasUsed(opts *bind.CallOpts, _data []byte) (*big.Int, error) { 279 var out []interface{} 280 err := _OptimismGas.contract.Call(opts, &out, "getL1GasUsed", _data) 281 282 if err != nil { 283 return *new(*big.Int), err 284 } 285 286 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 287 288 return out0, err 289 290 } 291 292 // GetL1GasUsed is a free data retrieval call binding the contract method 0xde26c4a1. 293 // 294 // Solidity: function getL1GasUsed(bytes _data) view returns(uint256) 295 func (_OptimismGas *OptimismGasSession) GetL1GasUsed(_data []byte) (*big.Int, error) { 296 return _OptimismGas.Contract.GetL1GasUsed(&_OptimismGas.CallOpts, _data) 297 } 298 299 // GetL1GasUsed is a free data retrieval call binding the contract method 0xde26c4a1. 300 // 301 // Solidity: function getL1GasUsed(bytes _data) view returns(uint256) 302 func (_OptimismGas *OptimismGasCallerSession) GetL1GasUsed(_data []byte) (*big.Int, error) { 303 return _OptimismGas.Contract.GetL1GasUsed(&_OptimismGas.CallOpts, _data) 304 } 305 306 // L1BaseFee is a free data retrieval call binding the contract method 0x519b4bd3. 307 // 308 // Solidity: function l1BaseFee() view returns(uint256) 309 func (_OptimismGas *OptimismGasCaller) L1BaseFee(opts *bind.CallOpts) (*big.Int, error) { 310 var out []interface{} 311 err := _OptimismGas.contract.Call(opts, &out, "l1BaseFee") 312 313 if err != nil { 314 return *new(*big.Int), err 315 } 316 317 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 318 319 return out0, err 320 321 } 322 323 // L1BaseFee is a free data retrieval call binding the contract method 0x519b4bd3. 324 // 325 // Solidity: function l1BaseFee() view returns(uint256) 326 func (_OptimismGas *OptimismGasSession) L1BaseFee() (*big.Int, error) { 327 return _OptimismGas.Contract.L1BaseFee(&_OptimismGas.CallOpts) 328 } 329 330 // L1BaseFee is a free data retrieval call binding the contract method 0x519b4bd3. 331 // 332 // Solidity: function l1BaseFee() view returns(uint256) 333 func (_OptimismGas *OptimismGasCallerSession) L1BaseFee() (*big.Int, error) { 334 return _OptimismGas.Contract.L1BaseFee(&_OptimismGas.CallOpts) 335 } 336 337 // Overhead is a free data retrieval call binding the contract method 0x0c18c162. 338 // 339 // Solidity: function overhead() view returns(uint256) 340 func (_OptimismGas *OptimismGasCaller) Overhead(opts *bind.CallOpts) (*big.Int, error) { 341 var out []interface{} 342 err := _OptimismGas.contract.Call(opts, &out, "overhead") 343 344 if err != nil { 345 return *new(*big.Int), err 346 } 347 348 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 349 350 return out0, err 351 352 } 353 354 // Overhead is a free data retrieval call binding the contract method 0x0c18c162. 355 // 356 // Solidity: function overhead() view returns(uint256) 357 func (_OptimismGas *OptimismGasSession) Overhead() (*big.Int, error) { 358 return _OptimismGas.Contract.Overhead(&_OptimismGas.CallOpts) 359 } 360 361 // Overhead is a free data retrieval call binding the contract method 0x0c18c162. 362 // 363 // Solidity: function overhead() view returns(uint256) 364 func (_OptimismGas *OptimismGasCallerSession) Overhead() (*big.Int, error) { 365 return _OptimismGas.Contract.Overhead(&_OptimismGas.CallOpts) 366 } 367 368 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 369 // 370 // Solidity: function owner() view returns(address) 371 func (_OptimismGas *OptimismGasCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 372 var out []interface{} 373 err := _OptimismGas.contract.Call(opts, &out, "owner") 374 375 if err != nil { 376 return *new(common.Address), err 377 } 378 379 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 380 381 return out0, err 382 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 (_OptimismGas *OptimismGasSession) Owner() (common.Address, error) { 389 return _OptimismGas.Contract.Owner(&_OptimismGas.CallOpts) 390 } 391 392 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 393 // 394 // Solidity: function owner() view returns(address) 395 func (_OptimismGas *OptimismGasCallerSession) Owner() (common.Address, error) { 396 return _OptimismGas.Contract.Owner(&_OptimismGas.CallOpts) 397 } 398 399 // Scalar is a free data retrieval call binding the contract method 0xf45e65d8. 400 // 401 // Solidity: function scalar() view returns(uint256) 402 func (_OptimismGas *OptimismGasCaller) Scalar(opts *bind.CallOpts) (*big.Int, error) { 403 var out []interface{} 404 err := _OptimismGas.contract.Call(opts, &out, "scalar") 405 406 if err != nil { 407 return *new(*big.Int), err 408 } 409 410 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 411 412 return out0, err 413 414 } 415 416 // Scalar is a free data retrieval call binding the contract method 0xf45e65d8. 417 // 418 // Solidity: function scalar() view returns(uint256) 419 func (_OptimismGas *OptimismGasSession) Scalar() (*big.Int, error) { 420 return _OptimismGas.Contract.Scalar(&_OptimismGas.CallOpts) 421 } 422 423 // Scalar is a free data retrieval call binding the contract method 0xf45e65d8. 424 // 425 // Solidity: function scalar() view returns(uint256) 426 func (_OptimismGas *OptimismGasCallerSession) Scalar() (*big.Int, error) { 427 return _OptimismGas.Contract.Scalar(&_OptimismGas.CallOpts) 428 } 429 430 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 431 // 432 // Solidity: function renounceOwnership() returns() 433 func (_OptimismGas *OptimismGasTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 434 return _OptimismGas.contract.Transact(opts, "renounceOwnership") 435 } 436 437 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 438 // 439 // Solidity: function renounceOwnership() returns() 440 func (_OptimismGas *OptimismGasSession) RenounceOwnership() (*types.Transaction, error) { 441 return _OptimismGas.Contract.RenounceOwnership(&_OptimismGas.TransactOpts) 442 } 443 444 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 445 // 446 // Solidity: function renounceOwnership() returns() 447 func (_OptimismGas *OptimismGasTransactorSession) RenounceOwnership() (*types.Transaction, error) { 448 return _OptimismGas.Contract.RenounceOwnership(&_OptimismGas.TransactOpts) 449 } 450 451 // SetDecimals is a paid mutator transaction binding the contract method 0x8c8885c8. 452 // 453 // Solidity: function setDecimals(uint256 _decimals) returns() 454 func (_OptimismGas *OptimismGasTransactor) SetDecimals(opts *bind.TransactOpts, _decimals *big.Int) (*types.Transaction, error) { 455 return _OptimismGas.contract.Transact(opts, "setDecimals", _decimals) 456 } 457 458 // SetDecimals is a paid mutator transaction binding the contract method 0x8c8885c8. 459 // 460 // Solidity: function setDecimals(uint256 _decimals) returns() 461 func (_OptimismGas *OptimismGasSession) SetDecimals(_decimals *big.Int) (*types.Transaction, error) { 462 return _OptimismGas.Contract.SetDecimals(&_OptimismGas.TransactOpts, _decimals) 463 } 464 465 // SetDecimals is a paid mutator transaction binding the contract method 0x8c8885c8. 466 // 467 // Solidity: function setDecimals(uint256 _decimals) returns() 468 func (_OptimismGas *OptimismGasTransactorSession) SetDecimals(_decimals *big.Int) (*types.Transaction, error) { 469 return _OptimismGas.Contract.SetDecimals(&_OptimismGas.TransactOpts, _decimals) 470 } 471 472 // SetGasPrice is a paid mutator transaction binding the contract method 0xbf1fe420. 473 // 474 // Solidity: function setGasPrice(uint256 _gasPrice) returns() 475 func (_OptimismGas *OptimismGasTransactor) SetGasPrice(opts *bind.TransactOpts, _gasPrice *big.Int) (*types.Transaction, error) { 476 return _OptimismGas.contract.Transact(opts, "setGasPrice", _gasPrice) 477 } 478 479 // SetGasPrice is a paid mutator transaction binding the contract method 0xbf1fe420. 480 // 481 // Solidity: function setGasPrice(uint256 _gasPrice) returns() 482 func (_OptimismGas *OptimismGasSession) SetGasPrice(_gasPrice *big.Int) (*types.Transaction, error) { 483 return _OptimismGas.Contract.SetGasPrice(&_OptimismGas.TransactOpts, _gasPrice) 484 } 485 486 // SetGasPrice is a paid mutator transaction binding the contract method 0xbf1fe420. 487 // 488 // Solidity: function setGasPrice(uint256 _gasPrice) returns() 489 func (_OptimismGas *OptimismGasTransactorSession) SetGasPrice(_gasPrice *big.Int) (*types.Transaction, error) { 490 return _OptimismGas.Contract.SetGasPrice(&_OptimismGas.TransactOpts, _gasPrice) 491 } 492 493 // SetL1BaseFee is a paid mutator transaction binding the contract method 0xbede39b5. 494 // 495 // Solidity: function setL1BaseFee(uint256 _baseFee) returns() 496 func (_OptimismGas *OptimismGasTransactor) SetL1BaseFee(opts *bind.TransactOpts, _baseFee *big.Int) (*types.Transaction, error) { 497 return _OptimismGas.contract.Transact(opts, "setL1BaseFee", _baseFee) 498 } 499 500 // SetL1BaseFee is a paid mutator transaction binding the contract method 0xbede39b5. 501 // 502 // Solidity: function setL1BaseFee(uint256 _baseFee) returns() 503 func (_OptimismGas *OptimismGasSession) SetL1BaseFee(_baseFee *big.Int) (*types.Transaction, error) { 504 return _OptimismGas.Contract.SetL1BaseFee(&_OptimismGas.TransactOpts, _baseFee) 505 } 506 507 // SetL1BaseFee is a paid mutator transaction binding the contract method 0xbede39b5. 508 // 509 // Solidity: function setL1BaseFee(uint256 _baseFee) returns() 510 func (_OptimismGas *OptimismGasTransactorSession) SetL1BaseFee(_baseFee *big.Int) (*types.Transaction, error) { 511 return _OptimismGas.Contract.SetL1BaseFee(&_OptimismGas.TransactOpts, _baseFee) 512 } 513 514 // SetOverhead is a paid mutator transaction binding the contract method 0x3577afc5. 515 // 516 // Solidity: function setOverhead(uint256 _overhead) returns() 517 func (_OptimismGas *OptimismGasTransactor) SetOverhead(opts *bind.TransactOpts, _overhead *big.Int) (*types.Transaction, error) { 518 return _OptimismGas.contract.Transact(opts, "setOverhead", _overhead) 519 } 520 521 // SetOverhead is a paid mutator transaction binding the contract method 0x3577afc5. 522 // 523 // Solidity: function setOverhead(uint256 _overhead) returns() 524 func (_OptimismGas *OptimismGasSession) SetOverhead(_overhead *big.Int) (*types.Transaction, error) { 525 return _OptimismGas.Contract.SetOverhead(&_OptimismGas.TransactOpts, _overhead) 526 } 527 528 // SetOverhead is a paid mutator transaction binding the contract method 0x3577afc5. 529 // 530 // Solidity: function setOverhead(uint256 _overhead) returns() 531 func (_OptimismGas *OptimismGasTransactorSession) SetOverhead(_overhead *big.Int) (*types.Transaction, error) { 532 return _OptimismGas.Contract.SetOverhead(&_OptimismGas.TransactOpts, _overhead) 533 } 534 535 // SetScalar is a paid mutator transaction binding the contract method 0x70465597. 536 // 537 // Solidity: function setScalar(uint256 _scalar) returns() 538 func (_OptimismGas *OptimismGasTransactor) SetScalar(opts *bind.TransactOpts, _scalar *big.Int) (*types.Transaction, error) { 539 return _OptimismGas.contract.Transact(opts, "setScalar", _scalar) 540 } 541 542 // SetScalar is a paid mutator transaction binding the contract method 0x70465597. 543 // 544 // Solidity: function setScalar(uint256 _scalar) returns() 545 func (_OptimismGas *OptimismGasSession) SetScalar(_scalar *big.Int) (*types.Transaction, error) { 546 return _OptimismGas.Contract.SetScalar(&_OptimismGas.TransactOpts, _scalar) 547 } 548 549 // SetScalar is a paid mutator transaction binding the contract method 0x70465597. 550 // 551 // Solidity: function setScalar(uint256 _scalar) returns() 552 func (_OptimismGas *OptimismGasTransactorSession) SetScalar(_scalar *big.Int) (*types.Transaction, error) { 553 return _OptimismGas.Contract.SetScalar(&_OptimismGas.TransactOpts, _scalar) 554 } 555 556 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 557 // 558 // Solidity: function transferOwnership(address newOwner) returns() 559 func (_OptimismGas *OptimismGasTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 560 return _OptimismGas.contract.Transact(opts, "transferOwnership", newOwner) 561 } 562 563 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 564 // 565 // Solidity: function transferOwnership(address newOwner) returns() 566 func (_OptimismGas *OptimismGasSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 567 return _OptimismGas.Contract.TransferOwnership(&_OptimismGas.TransactOpts, newOwner) 568 } 569 570 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 571 // 572 // Solidity: function transferOwnership(address newOwner) returns() 573 func (_OptimismGas *OptimismGasTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 574 return _OptimismGas.Contract.TransferOwnership(&_OptimismGas.TransactOpts, newOwner) 575 } 576 577 // OptimismGasDecimalsUpdatedIterator is returned from FilterDecimalsUpdated and is used to iterate over the raw logs and unpacked data for DecimalsUpdated events raised by the OptimismGas contract. 578 type OptimismGasDecimalsUpdatedIterator struct { 579 Event *OptimismGasDecimalsUpdated // Event containing the contract specifics and raw log 580 581 contract *bind.BoundContract // Generic contract to use for unpacking event data 582 event string // Event name to use for unpacking event data 583 584 logs chan types.Log // Log channel receiving the found contract events 585 sub ethereum.Subscription // Subscription for errors, completion and termination 586 done bool // Whether the subscription completed delivering logs 587 fail error // Occurred error to stop iteration 588 } 589 590 // Next advances the iterator to the subsequent event, returning whether there 591 // are any more events found. In case of a retrieval or parsing error, false is 592 // returned and Error() can be queried for the exact failure. 593 func (it *OptimismGasDecimalsUpdatedIterator) Next() bool { 594 // If the iterator failed, stop iterating 595 if it.fail != nil { 596 return false 597 } 598 // If the iterator completed, deliver directly whatever's available 599 if it.done { 600 select { 601 case log := <-it.logs: 602 it.Event = new(OptimismGasDecimalsUpdated) 603 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 604 it.fail = err 605 return false 606 } 607 it.Event.Raw = log 608 return true 609 610 default: 611 return false 612 } 613 } 614 // Iterator still in progress, wait for either a data or an error event 615 select { 616 case log := <-it.logs: 617 it.Event = new(OptimismGasDecimalsUpdated) 618 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 619 it.fail = err 620 return false 621 } 622 it.Event.Raw = log 623 return true 624 625 case err := <-it.sub.Err(): 626 it.done = true 627 it.fail = err 628 return it.Next() 629 } 630 } 631 632 // Error returns any retrieval or parsing error occurred during filtering. 633 func (it *OptimismGasDecimalsUpdatedIterator) Error() error { 634 return it.fail 635 } 636 637 // Close terminates the iteration process, releasing any pending underlying 638 // resources. 639 func (it *OptimismGasDecimalsUpdatedIterator) Close() error { 640 it.sub.Unsubscribe() 641 return nil 642 } 643 644 // OptimismGasDecimalsUpdated represents a DecimalsUpdated event raised by the OptimismGas contract. 645 type OptimismGasDecimalsUpdated struct { 646 Arg0 *big.Int 647 Raw types.Log // Blockchain specific contextual infos 648 } 649 650 // FilterDecimalsUpdated is a free log retrieval operation binding the contract event 0xd68112a8707e326d08be3656b528c1bcc5bbbfc47f4177e2179b14d8640838c1. 651 // 652 // Solidity: event DecimalsUpdated(uint256 arg0) 653 func (_OptimismGas *OptimismGasFilterer) FilterDecimalsUpdated(opts *bind.FilterOpts) (*OptimismGasDecimalsUpdatedIterator, error) { 654 655 logs, sub, err := _OptimismGas.contract.FilterLogs(opts, "DecimalsUpdated") 656 if err != nil { 657 return nil, err 658 } 659 return &OptimismGasDecimalsUpdatedIterator{contract: _OptimismGas.contract, event: "DecimalsUpdated", logs: logs, sub: sub}, nil 660 } 661 662 // WatchDecimalsUpdated is a free log subscription operation binding the contract event 0xd68112a8707e326d08be3656b528c1bcc5bbbfc47f4177e2179b14d8640838c1. 663 // 664 // Solidity: event DecimalsUpdated(uint256 arg0) 665 func (_OptimismGas *OptimismGasFilterer) WatchDecimalsUpdated(opts *bind.WatchOpts, sink chan<- *OptimismGasDecimalsUpdated) (event.Subscription, error) { 666 667 logs, sub, err := _OptimismGas.contract.WatchLogs(opts, "DecimalsUpdated") 668 if err != nil { 669 return nil, err 670 } 671 return event.NewSubscription(func(quit <-chan struct{}) error { 672 defer sub.Unsubscribe() 673 for { 674 select { 675 case log := <-logs: 676 // New log arrived, parse the event and forward to the user 677 event := new(OptimismGasDecimalsUpdated) 678 if err := _OptimismGas.contract.UnpackLog(event, "DecimalsUpdated", log); err != nil { 679 return err 680 } 681 event.Raw = log 682 683 select { 684 case sink <- event: 685 case err := <-sub.Err(): 686 return err 687 case <-quit: 688 return nil 689 } 690 case err := <-sub.Err(): 691 return err 692 case <-quit: 693 return nil 694 } 695 } 696 }), nil 697 } 698 699 // ParseDecimalsUpdated is a log parse operation binding the contract event 0xd68112a8707e326d08be3656b528c1bcc5bbbfc47f4177e2179b14d8640838c1. 700 // 701 // Solidity: event DecimalsUpdated(uint256 arg0) 702 func (_OptimismGas *OptimismGasFilterer) ParseDecimalsUpdated(log types.Log) (*OptimismGasDecimalsUpdated, error) { 703 event := new(OptimismGasDecimalsUpdated) 704 if err := _OptimismGas.contract.UnpackLog(event, "DecimalsUpdated", log); err != nil { 705 return nil, err 706 } 707 event.Raw = log 708 return event, nil 709 } 710 711 // OptimismGasGasPriceUpdatedIterator is returned from FilterGasPriceUpdated and is used to iterate over the raw logs and unpacked data for GasPriceUpdated events raised by the OptimismGas contract. 712 type OptimismGasGasPriceUpdatedIterator struct { 713 Event *OptimismGasGasPriceUpdated // Event containing the contract specifics and raw log 714 715 contract *bind.BoundContract // Generic contract to use for unpacking event data 716 event string // Event name to use for unpacking event data 717 718 logs chan types.Log // Log channel receiving the found contract events 719 sub ethereum.Subscription // Subscription for errors, completion and termination 720 done bool // Whether the subscription completed delivering logs 721 fail error // Occurred error to stop iteration 722 } 723 724 // Next advances the iterator to the subsequent event, returning whether there 725 // are any more events found. In case of a retrieval or parsing error, false is 726 // returned and Error() can be queried for the exact failure. 727 func (it *OptimismGasGasPriceUpdatedIterator) Next() bool { 728 // If the iterator failed, stop iterating 729 if it.fail != nil { 730 return false 731 } 732 // If the iterator completed, deliver directly whatever's available 733 if it.done { 734 select { 735 case log := <-it.logs: 736 it.Event = new(OptimismGasGasPriceUpdated) 737 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 738 it.fail = err 739 return false 740 } 741 it.Event.Raw = log 742 return true 743 744 default: 745 return false 746 } 747 } 748 // Iterator still in progress, wait for either a data or an error event 749 select { 750 case log := <-it.logs: 751 it.Event = new(OptimismGasGasPriceUpdated) 752 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 753 it.fail = err 754 return false 755 } 756 it.Event.Raw = log 757 return true 758 759 case err := <-it.sub.Err(): 760 it.done = true 761 it.fail = err 762 return it.Next() 763 } 764 } 765 766 // Error returns any retrieval or parsing error occurred during filtering. 767 func (it *OptimismGasGasPriceUpdatedIterator) Error() error { 768 return it.fail 769 } 770 771 // Close terminates the iteration process, releasing any pending underlying 772 // resources. 773 func (it *OptimismGasGasPriceUpdatedIterator) Close() error { 774 it.sub.Unsubscribe() 775 return nil 776 } 777 778 // OptimismGasGasPriceUpdated represents a GasPriceUpdated event raised by the OptimismGas contract. 779 type OptimismGasGasPriceUpdated struct { 780 Arg0 *big.Int 781 Raw types.Log // Blockchain specific contextual infos 782 } 783 784 // FilterGasPriceUpdated is a free log retrieval operation binding the contract event 0xfcdccc6074c6c42e4bd578aa9870c697dc976a270968452d2b8c8dc369fae396. 785 // 786 // Solidity: event GasPriceUpdated(uint256 arg0) 787 func (_OptimismGas *OptimismGasFilterer) FilterGasPriceUpdated(opts *bind.FilterOpts) (*OptimismGasGasPriceUpdatedIterator, error) { 788 789 logs, sub, err := _OptimismGas.contract.FilterLogs(opts, "GasPriceUpdated") 790 if err != nil { 791 return nil, err 792 } 793 return &OptimismGasGasPriceUpdatedIterator{contract: _OptimismGas.contract, event: "GasPriceUpdated", logs: logs, sub: sub}, nil 794 } 795 796 // WatchGasPriceUpdated is a free log subscription operation binding the contract event 0xfcdccc6074c6c42e4bd578aa9870c697dc976a270968452d2b8c8dc369fae396. 797 // 798 // Solidity: event GasPriceUpdated(uint256 arg0) 799 func (_OptimismGas *OptimismGasFilterer) WatchGasPriceUpdated(opts *bind.WatchOpts, sink chan<- *OptimismGasGasPriceUpdated) (event.Subscription, error) { 800 801 logs, sub, err := _OptimismGas.contract.WatchLogs(opts, "GasPriceUpdated") 802 if err != nil { 803 return nil, err 804 } 805 return event.NewSubscription(func(quit <-chan struct{}) error { 806 defer sub.Unsubscribe() 807 for { 808 select { 809 case log := <-logs: 810 // New log arrived, parse the event and forward to the user 811 event := new(OptimismGasGasPriceUpdated) 812 if err := _OptimismGas.contract.UnpackLog(event, "GasPriceUpdated", log); err != nil { 813 return err 814 } 815 event.Raw = log 816 817 select { 818 case sink <- event: 819 case err := <-sub.Err(): 820 return err 821 case <-quit: 822 return nil 823 } 824 case err := <-sub.Err(): 825 return err 826 case <-quit: 827 return nil 828 } 829 } 830 }), nil 831 } 832 833 // ParseGasPriceUpdated is a log parse operation binding the contract event 0xfcdccc6074c6c42e4bd578aa9870c697dc976a270968452d2b8c8dc369fae396. 834 // 835 // Solidity: event GasPriceUpdated(uint256 arg0) 836 func (_OptimismGas *OptimismGasFilterer) ParseGasPriceUpdated(log types.Log) (*OptimismGasGasPriceUpdated, error) { 837 event := new(OptimismGasGasPriceUpdated) 838 if err := _OptimismGas.contract.UnpackLog(event, "GasPriceUpdated", log); err != nil { 839 return nil, err 840 } 841 event.Raw = log 842 return event, nil 843 } 844 845 // OptimismGasL1BaseFeeUpdatedIterator is returned from FilterL1BaseFeeUpdated and is used to iterate over the raw logs and unpacked data for L1BaseFeeUpdated events raised by the OptimismGas contract. 846 type OptimismGasL1BaseFeeUpdatedIterator struct { 847 Event *OptimismGasL1BaseFeeUpdated // Event containing the contract specifics and raw log 848 849 contract *bind.BoundContract // Generic contract to use for unpacking event data 850 event string // Event name to use for unpacking event data 851 852 logs chan types.Log // Log channel receiving the found contract events 853 sub ethereum.Subscription // Subscription for errors, completion and termination 854 done bool // Whether the subscription completed delivering logs 855 fail error // Occurred error to stop iteration 856 } 857 858 // Next advances the iterator to the subsequent event, returning whether there 859 // are any more events found. In case of a retrieval or parsing error, false is 860 // returned and Error() can be queried for the exact failure. 861 func (it *OptimismGasL1BaseFeeUpdatedIterator) Next() bool { 862 // If the iterator failed, stop iterating 863 if it.fail != nil { 864 return false 865 } 866 // If the iterator completed, deliver directly whatever's available 867 if it.done { 868 select { 869 case log := <-it.logs: 870 it.Event = new(OptimismGasL1BaseFeeUpdated) 871 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 872 it.fail = err 873 return false 874 } 875 it.Event.Raw = log 876 return true 877 878 default: 879 return false 880 } 881 } 882 // Iterator still in progress, wait for either a data or an error event 883 select { 884 case log := <-it.logs: 885 it.Event = new(OptimismGasL1BaseFeeUpdated) 886 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 887 it.fail = err 888 return false 889 } 890 it.Event.Raw = log 891 return true 892 893 case err := <-it.sub.Err(): 894 it.done = true 895 it.fail = err 896 return it.Next() 897 } 898 } 899 900 // Error returns any retrieval or parsing error occurred during filtering. 901 func (it *OptimismGasL1BaseFeeUpdatedIterator) Error() error { 902 return it.fail 903 } 904 905 // Close terminates the iteration process, releasing any pending underlying 906 // resources. 907 func (it *OptimismGasL1BaseFeeUpdatedIterator) Close() error { 908 it.sub.Unsubscribe() 909 return nil 910 } 911 912 // OptimismGasL1BaseFeeUpdated represents a L1BaseFeeUpdated event raised by the OptimismGas contract. 913 type OptimismGasL1BaseFeeUpdated struct { 914 Arg0 *big.Int 915 Raw types.Log // Blockchain specific contextual infos 916 } 917 918 // FilterL1BaseFeeUpdated is a free log retrieval operation binding the contract event 0x351fb23757bb5ea0546c85b7996ddd7155f96b939ebaa5ff7bc49c75f27f2c44. 919 // 920 // Solidity: event L1BaseFeeUpdated(uint256 arg0) 921 func (_OptimismGas *OptimismGasFilterer) FilterL1BaseFeeUpdated(opts *bind.FilterOpts) (*OptimismGasL1BaseFeeUpdatedIterator, error) { 922 923 logs, sub, err := _OptimismGas.contract.FilterLogs(opts, "L1BaseFeeUpdated") 924 if err != nil { 925 return nil, err 926 } 927 return &OptimismGasL1BaseFeeUpdatedIterator{contract: _OptimismGas.contract, event: "L1BaseFeeUpdated", logs: logs, sub: sub}, nil 928 } 929 930 // WatchL1BaseFeeUpdated is a free log subscription operation binding the contract event 0x351fb23757bb5ea0546c85b7996ddd7155f96b939ebaa5ff7bc49c75f27f2c44. 931 // 932 // Solidity: event L1BaseFeeUpdated(uint256 arg0) 933 func (_OptimismGas *OptimismGasFilterer) WatchL1BaseFeeUpdated(opts *bind.WatchOpts, sink chan<- *OptimismGasL1BaseFeeUpdated) (event.Subscription, error) { 934 935 logs, sub, err := _OptimismGas.contract.WatchLogs(opts, "L1BaseFeeUpdated") 936 if err != nil { 937 return nil, err 938 } 939 return event.NewSubscription(func(quit <-chan struct{}) error { 940 defer sub.Unsubscribe() 941 for { 942 select { 943 case log := <-logs: 944 // New log arrived, parse the event and forward to the user 945 event := new(OptimismGasL1BaseFeeUpdated) 946 if err := _OptimismGas.contract.UnpackLog(event, "L1BaseFeeUpdated", log); err != nil { 947 return err 948 } 949 event.Raw = log 950 951 select { 952 case sink <- event: 953 case err := <-sub.Err(): 954 return err 955 case <-quit: 956 return nil 957 } 958 case err := <-sub.Err(): 959 return err 960 case <-quit: 961 return nil 962 } 963 } 964 }), nil 965 } 966 967 // ParseL1BaseFeeUpdated is a log parse operation binding the contract event 0x351fb23757bb5ea0546c85b7996ddd7155f96b939ebaa5ff7bc49c75f27f2c44. 968 // 969 // Solidity: event L1BaseFeeUpdated(uint256 arg0) 970 func (_OptimismGas *OptimismGasFilterer) ParseL1BaseFeeUpdated(log types.Log) (*OptimismGasL1BaseFeeUpdated, error) { 971 event := new(OptimismGasL1BaseFeeUpdated) 972 if err := _OptimismGas.contract.UnpackLog(event, "L1BaseFeeUpdated", log); err != nil { 973 return nil, err 974 } 975 event.Raw = log 976 return event, nil 977 } 978 979 // OptimismGasOverheadUpdatedIterator is returned from FilterOverheadUpdated and is used to iterate over the raw logs and unpacked data for OverheadUpdated events raised by the OptimismGas contract. 980 type OptimismGasOverheadUpdatedIterator struct { 981 Event *OptimismGasOverheadUpdated // Event containing the contract specifics and raw log 982 983 contract *bind.BoundContract // Generic contract to use for unpacking event data 984 event string // Event name to use for unpacking event data 985 986 logs chan types.Log // Log channel receiving the found contract events 987 sub ethereum.Subscription // Subscription for errors, completion and termination 988 done bool // Whether the subscription completed delivering logs 989 fail error // Occurred error to stop iteration 990 } 991 992 // Next advances the iterator to the subsequent event, returning whether there 993 // are any more events found. In case of a retrieval or parsing error, false is 994 // returned and Error() can be queried for the exact failure. 995 func (it *OptimismGasOverheadUpdatedIterator) Next() bool { 996 // If the iterator failed, stop iterating 997 if it.fail != nil { 998 return false 999 } 1000 // If the iterator completed, deliver directly whatever's available 1001 if it.done { 1002 select { 1003 case log := <-it.logs: 1004 it.Event = new(OptimismGasOverheadUpdated) 1005 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1006 it.fail = err 1007 return false 1008 } 1009 it.Event.Raw = log 1010 return true 1011 1012 default: 1013 return false 1014 } 1015 } 1016 // Iterator still in progress, wait for either a data or an error event 1017 select { 1018 case log := <-it.logs: 1019 it.Event = new(OptimismGasOverheadUpdated) 1020 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1021 it.fail = err 1022 return false 1023 } 1024 it.Event.Raw = log 1025 return true 1026 1027 case err := <-it.sub.Err(): 1028 it.done = true 1029 it.fail = err 1030 return it.Next() 1031 } 1032 } 1033 1034 // Error returns any retrieval or parsing error occurred during filtering. 1035 func (it *OptimismGasOverheadUpdatedIterator) Error() error { 1036 return it.fail 1037 } 1038 1039 // Close terminates the iteration process, releasing any pending underlying 1040 // resources. 1041 func (it *OptimismGasOverheadUpdatedIterator) Close() error { 1042 it.sub.Unsubscribe() 1043 return nil 1044 } 1045 1046 // OptimismGasOverheadUpdated represents a OverheadUpdated event raised by the OptimismGas contract. 1047 type OptimismGasOverheadUpdated struct { 1048 Arg0 *big.Int 1049 Raw types.Log // Blockchain specific contextual infos 1050 } 1051 1052 // FilterOverheadUpdated is a free log retrieval operation binding the contract event 0x32740b35c0ea213650f60d44366b4fb211c9033b50714e4a1d34e65d5beb9bb4. 1053 // 1054 // Solidity: event OverheadUpdated(uint256 arg0) 1055 func (_OptimismGas *OptimismGasFilterer) FilterOverheadUpdated(opts *bind.FilterOpts) (*OptimismGasOverheadUpdatedIterator, error) { 1056 1057 logs, sub, err := _OptimismGas.contract.FilterLogs(opts, "OverheadUpdated") 1058 if err != nil { 1059 return nil, err 1060 } 1061 return &OptimismGasOverheadUpdatedIterator{contract: _OptimismGas.contract, event: "OverheadUpdated", logs: logs, sub: sub}, nil 1062 } 1063 1064 // WatchOverheadUpdated is a free log subscription operation binding the contract event 0x32740b35c0ea213650f60d44366b4fb211c9033b50714e4a1d34e65d5beb9bb4. 1065 // 1066 // Solidity: event OverheadUpdated(uint256 arg0) 1067 func (_OptimismGas *OptimismGasFilterer) WatchOverheadUpdated(opts *bind.WatchOpts, sink chan<- *OptimismGasOverheadUpdated) (event.Subscription, error) { 1068 1069 logs, sub, err := _OptimismGas.contract.WatchLogs(opts, "OverheadUpdated") 1070 if err != nil { 1071 return nil, err 1072 } 1073 return event.NewSubscription(func(quit <-chan struct{}) error { 1074 defer sub.Unsubscribe() 1075 for { 1076 select { 1077 case log := <-logs: 1078 // New log arrived, parse the event and forward to the user 1079 event := new(OptimismGasOverheadUpdated) 1080 if err := _OptimismGas.contract.UnpackLog(event, "OverheadUpdated", log); err != nil { 1081 return err 1082 } 1083 event.Raw = log 1084 1085 select { 1086 case sink <- event: 1087 case err := <-sub.Err(): 1088 return err 1089 case <-quit: 1090 return nil 1091 } 1092 case err := <-sub.Err(): 1093 return err 1094 case <-quit: 1095 return nil 1096 } 1097 } 1098 }), nil 1099 } 1100 1101 // ParseOverheadUpdated is a log parse operation binding the contract event 0x32740b35c0ea213650f60d44366b4fb211c9033b50714e4a1d34e65d5beb9bb4. 1102 // 1103 // Solidity: event OverheadUpdated(uint256 arg0) 1104 func (_OptimismGas *OptimismGasFilterer) ParseOverheadUpdated(log types.Log) (*OptimismGasOverheadUpdated, error) { 1105 event := new(OptimismGasOverheadUpdated) 1106 if err := _OptimismGas.contract.UnpackLog(event, "OverheadUpdated", log); err != nil { 1107 return nil, err 1108 } 1109 event.Raw = log 1110 return event, nil 1111 } 1112 1113 // OptimismGasOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the OptimismGas contract. 1114 type OptimismGasOwnershipTransferredIterator struct { 1115 Event *OptimismGasOwnershipTransferred // Event containing the contract specifics and raw log 1116 1117 contract *bind.BoundContract // Generic contract to use for unpacking event data 1118 event string // Event name to use for unpacking event data 1119 1120 logs chan types.Log // Log channel receiving the found contract events 1121 sub ethereum.Subscription // Subscription for errors, completion and termination 1122 done bool // Whether the subscription completed delivering logs 1123 fail error // Occurred error to stop iteration 1124 } 1125 1126 // Next advances the iterator to the subsequent event, returning whether there 1127 // are any more events found. In case of a retrieval or parsing error, false is 1128 // returned and Error() can be queried for the exact failure. 1129 func (it *OptimismGasOwnershipTransferredIterator) Next() bool { 1130 // If the iterator failed, stop iterating 1131 if it.fail != nil { 1132 return false 1133 } 1134 // If the iterator completed, deliver directly whatever's available 1135 if it.done { 1136 select { 1137 case log := <-it.logs: 1138 it.Event = new(OptimismGasOwnershipTransferred) 1139 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1140 it.fail = err 1141 return false 1142 } 1143 it.Event.Raw = log 1144 return true 1145 1146 default: 1147 return false 1148 } 1149 } 1150 // Iterator still in progress, wait for either a data or an error event 1151 select { 1152 case log := <-it.logs: 1153 it.Event = new(OptimismGasOwnershipTransferred) 1154 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1155 it.fail = err 1156 return false 1157 } 1158 it.Event.Raw = log 1159 return true 1160 1161 case err := <-it.sub.Err(): 1162 it.done = true 1163 it.fail = err 1164 return it.Next() 1165 } 1166 } 1167 1168 // Error returns any retrieval or parsing error occurred during filtering. 1169 func (it *OptimismGasOwnershipTransferredIterator) Error() error { 1170 return it.fail 1171 } 1172 1173 // Close terminates the iteration process, releasing any pending underlying 1174 // resources. 1175 func (it *OptimismGasOwnershipTransferredIterator) Close() error { 1176 it.sub.Unsubscribe() 1177 return nil 1178 } 1179 1180 // OptimismGasOwnershipTransferred represents a OwnershipTransferred event raised by the OptimismGas contract. 1181 type OptimismGasOwnershipTransferred struct { 1182 PreviousOwner common.Address 1183 NewOwner common.Address 1184 Raw types.Log // Blockchain specific contextual infos 1185 } 1186 1187 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 1188 // 1189 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 1190 func (_OptimismGas *OptimismGasFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OptimismGasOwnershipTransferredIterator, error) { 1191 1192 var previousOwnerRule []interface{} 1193 for _, previousOwnerItem := range previousOwner { 1194 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 1195 } 1196 var newOwnerRule []interface{} 1197 for _, newOwnerItem := range newOwner { 1198 newOwnerRule = append(newOwnerRule, newOwnerItem) 1199 } 1200 1201 logs, sub, err := _OptimismGas.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 1202 if err != nil { 1203 return nil, err 1204 } 1205 return &OptimismGasOwnershipTransferredIterator{contract: _OptimismGas.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 1206 } 1207 1208 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 1209 // 1210 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 1211 func (_OptimismGas *OptimismGasFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OptimismGasOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 1212 1213 var previousOwnerRule []interface{} 1214 for _, previousOwnerItem := range previousOwner { 1215 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 1216 } 1217 var newOwnerRule []interface{} 1218 for _, newOwnerItem := range newOwner { 1219 newOwnerRule = append(newOwnerRule, newOwnerItem) 1220 } 1221 1222 logs, sub, err := _OptimismGas.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 1223 if err != nil { 1224 return nil, err 1225 } 1226 return event.NewSubscription(func(quit <-chan struct{}) error { 1227 defer sub.Unsubscribe() 1228 for { 1229 select { 1230 case log := <-logs: 1231 // New log arrived, parse the event and forward to the user 1232 event := new(OptimismGasOwnershipTransferred) 1233 if err := _OptimismGas.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 1234 return err 1235 } 1236 event.Raw = log 1237 1238 select { 1239 case sink <- event: 1240 case err := <-sub.Err(): 1241 return err 1242 case <-quit: 1243 return nil 1244 } 1245 case err := <-sub.Err(): 1246 return err 1247 case <-quit: 1248 return nil 1249 } 1250 } 1251 }), nil 1252 } 1253 1254 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 1255 // 1256 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 1257 func (_OptimismGas *OptimismGasFilterer) ParseOwnershipTransferred(log types.Log) (*OptimismGasOwnershipTransferred, error) { 1258 event := new(OptimismGasOwnershipTransferred) 1259 if err := _OptimismGas.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 1260 return nil, err 1261 } 1262 event.Raw = log 1263 return event, nil 1264 } 1265 1266 // OptimismGasScalarUpdatedIterator is returned from FilterScalarUpdated and is used to iterate over the raw logs and unpacked data for ScalarUpdated events raised by the OptimismGas contract. 1267 type OptimismGasScalarUpdatedIterator struct { 1268 Event *OptimismGasScalarUpdated // Event containing the contract specifics and raw log 1269 1270 contract *bind.BoundContract // Generic contract to use for unpacking event data 1271 event string // Event name to use for unpacking event data 1272 1273 logs chan types.Log // Log channel receiving the found contract events 1274 sub ethereum.Subscription // Subscription for errors, completion and termination 1275 done bool // Whether the subscription completed delivering logs 1276 fail error // Occurred error to stop iteration 1277 } 1278 1279 // Next advances the iterator to the subsequent event, returning whether there 1280 // are any more events found. In case of a retrieval or parsing error, false is 1281 // returned and Error() can be queried for the exact failure. 1282 func (it *OptimismGasScalarUpdatedIterator) Next() bool { 1283 // If the iterator failed, stop iterating 1284 if it.fail != nil { 1285 return false 1286 } 1287 // If the iterator completed, deliver directly whatever's available 1288 if it.done { 1289 select { 1290 case log := <-it.logs: 1291 it.Event = new(OptimismGasScalarUpdated) 1292 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1293 it.fail = err 1294 return false 1295 } 1296 it.Event.Raw = log 1297 return true 1298 1299 default: 1300 return false 1301 } 1302 } 1303 // Iterator still in progress, wait for either a data or an error event 1304 select { 1305 case log := <-it.logs: 1306 it.Event = new(OptimismGasScalarUpdated) 1307 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1308 it.fail = err 1309 return false 1310 } 1311 it.Event.Raw = log 1312 return true 1313 1314 case err := <-it.sub.Err(): 1315 it.done = true 1316 it.fail = err 1317 return it.Next() 1318 } 1319 } 1320 1321 // Error returns any retrieval or parsing error occurred during filtering. 1322 func (it *OptimismGasScalarUpdatedIterator) Error() error { 1323 return it.fail 1324 } 1325 1326 // Close terminates the iteration process, releasing any pending underlying 1327 // resources. 1328 func (it *OptimismGasScalarUpdatedIterator) Close() error { 1329 it.sub.Unsubscribe() 1330 return nil 1331 } 1332 1333 // OptimismGasScalarUpdated represents a ScalarUpdated event raised by the OptimismGas contract. 1334 type OptimismGasScalarUpdated struct { 1335 Arg0 *big.Int 1336 Raw types.Log // Blockchain specific contextual infos 1337 } 1338 1339 // FilterScalarUpdated is a free log retrieval operation binding the contract event 0x3336cd9708eaf2769a0f0dc0679f30e80f15dcd88d1921b5a16858e8b85c591a. 1340 // 1341 // Solidity: event ScalarUpdated(uint256 arg0) 1342 func (_OptimismGas *OptimismGasFilterer) FilterScalarUpdated(opts *bind.FilterOpts) (*OptimismGasScalarUpdatedIterator, error) { 1343 1344 logs, sub, err := _OptimismGas.contract.FilterLogs(opts, "ScalarUpdated") 1345 if err != nil { 1346 return nil, err 1347 } 1348 return &OptimismGasScalarUpdatedIterator{contract: _OptimismGas.contract, event: "ScalarUpdated", logs: logs, sub: sub}, nil 1349 } 1350 1351 // WatchScalarUpdated is a free log subscription operation binding the contract event 0x3336cd9708eaf2769a0f0dc0679f30e80f15dcd88d1921b5a16858e8b85c591a. 1352 // 1353 // Solidity: event ScalarUpdated(uint256 arg0) 1354 func (_OptimismGas *OptimismGasFilterer) WatchScalarUpdated(opts *bind.WatchOpts, sink chan<- *OptimismGasScalarUpdated) (event.Subscription, error) { 1355 1356 logs, sub, err := _OptimismGas.contract.WatchLogs(opts, "ScalarUpdated") 1357 if err != nil { 1358 return nil, err 1359 } 1360 return event.NewSubscription(func(quit <-chan struct{}) error { 1361 defer sub.Unsubscribe() 1362 for { 1363 select { 1364 case log := <-logs: 1365 // New log arrived, parse the event and forward to the user 1366 event := new(OptimismGasScalarUpdated) 1367 if err := _OptimismGas.contract.UnpackLog(event, "ScalarUpdated", log); err != nil { 1368 return err 1369 } 1370 event.Raw = log 1371 1372 select { 1373 case sink <- event: 1374 case err := <-sub.Err(): 1375 return err 1376 case <-quit: 1377 return nil 1378 } 1379 case err := <-sub.Err(): 1380 return err 1381 case <-quit: 1382 return nil 1383 } 1384 } 1385 }), nil 1386 } 1387 1388 // ParseScalarUpdated is a log parse operation binding the contract event 0x3336cd9708eaf2769a0f0dc0679f30e80f15dcd88d1921b5a16858e8b85c591a. 1389 // 1390 // Solidity: event ScalarUpdated(uint256 arg0) 1391 func (_OptimismGas *OptimismGasFilterer) ParseScalarUpdated(log types.Log) (*OptimismGasScalarUpdated, error) { 1392 event := new(OptimismGasScalarUpdated) 1393 if err := _OptimismGas.contract.UnpackLog(event, "ScalarUpdated", log); err != nil { 1394 return nil, err 1395 } 1396 event.Raw = log 1397 return event, nil 1398 }