abi

package
v0.1.7 Latest Latest
Warning

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

 Go to latest Published: Aug 26, 2022 License: GPL-3.0 Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var AxieABI = AxieMetaData.ABI

AxieABI is the input ABI used to generate the binding from. Deprecated: Use AxieMetaData.ABI instead.

View Source 
var AxieMetaData = &bind.MetaData{
	ABI: "[{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"_success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_sireId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_matronId\",\"type\":\"uint256\"}],\"name\":\"breedAxies\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"_success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_index\",\"type\":\"uint256\"}],\"name\":\"tokenOfOwnerByIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]",
}

AxieMetaData contains all meta data concerning the Axie contract.

View Source 
var MarketplaceABI = MarketplaceMetaData.ABI

MarketplaceABI is the input ABI used to generate the binding from. Deprecated: Use MarketplaceMetaData.ABI instead.

View Source 
var MarketplaceMetaData = &bind.MetaData{
	ABI: "[{\"constant\":false,\"inputs\":[{\"name\":\"_listingIndex\",\"type\":\"uint256\"}],\"name\":\"cancelAuction\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_tokenTypes\",\"type\":\"uint8\"},{\"name\":\"_tokenAddresses\",\"type\":\"address\"},{\"name\":\"_tokenNumbers\",\"type\":\"uint256\"},{\"name\":\"_startingPrices\",\"type\":\"uint256\"},{\"name\":\"_endingPrices\",\"type\":\"uint256\"},{\"name\":\"_exchangeTokens\",\"type\":\"address\"},{\"name\":\"_durations\",\"type\":\"uint256\"}],\"name\":\"createAuction\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
}

MarketplaceMetaData contains all meta data concerning the Marketplace contract.

View Source 
var RoninBalanceABI = RoninBalanceMetaData.ABI

RoninBalanceABI is the input ABI used to generate the binding from. Deprecated: Use RoninBalanceMetaData.ABI instead.

View Source 
var RoninBalanceMetaData = &bind.MetaData{
	ABI: "[{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]",
}

RoninBalanceMetaData contains all meta data concerning the RoninBalance contract.

View Source 
var SlpABI = SlpMetaData.ABI

SlpABI is the input ABI used to generate the binding from. Deprecated: Use SlpMetaData.ABI instead.

View Source 
var SlpMetaData = &bind.MetaData{
	ABI: "[{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_createdAt\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_signature\",\"type\":\"bytes\"}],\"name\":\"checkpoint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"_balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"_success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
}

SlpMetaData contains all meta data concerning the Slp contract.

Functions

This section is empty.

Types

type Axie 

type Axie struct {
	AxieCaller     // Read-only binding to the contract
	AxieTransactor // Write-only binding to the contract
	AxieFilterer   // Log filterer for contract events
}

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

func NewAxie 

func NewAxie(address common.Address, backend bind.ContractBackend) (*Axie, error)

NewAxie creates a new instance of Axie, bound to a specific deployed contract.

type AxieCaller 

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

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

func NewAxieCaller 

func NewAxieCaller(address common.Address, caller bind.ContractCaller) (*AxieCaller, error)

NewAxieCaller creates a new read-only instance of Axie, bound to a specific deployed contract.

func (*AxieCaller) BalanceOf 

func (_Axie *AxieCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

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

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

func (*AxieCaller) TokenOfOwnerByIndex 

func (_Axie *AxieCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, _owner common.Address, _index *big.Int) (*big.Int, error)

TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.

Solidity: function tokenOfOwnerByIndex(address _owner, uint256 _index) view returns(uint256)

type AxieCallerRaw 

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

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

func (*AxieCallerRaw) Call 

func (_Axie *AxieCallerRaw) 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 AxieCallerSession 

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

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

func (*AxieCallerSession) BalanceOf 

func (_Axie *AxieCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error)

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

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

func (*AxieCallerSession) TokenOfOwnerByIndex 

func (_Axie *AxieCallerSession) TokenOfOwnerByIndex(_owner common.Address, _index *big.Int) (*big.Int, error)

TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.

Solidity: function tokenOfOwnerByIndex(address _owner, uint256 _index) view returns(uint256)

type AxieFilterer 

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

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

func NewAxieFilterer 

func NewAxieFilterer(address common.Address, filterer bind.ContractFilterer) (*AxieFilterer, error)

NewAxieFilterer creates a new log filterer instance of Axie, bound to a specific deployed contract.

type AxieRaw 

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

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

func (*AxieRaw) Call 

func (_Axie *AxieRaw) 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 (*AxieRaw) Transact 

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

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

func (*AxieRaw) Transfer 

func (_Axie *AxieRaw) 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 AxieSession 

type AxieSession struct {
	Contract     *Axie             // 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
}

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

func (*AxieSession) BalanceOf 

func (_Axie *AxieSession) BalanceOf(arg0 common.Address) (*big.Int, error)

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

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

func (*AxieSession) BreedAxies 

func (_Axie *AxieSession) BreedAxies(_sireId *big.Int, _matronId *big.Int) (*types.Transaction, error)

BreedAxies is a paid mutator transaction binding the contract method 0x8264f2c2.

Solidity: function breedAxies(uint256 _sireId, uint256 _matronId) returns(bool _success)

func (*AxieSession) SafeTransferFrom 

func (_Axie *AxieSession) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error)

SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.

Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) returns(bool _success)

func (*AxieSession) TokenOfOwnerByIndex 

func (_Axie *AxieSession) TokenOfOwnerByIndex(_owner common.Address, _index *big.Int) (*big.Int, error)

TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.

Solidity: function tokenOfOwnerByIndex(address _owner, uint256 _index) view returns(uint256)

type AxieTransactor 

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

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

func NewAxieTransactor 

func NewAxieTransactor(address common.Address, transactor bind.ContractTransactor) (*AxieTransactor, error)

NewAxieTransactor creates a new write-only instance of Axie, bound to a specific deployed contract.

func (*AxieTransactor) BreedAxies 

func (_Axie *AxieTransactor) BreedAxies(opts *bind.TransactOpts, _sireId *big.Int, _matronId *big.Int) (*types.Transaction, error)

BreedAxies is a paid mutator transaction binding the contract method 0x8264f2c2.

Solidity: function breedAxies(uint256 _sireId, uint256 _matronId) returns(bool _success)

func (*AxieTransactor) SafeTransferFrom 

func (_Axie *AxieTransactor) SafeTransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error)

SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.

Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) returns(bool _success)

type AxieTransactorRaw 

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

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

func (*AxieTransactorRaw) Transact 

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

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

func (*AxieTransactorRaw) Transfer 

func (_Axie *AxieTransactorRaw) 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 AxieTransactorSession 

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

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

func (*AxieTransactorSession) BreedAxies 

func (_Axie *AxieTransactorSession) BreedAxies(_sireId *big.Int, _matronId *big.Int) (*types.Transaction, error)

BreedAxies is a paid mutator transaction binding the contract method 0x8264f2c2.

Solidity: function breedAxies(uint256 _sireId, uint256 _matronId) returns(bool _success)

func (*AxieTransactorSession) SafeTransferFrom 

func (_Axie *AxieTransactorSession) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error)

SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.

Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) returns(bool _success)

type Marketplace 

type Marketplace struct {
	MarketplaceCaller     // Read-only binding to the contract
	MarketplaceTransactor // Write-only binding to the contract
	MarketplaceFilterer   // Log filterer for contract events
}

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

func NewMarketplace 

func NewMarketplace(address common.Address, backend bind.ContractBackend) (*Marketplace, error)

NewMarketplace creates a new instance of Marketplace, bound to a specific deployed contract.

type MarketplaceCaller 

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

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

func NewMarketplaceCaller 

func NewMarketplaceCaller(address common.Address, caller bind.ContractCaller) (*MarketplaceCaller, error)

NewMarketplaceCaller creates a new read-only instance of Marketplace, bound to a specific deployed contract.

type MarketplaceCallerRaw 

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

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

func (*MarketplaceCallerRaw) Call 

func (_Marketplace *MarketplaceCallerRaw) 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 MarketplaceCallerSession 

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

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

type MarketplaceFilterer 

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

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

func NewMarketplaceFilterer 

func NewMarketplaceFilterer(address common.Address, filterer bind.ContractFilterer) (*MarketplaceFilterer, error)

NewMarketplaceFilterer creates a new log filterer instance of Marketplace, bound to a specific deployed contract.

type MarketplaceRaw 

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

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

func (*MarketplaceRaw) Call 

func (_Marketplace *MarketplaceRaw) 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 (*MarketplaceRaw) Transact 

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

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

func (*MarketplaceRaw) Transfer 

func (_Marketplace *MarketplaceRaw) 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 MarketplaceSession 

type MarketplaceSession struct {
	Contract     *Marketplace      // 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
}

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

func (*MarketplaceSession) CancelAuction 

func (_Marketplace *MarketplaceSession) CancelAuction(_listingIndex *big.Int) (*types.Transaction, error)

CancelAuction is a paid mutator transaction binding the contract method 0x96b5a755.

Solidity: function cancelAuction(uint256 _listingIndex) returns()

func (*MarketplaceSession) CreateAuction 

func (_Marketplace *MarketplaceSession) CreateAuction(_tokenTypes uint8, _tokenAddresses common.Address, _tokenNumbers *big.Int, _startingPrices *big.Int, _endingPrices *big.Int, _exchangeTokens common.Address, _durations *big.Int) (*types.Transaction, error)

CreateAuction is a paid mutator transaction binding the contract method 0x5c1f8e16.

Solidity: function createAuction(uint8 _tokenTypes, address _tokenAddresses, uint256 _tokenNumbers, uint256 _startingPrices, uint256 _endingPrices, address _exchangeTokens, uint256 _durations) returns()

type MarketplaceTransactor 

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

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

func NewMarketplaceTransactor 

func NewMarketplaceTransactor(address common.Address, transactor bind.ContractTransactor) (*MarketplaceTransactor, error)

NewMarketplaceTransactor creates a new write-only instance of Marketplace, bound to a specific deployed contract.

func (*MarketplaceTransactor) CancelAuction 

func (_Marketplace *MarketplaceTransactor) CancelAuction(opts *bind.TransactOpts, _listingIndex *big.Int) (*types.Transaction, error)

CancelAuction is a paid mutator transaction binding the contract method 0x96b5a755.

Solidity: function cancelAuction(uint256 _listingIndex) returns()

func (*MarketplaceTransactor) CreateAuction 

func (_Marketplace *MarketplaceTransactor) CreateAuction(opts *bind.TransactOpts, _tokenTypes uint8, _tokenAddresses common.Address, _tokenNumbers *big.Int, _startingPrices *big.Int, _endingPrices *big.Int, _exchangeTokens common.Address, _durations *big.Int) (*types.Transaction, error)

CreateAuction is a paid mutator transaction binding the contract method 0x5c1f8e16.

Solidity: function createAuction(uint8 _tokenTypes, address _tokenAddresses, uint256 _tokenNumbers, uint256 _startingPrices, uint256 _endingPrices, address _exchangeTokens, uint256 _durations) returns()

type MarketplaceTransactorRaw 

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

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

func (*MarketplaceTransactorRaw) Transact 

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

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

func (*MarketplaceTransactorRaw) Transfer 

func (_Marketplace *MarketplaceTransactorRaw) 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 MarketplaceTransactorSession 

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

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

func (*MarketplaceTransactorSession) CancelAuction 

func (_Marketplace *MarketplaceTransactorSession) CancelAuction(_listingIndex *big.Int) (*types.Transaction, error)

CancelAuction is a paid mutator transaction binding the contract method 0x96b5a755.

Solidity: function cancelAuction(uint256 _listingIndex) returns()

func (*MarketplaceTransactorSession) CreateAuction 

func (_Marketplace *MarketplaceTransactorSession) CreateAuction(_tokenTypes uint8, _tokenAddresses common.Address, _tokenNumbers *big.Int, _startingPrices *big.Int, _endingPrices *big.Int, _exchangeTokens common.Address, _durations *big.Int) (*types.Transaction, error)

CreateAuction is a paid mutator transaction binding the contract method 0x5c1f8e16.

Solidity: function createAuction(uint8 _tokenTypes, address _tokenAddresses, uint256 _tokenNumbers, uint256 _startingPrices, uint256 _endingPrices, address _exchangeTokens, uint256 _durations) returns()

type RoninBalance 

type RoninBalance struct {
	RoninBalanceCaller     // Read-only binding to the contract
	RoninBalanceTransactor // Write-only binding to the contract
	RoninBalanceFilterer   // Log filterer for contract events
}

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

func NewRoninBalance 

func NewRoninBalance(address common.Address, backend bind.ContractBackend) (*RoninBalance, error)

NewRoninBalance creates a new instance of RoninBalance, bound to a specific deployed contract.

type RoninBalanceCaller 

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

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

func NewRoninBalanceCaller 

func NewRoninBalanceCaller(address common.Address, caller bind.ContractCaller) (*RoninBalanceCaller, error)

NewRoninBalanceCaller creates a new read-only instance of RoninBalance, bound to a specific deployed contract.

func (*RoninBalanceCaller) BalanceOf 

func (_RoninBalance *RoninBalanceCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

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

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

type RoninBalanceCallerRaw 

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

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

func (*RoninBalanceCallerRaw) Call 

func (_RoninBalance *RoninBalanceCallerRaw) 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 RoninBalanceCallerSession 

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

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

func (*RoninBalanceCallerSession) BalanceOf 

func (_RoninBalance *RoninBalanceCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error)

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

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

type RoninBalanceFilterer 

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

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

func NewRoninBalanceFilterer 

func NewRoninBalanceFilterer(address common.Address, filterer bind.ContractFilterer) (*RoninBalanceFilterer, error)

NewRoninBalanceFilterer creates a new log filterer instance of RoninBalance, bound to a specific deployed contract.

type RoninBalanceRaw 

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

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

func (*RoninBalanceRaw) Call 

func (_RoninBalance *RoninBalanceRaw) 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 (*RoninBalanceRaw) Transact 

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

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

func (*RoninBalanceRaw) Transfer 

func (_RoninBalance *RoninBalanceRaw) 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 RoninBalanceSession 

type RoninBalanceSession struct {
	Contract     *RoninBalance     // 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
}

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

func (*RoninBalanceSession) BalanceOf 

func (_RoninBalance *RoninBalanceSession) BalanceOf(arg0 common.Address) (*big.Int, error)

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

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

type RoninBalanceTransactor 

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

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

func NewRoninBalanceTransactor 

func NewRoninBalanceTransactor(address common.Address, transactor bind.ContractTransactor) (*RoninBalanceTransactor, error)

NewRoninBalanceTransactor creates a new write-only instance of RoninBalance, bound to a specific deployed contract.

type RoninBalanceTransactorRaw 

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

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

func (*RoninBalanceTransactorRaw) Transact 

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

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

func (*RoninBalanceTransactorRaw) Transfer 

func (_RoninBalance *RoninBalanceTransactorRaw) 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 RoninBalanceTransactorSession 

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

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

type Slp 

type Slp struct {
	SlpCaller     // Read-only binding to the contract
	SlpTransactor // Write-only binding to the contract
	SlpFilterer   // Log filterer for contract events
}

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

func NewSlp 

func NewSlp(address common.Address, backend bind.ContractBackend) (*Slp, error)

NewSlp creates a new instance of Slp, bound to a specific deployed contract.

type SlpCaller 

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

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

func NewSlpCaller 

func NewSlpCaller(address common.Address, caller bind.ContractCaller) (*SlpCaller, error)

NewSlpCaller creates a new read-only instance of Slp, bound to a specific deployed contract.

func (*SlpCaller) BalanceOf 

func (_Slp *SlpCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

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

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

type SlpCallerRaw 

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

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

func (*SlpCallerRaw) Call 

func (_Slp *SlpCallerRaw) 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 SlpCallerSession 

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

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

func (*SlpCallerSession) BalanceOf 

func (_Slp *SlpCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error)

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

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

type SlpFilterer 

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

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

func NewSlpFilterer 

func NewSlpFilterer(address common.Address, filterer bind.ContractFilterer) (*SlpFilterer, error)

NewSlpFilterer creates a new log filterer instance of Slp, bound to a specific deployed contract.

type SlpRaw 

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

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

func (*SlpRaw) Call 

func (_Slp *SlpRaw) 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 (*SlpRaw) Transact 

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

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

func (*SlpRaw) Transfer 

func (_Slp *SlpRaw) 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 SlpSession 

type SlpSession struct {
	Contract     *Slp              // 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
}

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

func (*SlpSession) BalanceOf 

func (_Slp *SlpSession) BalanceOf(arg0 common.Address) (*big.Int, error)

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

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

func (*SlpSession) Checkpoint 

func (_Slp *SlpSession) Checkpoint(_owner common.Address, _amount *big.Int, _createdAt *big.Int, _signature []byte) (*types.Transaction, error)

Checkpoint is a paid mutator transaction binding the contract method 0xd3392ddf.

Solidity: function checkpoint(address _owner, uint256 _amount, uint256 _createdAt, bytes _signature) returns(uint256 _balance)

func (*SlpSession) Transfer 

func (_Slp *SlpSession) Transfer(_to common.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 _success)

type SlpTransactor 

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

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

func NewSlpTransactor 

func NewSlpTransactor(address common.Address, transactor bind.ContractTransactor) (*SlpTransactor, error)

NewSlpTransactor creates a new write-only instance of Slp, bound to a specific deployed contract.

func (*SlpTransactor) Checkpoint 

func (_Slp *SlpTransactor) Checkpoint(opts *bind.TransactOpts, _owner common.Address, _amount *big.Int, _createdAt *big.Int, _signature []byte) (*types.Transaction, error)

Checkpoint is a paid mutator transaction binding the contract method 0xd3392ddf.

Solidity: function checkpoint(address _owner, uint256 _amount, uint256 _createdAt, bytes _signature) returns(uint256 _balance)

func (*SlpTransactor) Transfer 

func (_Slp *SlpTransactor) Transfer(opts *bind.TransactOpts, _to common.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 _success)

type SlpTransactorRaw 

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

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

func (*SlpTransactorRaw) Transact 

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

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

func (*SlpTransactorRaw) Transfer 

func (_Slp *SlpTransactorRaw) 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 SlpTransactorSession 

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

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

func (*SlpTransactorSession) Checkpoint 

func (_Slp *SlpTransactorSession) Checkpoint(_owner common.Address, _amount *big.Int, _createdAt *big.Int, _signature []byte) (*types.Transaction, error)

Checkpoint is a paid mutator transaction binding the contract method 0xd3392ddf.

Solidity: function checkpoint(address _owner, uint256 _amount, uint256 _createdAt, bytes _signature) returns(uint256 _balance)

func (*SlpTransactorSession) Transfer 

func (_Slp *SlpTransactorSession) Transfer(_to common.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 _success)

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.