contracts

package
v0.0.0-...-1f8a15b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 12, 2023 License: GPL-3.0 Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source 
const ChangerABI = "" /* 185-byte string literal not displayed */

ChangerABI is the input ABI used to generate the binding from.

View Source 
const PhoenixABI = "" /* 348-byte string literal not displayed */

PhoenixABI is the input ABI used to generate the binding from.

View Source 
const PolyABI = "" /* 418-byte string literal not displayed */

PolyABI is the input ABI used to generate the binding from.

View Source 
const Revive2ABI = "" /* 426-byte string literal not displayed */

Revive2ABI is the input ABI used to generate the binding from.

View Source 
const ReviveABI = "" /* 418-byte string literal not displayed */

ReviveABI is the input ABI used to generate the binding from.

View Source 
const SelfdestructABI = "" /* 350-byte string literal not displayed */

SelfdestructABI is the input ABI used to generate the binding from.

Variables

View Source 
var ChangerBin = "" /* 314-byte string literal not displayed */

ChangerBin is the compiled bytecode used for deploying new contracts.

View Source 
var PhoenixBin = "" /* 454-byte string literal not displayed */

PhoenixBin is the compiled bytecode used for deploying new contracts.

View Source 
var PolyBin = "" /* 558-byte string literal not displayed */

PolyBin is the compiled bytecode used for deploying new contracts.

View Source 
var Revive2Bin = "" /* 1114-byte string literal not displayed */

Revive2Bin is the compiled bytecode used for deploying new contracts.

View Source 
var ReviveBin = "" /* 558-byte string literal not displayed */

ReviveBin is the compiled bytecode used for deploying new contracts.

View Source 
var SelfdestructBin = "" /* 454-byte string literal not displayed */

SelfdestructBin is the compiled bytecode used for deploying new contracts.

Functions

This section is empty.

Types

type Changer 

type Changer struct {
	ChangerCaller     // Read-only binding to the contract
	ChangerTransactor // Write-only binding to the contract
	ChangerFilterer   // Log filterer for contract events
}

Changer is an auto generated Go binding around an Ethereum contract.

func DeployChanger 

func DeployChanger(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Changer, error)

DeployChanger deploys a new Ethereum contract, binding an instance of Changer to it.

func NewChanger 

func NewChanger(address libcommon.Address, backend bind.ContractBackend) (*Changer, error)

NewChanger creates a new instance of Changer, bound to a specific deployed contract.

type ChangerCaller 

type ChangerCaller struct {
	// contains filtered or unexported fields
}

ChangerCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewChangerCaller 

func NewChangerCaller(address libcommon.Address, caller bind.ContractCaller) (*ChangerCaller, error)

NewChangerCaller creates a new read-only instance of Changer, bound to a specific deployed contract.

type ChangerCallerRaw 

type ChangerCallerRaw struct {
	Contract *ChangerCaller // Generic read-only contract binding to access the raw methods on
}

ChangerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ChangerCallerRaw) Call 

func (_Changer *ChangerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ChangerCallerSession 

type ChangerCallerSession struct {
	Contract *ChangerCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts  // Call options to use throughout this session
}

ChangerCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ChangerFilterer 

type ChangerFilterer struct {
	// contains filtered or unexported fields
}

ChangerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewChangerFilterer 

func NewChangerFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*ChangerFilterer, error)

NewChangerFilterer creates a new log filterer instance of Changer, bound to a specific deployed contract.

type ChangerRaw 

type ChangerRaw struct {
	Contract *Changer // Generic contract binding to access the raw methods on
}

ChangerRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ChangerRaw) Call 

func (_Changer *ChangerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ChangerRaw) Transact 

func (_Changer *ChangerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ChangerRaw) Transfer 

func (_Changer *ChangerRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ChangerSession 

type ChangerSession struct {
	Contract     *Changer          // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ChangerSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ChangerSession) Change 

func (_Changer *ChangerSession) Change() (types.Transaction, error)

Change is a paid mutator transaction binding the contract method 0x2ee79ded.

Solidity: function change() returns()

type ChangerTransactor 

type ChangerTransactor struct {
	// contains filtered or unexported fields
}

ChangerTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewChangerTransactor 

func NewChangerTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*ChangerTransactor, error)

NewChangerTransactor creates a new write-only instance of Changer, bound to a specific deployed contract.

func (*ChangerTransactor) Change 

func (_Changer *ChangerTransactor) Change(opts *bind.TransactOpts) (types.Transaction, error)

Change is a paid mutator transaction binding the contract method 0x2ee79ded.

Solidity: function change() returns()

type ChangerTransactorRaw 

type ChangerTransactorRaw struct {
	Contract *ChangerTransactor // Generic write-only contract binding to access the raw methods on
}

ChangerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ChangerTransactorRaw) Transact 

func (_Changer *ChangerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ChangerTransactorRaw) Transfer 

func (_Changer *ChangerTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ChangerTransactorSession 

type ChangerTransactorSession struct {
	Contract     *ChangerTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
}

ChangerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*ChangerTransactorSession) Change 

func (_Changer *ChangerTransactorSession) Change() (types.Transaction, error)

Change is a paid mutator transaction binding the contract method 0x2ee79ded.

Solidity: function change() returns()

type Phoenix 

type Phoenix struct {
	PhoenixCaller     // Read-only binding to the contract
	PhoenixTransactor // Write-only binding to the contract
	PhoenixFilterer   // Log filterer for contract events
}

Phoenix is an auto generated Go binding around an Ethereum contract.

func DeployPhoenix 

func DeployPhoenix(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Phoenix, error)

DeployPhoenix deploys a new Ethereum contract, binding an instance of Phoenix to it.

func NewPhoenix 

func NewPhoenix(address libcommon.Address, backend bind.ContractBackend) (*Phoenix, error)

NewPhoenix creates a new instance of Phoenix, bound to a specific deployed contract.

type PhoenixCaller 

type PhoenixCaller struct {
	// contains filtered or unexported fields
}

PhoenixCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewPhoenixCaller 

func NewPhoenixCaller(address libcommon.Address, caller bind.ContractCaller) (*PhoenixCaller, error)

NewPhoenixCaller creates a new read-only instance of Phoenix, bound to a specific deployed contract.

type PhoenixCallerRaw 

type PhoenixCallerRaw struct {
	Contract *PhoenixCaller // Generic read-only contract binding to access the raw methods on
}

PhoenixCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*PhoenixCallerRaw) Call 

func (_Phoenix *PhoenixCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type PhoenixCallerSession 

type PhoenixCallerSession struct {
	Contract *PhoenixCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts  // Call options to use throughout this session
}

PhoenixCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type PhoenixFilterer 

type PhoenixFilterer struct {
	// contains filtered or unexported fields
}

PhoenixFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewPhoenixFilterer 

func NewPhoenixFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*PhoenixFilterer, error)

NewPhoenixFilterer creates a new log filterer instance of Phoenix, bound to a specific deployed contract.

type PhoenixRaw 

type PhoenixRaw struct {
	Contract *Phoenix // Generic contract binding to access the raw methods on
}

PhoenixRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*PhoenixRaw) Call 

func (_Phoenix *PhoenixRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*PhoenixRaw) Transact 

func (_Phoenix *PhoenixRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*PhoenixRaw) Transfer 

func (_Phoenix *PhoenixRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type PhoenixSession 

type PhoenixSession struct {
	Contract     *Phoenix          // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

PhoenixSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*PhoenixSession) Die 

func (_Phoenix *PhoenixSession) Die() (types.Transaction, error)

Die is a paid mutator transaction binding the contract method 0x35f46994.

Solidity: function die() returns()

func (*PhoenixSession) Increment 

func (_Phoenix *PhoenixSession) Increment() (types.Transaction, error)

Increment is a paid mutator transaction binding the contract method 0xd09de08a.

Solidity: function increment() returns()

func (*PhoenixSession) Receive 

func (_Phoenix *PhoenixSession) Receive() (types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

type PhoenixTransactor 

type PhoenixTransactor struct {
	// contains filtered or unexported fields
}

PhoenixTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewPhoenixTransactor 

func NewPhoenixTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*PhoenixTransactor, error)

NewPhoenixTransactor creates a new write-only instance of Phoenix, bound to a specific deployed contract.

func (*PhoenixTransactor) Die 

func (_Phoenix *PhoenixTransactor) Die(opts *bind.TransactOpts) (types.Transaction, error)

Die is a paid mutator transaction binding the contract method 0x35f46994.

Solidity: function die() returns()

func (*PhoenixTransactor) Increment 

func (_Phoenix *PhoenixTransactor) Increment(opts *bind.TransactOpts) (types.Transaction, error)

Increment is a paid mutator transaction binding the contract method 0xd09de08a.

Solidity: function increment() returns()

func (*PhoenixTransactor) Receive 

func (_Phoenix *PhoenixTransactor) Receive(opts *bind.TransactOpts) (types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

type PhoenixTransactorRaw 

type PhoenixTransactorRaw struct {
	Contract *PhoenixTransactor // Generic write-only contract binding to access the raw methods on
}

PhoenixTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*PhoenixTransactorRaw) Transact 

func (_Phoenix *PhoenixTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*PhoenixTransactorRaw) Transfer 

func (_Phoenix *PhoenixTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type PhoenixTransactorSession 

type PhoenixTransactorSession struct {
	Contract     *PhoenixTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
}

PhoenixTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*PhoenixTransactorSession) Die 

func (_Phoenix *PhoenixTransactorSession) Die() (types.Transaction, error)

Die is a paid mutator transaction binding the contract method 0x35f46994.

Solidity: function die() returns()

func (*PhoenixTransactorSession) Increment 

func (_Phoenix *PhoenixTransactorSession) Increment() (types.Transaction, error)

Increment is a paid mutator transaction binding the contract method 0xd09de08a.

Solidity: function increment() returns()

func (*PhoenixTransactorSession) Receive 

func (_Phoenix *PhoenixTransactorSession) Receive() (types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

type Poly 

type Poly struct {
	PolyCaller     // Read-only binding to the contract
	PolyTransactor // Write-only binding to the contract
	PolyFilterer   // Log filterer for contract events
}

Poly is an auto generated Go binding around an Ethereum contract.

func DeployPoly 

func DeployPoly(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Poly, error)

DeployPoly deploys a new Ethereum contract, binding an instance of Poly to it.

func NewPoly 

func NewPoly(address libcommon.Address, backend bind.ContractBackend) (*Poly, error)

NewPoly creates a new instance of Poly, bound to a specific deployed contract.

type PolyCaller 

type PolyCaller struct {
	// contains filtered or unexported fields
}

PolyCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewPolyCaller 

func NewPolyCaller(address libcommon.Address, caller bind.ContractCaller) (*PolyCaller, error)

NewPolyCaller creates a new read-only instance of Poly, bound to a specific deployed contract.

type PolyCallerRaw 

type PolyCallerRaw struct {
	Contract *PolyCaller // Generic read-only contract binding to access the raw methods on
}

PolyCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*PolyCallerRaw) Call 

func (_Poly *PolyCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type PolyCallerSession 

type PolyCallerSession struct {
	Contract *PolyCaller   // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

PolyCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type PolyDeployEvent 

type PolyDeployEvent struct {
	D   libcommon.Address
	Raw types.Log // Blockchain specific contextual infos
}

PolyDeployEvent represents a DeployEvent event raised by the Poly contract.

type PolyDeployEventIterator 

type PolyDeployEventIterator struct {
	Event *PolyDeployEvent // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

PolyDeployEventIterator is returned from FilterDeployEvent and is used to iterate over the raw logs and unpacked data for DeployEvent events raised by the Poly contract.

func (*PolyDeployEventIterator) Close 

func (it *PolyDeployEventIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*PolyDeployEventIterator) Error 

func (it *PolyDeployEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*PolyDeployEventIterator) Next 

func (it *PolyDeployEventIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type PolyFilterer 

type PolyFilterer struct {
	// contains filtered or unexported fields
}

PolyFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewPolyFilterer 

func NewPolyFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*PolyFilterer, error)

NewPolyFilterer creates a new log filterer instance of Poly, bound to a specific deployed contract.

func (*PolyFilterer) FilterDeployEvent 

func (_Poly *PolyFilterer) FilterDeployEvent(opts *bind.FilterOpts) (*PolyDeployEventIterator, error)

FilterDeployEvent is a free log retrieval operation binding the contract event 0x68f6a0f063c25c6678c443b9a484086f15ba8f91f60218695d32a5251f2050eb.

Solidity: event DeployEvent(address d)

func (*PolyFilterer) ParseDeployEvent 

func (_Poly *PolyFilterer) ParseDeployEvent(log types.Log) (*PolyDeployEvent, error)

ParseDeployEvent is a log parse operation binding the contract event 0x68f6a0f063c25c6678c443b9a484086f15ba8f91f60218695d32a5251f2050eb.

Solidity: event DeployEvent(address d)

func (*PolyFilterer) WatchDeployEvent 

func (_Poly *PolyFilterer) WatchDeployEvent(opts *bind.WatchOpts, sink chan<- *PolyDeployEvent) (event.Subscription, error)

WatchDeployEvent is a free log subscription operation binding the contract event 0x68f6a0f063c25c6678c443b9a484086f15ba8f91f60218695d32a5251f2050eb.

Solidity: event DeployEvent(address d)

type PolyRaw 

type PolyRaw struct {
	Contract *Poly // Generic contract binding to access the raw methods on
}

PolyRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*PolyRaw) Call 

func (_Poly *PolyRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*PolyRaw) Transact 

func (_Poly *PolyRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*PolyRaw) Transfer 

func (_Poly *PolyRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type PolySession 

type PolySession struct {
	Contract     *Poly             // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

PolySession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*PolySession) Deploy 

func (_Poly *PolySession) Deploy(salt *big.Int) (types.Transaction, error)

Deploy is a paid mutator transaction binding the contract method 0xa5e38751.

Solidity: function deploy(uint256 salt) returns()

type PolyTransactor 

type PolyTransactor struct {
	// contains filtered or unexported fields
}

PolyTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewPolyTransactor 

func NewPolyTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*PolyTransactor, error)

NewPolyTransactor creates a new write-only instance of Poly, bound to a specific deployed contract.

func (*PolyTransactor) Deploy 

func (_Poly *PolyTransactor) Deploy(opts *bind.TransactOpts, salt *big.Int) (types.Transaction, error)

Deploy is a paid mutator transaction binding the contract method 0xa5e38751.

Solidity: function deploy(uint256 salt) returns()

type PolyTransactorRaw 

type PolyTransactorRaw struct {
	Contract *PolyTransactor // Generic write-only contract binding to access the raw methods on
}

PolyTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*PolyTransactorRaw) Transact 

func (_Poly *PolyTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*PolyTransactorRaw) Transfer 

func (_Poly *PolyTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type PolyTransactorSession 

type PolyTransactorSession struct {
	Contract     *PolyTransactor   // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

PolyTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*PolyTransactorSession) Deploy 

func (_Poly *PolyTransactorSession) Deploy(salt *big.Int) (types.Transaction, error)

Deploy is a paid mutator transaction binding the contract method 0xa5e38751.

Solidity: function deploy(uint256 salt) returns()

type Revive 

type Revive struct {
	ReviveCaller     // Read-only binding to the contract
	ReviveTransactor // Write-only binding to the contract
	ReviveFilterer   // Log filterer for contract events
}

Revive is an auto generated Go binding around an Ethereum contract.

func DeployRevive 

func DeployRevive(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Revive, error)

DeployRevive deploys a new Ethereum contract, binding an instance of Revive to it.

func NewRevive 

func NewRevive(address libcommon.Address, backend bind.ContractBackend) (*Revive, error)

NewRevive creates a new instance of Revive, bound to a specific deployed contract.

type Revive2 

type Revive2 struct {
	Revive2Caller     // Read-only binding to the contract
	Revive2Transactor // Write-only binding to the contract
	Revive2Filterer   // Log filterer for contract events
}

Revive2 is an auto generated Go binding around an Ethereum contract.

func DeployRevive2 

func DeployRevive2(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Revive2, error)

DeployRevive2 deploys a new Ethereum contract, binding an instance of Revive2 to it.

func NewRevive2 

func NewRevive2(address libcommon.Address, backend bind.ContractBackend) (*Revive2, error)

NewRevive2 creates a new instance of Revive2, bound to a specific deployed contract.

type Revive2Caller 

type Revive2Caller struct {
	// contains filtered or unexported fields
}

Revive2Caller is an auto generated read-only Go binding around an Ethereum contract.

func NewRevive2Caller 

func NewRevive2Caller(address libcommon.Address, caller bind.ContractCaller) (*Revive2Caller, error)

NewRevive2Caller creates a new read-only instance of Revive2, bound to a specific deployed contract.

type Revive2CallerRaw 

type Revive2CallerRaw struct {
	Contract *Revive2Caller // Generic read-only contract binding to access the raw methods on
}

Revive2CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*Revive2CallerRaw) Call 

func (_Revive2 *Revive2CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type Revive2CallerSession 

type Revive2CallerSession struct {
	Contract *Revive2Caller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts  // Call options to use throughout this session
}

Revive2CallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type Revive2DeployEvent 

type Revive2DeployEvent struct {
	D   libcommon.Address
	Raw types.Log // Blockchain specific contextual infos
}

Revive2DeployEvent represents a DeployEvent event raised by the Revive2 contract.

type Revive2DeployEventIterator 

type Revive2DeployEventIterator struct {
	Event *Revive2DeployEvent // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

Revive2DeployEventIterator is returned from FilterDeployEvent and is used to iterate over the raw logs and unpacked data for DeployEvent events raised by the Revive2 contract.

func (*Revive2DeployEventIterator) Close 

func (it *Revive2DeployEventIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*Revive2DeployEventIterator) Error 

func (it *Revive2DeployEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*Revive2DeployEventIterator) Next 

func (it *Revive2DeployEventIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type Revive2Filterer 

type Revive2Filterer struct {
	// contains filtered or unexported fields
}

Revive2Filterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewRevive2Filterer 

func NewRevive2Filterer(address libcommon.Address, filterer bind.ContractFilterer) (*Revive2Filterer, error)

NewRevive2Filterer creates a new log filterer instance of Revive2, bound to a specific deployed contract.

func (*Revive2Filterer) FilterDeployEvent 

func (_Revive2 *Revive2Filterer) FilterDeployEvent(opts *bind.FilterOpts) (*Revive2DeployEventIterator, error)

FilterDeployEvent is a free log retrieval operation binding the contract event 0x68f6a0f063c25c6678c443b9a484086f15ba8f91f60218695d32a5251f2050eb.

Solidity: event DeployEvent(address d)

func (*Revive2Filterer) ParseDeployEvent 

func (_Revive2 *Revive2Filterer) ParseDeployEvent(log types.Log) (*Revive2DeployEvent, error)

ParseDeployEvent is a log parse operation binding the contract event 0x68f6a0f063c25c6678c443b9a484086f15ba8f91f60218695d32a5251f2050eb.

Solidity: event DeployEvent(address d)

func (*Revive2Filterer) WatchDeployEvent 

func (_Revive2 *Revive2Filterer) WatchDeployEvent(opts *bind.WatchOpts, sink chan<- *Revive2DeployEvent) (event.Subscription, error)

WatchDeployEvent is a free log subscription operation binding the contract event 0x68f6a0f063c25c6678c443b9a484086f15ba8f91f60218695d32a5251f2050eb.

Solidity: event DeployEvent(address d)

type Revive2Raw 

type Revive2Raw struct {
	Contract *Revive2 // Generic contract binding to access the raw methods on
}

Revive2Raw is an auto generated low-level Go binding around an Ethereum contract.

func (*Revive2Raw) Call 

func (_Revive2 *Revive2Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*Revive2Raw) Transact 

func (_Revive2 *Revive2Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*Revive2Raw) Transfer 

func (_Revive2 *Revive2Raw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type Revive2Session 

type Revive2Session struct {
	Contract     *Revive2          // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

Revive2Session is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*Revive2Session) Deploy 

func (_Revive2 *Revive2Session) Deploy(salt [32]byte) (types.Transaction, error)

Deploy is a paid mutator transaction binding the contract method 0x2b85ba38.

Solidity: function deploy(bytes32 salt) returns()

type Revive2Transactor 

type Revive2Transactor struct {
	// contains filtered or unexported fields
}

Revive2Transactor is an auto generated write-only Go binding around an Ethereum contract.

func NewRevive2Transactor 

func NewRevive2Transactor(address libcommon.Address, transactor bind.ContractTransactor) (*Revive2Transactor, error)

NewRevive2Transactor creates a new write-only instance of Revive2, bound to a specific deployed contract.

func (*Revive2Transactor) Deploy 

func (_Revive2 *Revive2Transactor) Deploy(opts *bind.TransactOpts, salt [32]byte) (types.Transaction, error)

Deploy is a paid mutator transaction binding the contract method 0x2b85ba38.

Solidity: function deploy(bytes32 salt) returns()

type Revive2TransactorRaw 

type Revive2TransactorRaw struct {
	Contract *Revive2Transactor // Generic write-only contract binding to access the raw methods on
}

Revive2TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*Revive2TransactorRaw) Transact 

func (_Revive2 *Revive2TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*Revive2TransactorRaw) Transfer 

func (_Revive2 *Revive2TransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type Revive2TransactorSession 

type Revive2TransactorSession struct {
	Contract     *Revive2Transactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
}

Revive2TransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*Revive2TransactorSession) Deploy 

func (_Revive2 *Revive2TransactorSession) Deploy(salt [32]byte) (types.Transaction, error)

Deploy is a paid mutator transaction binding the contract method 0x2b85ba38.

Solidity: function deploy(bytes32 salt) returns()

type ReviveCaller 

type ReviveCaller struct {
	// contains filtered or unexported fields
}

ReviveCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewReviveCaller 

func NewReviveCaller(address libcommon.Address, caller bind.ContractCaller) (*ReviveCaller, error)

NewReviveCaller creates a new read-only instance of Revive, bound to a specific deployed contract.

type ReviveCallerRaw 

type ReviveCallerRaw struct {
	Contract *ReviveCaller // Generic read-only contract binding to access the raw methods on
}

ReviveCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ReviveCallerRaw) Call 

func (_Revive *ReviveCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ReviveCallerSession 

type ReviveCallerSession struct {
	Contract *ReviveCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

ReviveCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ReviveDeployEvent 

type ReviveDeployEvent struct {
	D   libcommon.Address
	Raw types.Log // Blockchain specific contextual infos
}

ReviveDeployEvent represents a DeployEvent event raised by the Revive contract.

type ReviveDeployEventIterator 

type ReviveDeployEventIterator struct {
	Event *ReviveDeployEvent // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ReviveDeployEventIterator is returned from FilterDeployEvent and is used to iterate over the raw logs and unpacked data for DeployEvent events raised by the Revive contract.

func (*ReviveDeployEventIterator) Close 

func (it *ReviveDeployEventIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ReviveDeployEventIterator) Error 

func (it *ReviveDeployEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ReviveDeployEventIterator) Next 

func (it *ReviveDeployEventIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ReviveFilterer 

type ReviveFilterer struct {
	// contains filtered or unexported fields
}

ReviveFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewReviveFilterer 

func NewReviveFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*ReviveFilterer, error)

NewReviveFilterer creates a new log filterer instance of Revive, bound to a specific deployed contract.

func (*ReviveFilterer) FilterDeployEvent 

func (_Revive *ReviveFilterer) FilterDeployEvent(opts *bind.FilterOpts) (*ReviveDeployEventIterator, error)

FilterDeployEvent is a free log retrieval operation binding the contract event 0x68f6a0f063c25c6678c443b9a484086f15ba8f91f60218695d32a5251f2050eb.

Solidity: event DeployEvent(address d)

func (*ReviveFilterer) ParseDeployEvent 

func (_Revive *ReviveFilterer) ParseDeployEvent(log types.Log) (*ReviveDeployEvent, error)

ParseDeployEvent is a log parse operation binding the contract event 0x68f6a0f063c25c6678c443b9a484086f15ba8f91f60218695d32a5251f2050eb.

Solidity: event DeployEvent(address d)

func (*ReviveFilterer) WatchDeployEvent 

func (_Revive *ReviveFilterer) WatchDeployEvent(opts *bind.WatchOpts, sink chan<- *ReviveDeployEvent) (event.Subscription, error)

WatchDeployEvent is a free log subscription operation binding the contract event 0x68f6a0f063c25c6678c443b9a484086f15ba8f91f60218695d32a5251f2050eb.

Solidity: event DeployEvent(address d)

type ReviveRaw 

type ReviveRaw struct {
	Contract *Revive // Generic contract binding to access the raw methods on
}

ReviveRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ReviveRaw) Call 

func (_Revive *ReviveRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ReviveRaw) Transact 

func (_Revive *ReviveRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ReviveRaw) Transfer 

func (_Revive *ReviveRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ReviveSession 

type ReviveSession struct {
	Contract     *Revive           // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ReviveSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ReviveSession) Deploy 

func (_Revive *ReviveSession) Deploy(salt *big.Int) (types.Transaction, error)

Deploy is a paid mutator transaction binding the contract method 0xa5e38751.

Solidity: function deploy(uint256 salt) returns()

type ReviveTransactor 

type ReviveTransactor struct {
	// contains filtered or unexported fields
}

ReviveTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewReviveTransactor 

func NewReviveTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*ReviveTransactor, error)

NewReviveTransactor creates a new write-only instance of Revive, bound to a specific deployed contract.

func (*ReviveTransactor) Deploy 

func (_Revive *ReviveTransactor) Deploy(opts *bind.TransactOpts, salt *big.Int) (types.Transaction, error)

Deploy is a paid mutator transaction binding the contract method 0xa5e38751.

Solidity: function deploy(uint256 salt) returns()

type ReviveTransactorRaw 

type ReviveTransactorRaw struct {
	Contract *ReviveTransactor // Generic write-only contract binding to access the raw methods on
}

ReviveTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ReviveTransactorRaw) Transact 

func (_Revive *ReviveTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ReviveTransactorRaw) Transfer 

func (_Revive *ReviveTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ReviveTransactorSession 

type ReviveTransactorSession struct {
	Contract     *ReviveTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ReviveTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*ReviveTransactorSession) Deploy 

func (_Revive *ReviveTransactorSession) Deploy(salt *big.Int) (types.Transaction, error)

Deploy is a paid mutator transaction binding the contract method 0xa5e38751.

Solidity: function deploy(uint256 salt) returns()

type Selfdestruct 

type Selfdestruct struct {
	SelfdestructCaller     // Read-only binding to the contract
	SelfdestructTransactor // Write-only binding to the contract
	SelfdestructFilterer   // Log filterer for contract events
}

Selfdestruct is an auto generated Go binding around an Ethereum contract.

func DeploySelfdestruct 

func DeploySelfdestruct(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Selfdestruct, error)

DeploySelfdestruct deploys a new Ethereum contract, binding an instance of Selfdestruct to it.

func NewSelfdestruct 

func NewSelfdestruct(address libcommon.Address, backend bind.ContractBackend) (*Selfdestruct, error)

NewSelfdestruct creates a new instance of Selfdestruct, bound to a specific deployed contract.

type SelfdestructCaller 

type SelfdestructCaller struct {
	// contains filtered or unexported fields
}

SelfdestructCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewSelfdestructCaller 

func NewSelfdestructCaller(address libcommon.Address, caller bind.ContractCaller) (*SelfdestructCaller, error)

NewSelfdestructCaller creates a new read-only instance of Selfdestruct, bound to a specific deployed contract.

type SelfdestructCallerRaw 

type SelfdestructCallerRaw struct {
	Contract *SelfdestructCaller // Generic read-only contract binding to access the raw methods on
}

SelfdestructCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*SelfdestructCallerRaw) Call 

func (_Selfdestruct *SelfdestructCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type SelfdestructCallerSession 

type SelfdestructCallerSession struct {
	Contract *SelfdestructCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts       // Call options to use throughout this session
}

SelfdestructCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type SelfdestructFilterer 

type SelfdestructFilterer struct {
	// contains filtered or unexported fields
}

SelfdestructFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewSelfdestructFilterer 

func NewSelfdestructFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*SelfdestructFilterer, error)

NewSelfdestructFilterer creates a new log filterer instance of Selfdestruct, bound to a specific deployed contract.

type SelfdestructRaw 

type SelfdestructRaw struct {
	Contract *Selfdestruct // Generic contract binding to access the raw methods on
}

SelfdestructRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*SelfdestructRaw) Call 

func (_Selfdestruct *SelfdestructRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*SelfdestructRaw) Transact 

func (_Selfdestruct *SelfdestructRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SelfdestructRaw) Transfer 

func (_Selfdestruct *SelfdestructRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SelfdestructSession 

type SelfdestructSession struct {
	Contract     *Selfdestruct     // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

SelfdestructSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*SelfdestructSession) Change 

func (_Selfdestruct *SelfdestructSession) Change() (types.Transaction, error)

Change is a paid mutator transaction binding the contract method 0x2ee79ded.

Solidity: function change() returns()

func (*SelfdestructSession) Destruct 

func (_Selfdestruct *SelfdestructSession) Destruct() (types.Transaction, error)

Destruct is a paid mutator transaction binding the contract method 0x2b68b9c6.

Solidity: function destruct() returns()

func (*SelfdestructSession) Receive 

func (_Selfdestruct *SelfdestructSession) Receive() (types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

type SelfdestructTransactor 

type SelfdestructTransactor struct {
	// contains filtered or unexported fields
}

SelfdestructTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewSelfdestructTransactor 

func NewSelfdestructTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*SelfdestructTransactor, error)

NewSelfdestructTransactor creates a new write-only instance of Selfdestruct, bound to a specific deployed contract.

func (*SelfdestructTransactor) Change 

func (_Selfdestruct *SelfdestructTransactor) Change(opts *bind.TransactOpts) (types.Transaction, error)

Change is a paid mutator transaction binding the contract method 0x2ee79ded.

Solidity: function change() returns()

func (*SelfdestructTransactor) Destruct 

func (_Selfdestruct *SelfdestructTransactor) Destruct(opts *bind.TransactOpts) (types.Transaction, error)

Destruct is a paid mutator transaction binding the contract method 0x2b68b9c6.

Solidity: function destruct() returns()

func (*SelfdestructTransactor) Receive 

func (_Selfdestruct *SelfdestructTransactor) Receive(opts *bind.TransactOpts) (types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

type SelfdestructTransactorRaw 

type SelfdestructTransactorRaw struct {
	Contract *SelfdestructTransactor // Generic write-only contract binding to access the raw methods on
}

SelfdestructTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*SelfdestructTransactorRaw) Transact 

func (_Selfdestruct *SelfdestructTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SelfdestructTransactorRaw) Transfer 

func (_Selfdestruct *SelfdestructTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SelfdestructTransactorSession 

type SelfdestructTransactorSession struct {
	Contract     *SelfdestructTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
}

SelfdestructTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*SelfdestructTransactorSession) Change 

func (_Selfdestruct *SelfdestructTransactorSession) Change() (types.Transaction, error)

Change is a paid mutator transaction binding the contract method 0x2ee79ded.

Solidity: function change() returns()

func (*SelfdestructTransactorSession) Destruct 

func (_Selfdestruct *SelfdestructTransactorSession) Destruct() (types.Transaction, error)

Destruct is a paid mutator transaction binding the contract method 0x2b68b9c6.

Solidity: function destruct() returns()

func (*SelfdestructTransactorSession) Receive 

func (_Selfdestruct *SelfdestructTransactorSession) Receive() (types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.