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 PolyABI = "" /* 606-byte string literal not displayed */

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

View Source 
const TokenABI = "" /* 1337-byte string literal not displayed */

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

Variables

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

PolyBin is the compiled bytecode used for deploying new contracts.

View Source 
var TokenBin = "" /* 1436-byte string literal not displayed */

TokenBin is the compiled bytecode used for deploying new contracts.

Functions

This section is empty.

Types

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()

func (*PolySession) DeployAndDestruct 

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

DeployAndDestruct is a paid mutator transaction binding the contract method 0x9debe981.

Solidity: function deployAndDestruct(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()

func (*PolyTransactor) DeployAndDestruct 

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

DeployAndDestruct is a paid mutator transaction binding the contract method 0x9debe981.

Solidity: function deployAndDestruct(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()

func (*PolyTransactorSession) DeployAndDestruct 

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

DeployAndDestruct is a paid mutator transaction binding the contract method 0x9debe981.

Solidity: function deployAndDestruct(uint256 salt) returns()

type Token 

type Token struct {
	TokenCaller     // Read-only binding to the contract
	TokenTransactor // Write-only binding to the contract
	TokenFilterer   // Log filterer for contract events
}

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

func DeployToken 

func DeployToken(auth *bind.TransactOpts, backend bind.ContractBackend, _minter libcommon.Address) (libcommon.Address, types.Transaction, *Token, error)

DeployToken deploys a new Ethereum contract, binding an instance of Token to it.

func NewToken 

func NewToken(address libcommon.Address, backend bind.ContractBackend) (*Token, error)

NewToken creates a new instance of Token, bound to a specific deployed contract.

type TokenCaller 

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

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

func NewTokenCaller 

func NewTokenCaller(address libcommon.Address, caller bind.ContractCaller) (*TokenCaller, error)

NewTokenCaller creates a new read-only instance of Token, bound to a specific deployed contract.

func (*TokenCaller) BalanceOf 

func (_Token *TokenCaller) BalanceOf(opts *bind.CallOpts, arg0 libcommon.Address) (*big.Int, error)

BalanceOf is a free data retrieval call binding the contract method 0x70a08231.

Solidity: function balanceOf(address ) view returns(uint256)

func (*TokenCaller) Minter 

func (_Token *TokenCaller) Minter(opts *bind.CallOpts) (libcommon.Address, error)

Minter is a free data retrieval call binding the contract method 0x07546172.

Solidity: function minter() view returns(address)

func (*TokenCaller) TotalSupply 

func (_Token *TokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() view returns(uint256)

type TokenCallerRaw 

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

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

func (*TokenCallerRaw) Call 

func (_Token *TokenCallerRaw) 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 TokenCallerSession 

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

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

func (*TokenCallerSession) BalanceOf 

func (_Token *TokenCallerSession) BalanceOf(arg0 libcommon.Address) (*big.Int, error)

BalanceOf is a free data retrieval call binding the contract method 0x70a08231.

Solidity: function balanceOf(address ) view returns(uint256)

func (*TokenCallerSession) Minter 

func (_Token *TokenCallerSession) Minter() (libcommon.Address, error)

Minter is a free data retrieval call binding the contract method 0x07546172.

Solidity: function minter() view returns(address)

func (*TokenCallerSession) TotalSupply 

func (_Token *TokenCallerSession) TotalSupply() (*big.Int, error)

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() view returns(uint256)

type TokenFilterer 

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

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

func NewTokenFilterer 

func NewTokenFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*TokenFilterer, error)

NewTokenFilterer creates a new log filterer instance of Token, bound to a specific deployed contract.

type TokenRaw 

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

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

func (*TokenRaw) Call 

func (_Token *TokenRaw) 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 (*TokenRaw) Transact 

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

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

func (*TokenRaw) Transfer 

func (_Token *TokenRaw) 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 TokenSession 

type TokenSession struct {
	Contract     *Token            // 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
}

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

func (*TokenSession) BalanceOf 

func (_Token *TokenSession) BalanceOf(arg0 libcommon.Address) (*big.Int, error)

BalanceOf is a free data retrieval call binding the contract method 0x70a08231.

Solidity: function balanceOf(address ) view returns(uint256)

func (*TokenSession) Mint 

func (_Token *TokenSession) Mint(_to libcommon.Address, _value *big.Int) (types.Transaction, error)

Mint is a paid mutator transaction binding the contract method 0x40c10f19.

Solidity: function mint(address _to, uint256 _value) returns(bool)

func (*TokenSession) Minter 

func (_Token *TokenSession) Minter() (libcommon.Address, error)

Minter is a free data retrieval call binding the contract method 0x07546172.

Solidity: function minter() view returns(address)

func (*TokenSession) TotalSupply 

func (_Token *TokenSession) TotalSupply() (*big.Int, error)

TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.

Solidity: function totalSupply() view returns(uint256)

func (*TokenSession) Transfer 

func (_Token *TokenSession) Transfer(_to libcommon.Address, _value *big.Int) (types.Transaction, error)

Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.

Solidity: function transfer(address _to, uint256 _value) returns(bool)

type TokenTransactor 

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

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

func NewTokenTransactor 

func NewTokenTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*TokenTransactor, error)

NewTokenTransactor creates a new write-only instance of Token, bound to a specific deployed contract.

func (*TokenTransactor) Mint 

func (_Token *TokenTransactor) Mint(opts *bind.TransactOpts, _to libcommon.Address, _value *big.Int) (types.Transaction, error)

Mint is a paid mutator transaction binding the contract method 0x40c10f19.

Solidity: function mint(address _to, uint256 _value) returns(bool)

func (*TokenTransactor) Transfer 

func (_Token *TokenTransactor) Transfer(opts *bind.TransactOpts, _to libcommon.Address, _value *big.Int) (types.Transaction, error)

Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.

Solidity: function transfer(address _to, uint256 _value) returns(bool)

type TokenTransactorRaw 

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

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

func (*TokenTransactorRaw) Transact 

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

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

func (*TokenTransactorRaw) Transfer 

func (_Token *TokenTransactorRaw) 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 TokenTransactorSession 

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

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

func (*TokenTransactorSession) Mint 

func (_Token *TokenTransactorSession) Mint(_to libcommon.Address, _value *big.Int) (types.Transaction, error)

Mint is a paid mutator transaction binding the contract method 0x40c10f19.

Solidity: function mint(address _to, uint256 _value) returns(bool)

func (*TokenTransactorSession) Transfer 

func (_Token *TokenTransactorSession) Transfer(_to libcommon.Address, _value *big.Int) (types.Transaction, error)

Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.

Solidity: function transfer(address _to, uint256 _value) returns(bool)

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.