item

package
v0.0.9 Latest Latest
Warning

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

 Go to latest Published: Nov 7, 2021 License: GPL-3.0, GPL-3.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const CountersABI = "[]"

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

View Source 
const CountersBin = `` /* 242-byte string literal not displayed */

CountersBin is the compiled bytecode used for deploying new contracts.

View Source 
const EnumerableMapABI = "[]"

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

View Source 
const EnumerableMapBin = `` /* 242-byte string literal not displayed */

EnumerableMapBin is the compiled bytecode used for deploying new contracts.

View Source 
const EnumerableSetABI = "[]"

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

View Source 
const EnumerableSetBin = `` /* 242-byte string literal not displayed */

EnumerableSetBin is the compiled bytecode used for deploying new contracts.

View Source 
const ItemContractABI = "" /* 3460-byte string literal not displayed */

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

View Source 
const ItemContractBin = `` /* 10788-byte string literal not displayed */

ItemContractBin is the compiled bytecode used for deploying new contracts.

View Source 
const SafeMathABI = "[]"

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

View Source 
const SafeMathBin = `` /* 242-byte string literal not displayed */

SafeMathBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type Counters 

type Counters struct {
	CountersCaller     // Read-only binding to the contract
	CountersTransactor // Write-only binding to the contract
	CountersFilterer   // Log filterer for contract events
}

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

func DeployCounters 

func DeployCounters(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Counters, error)

DeployCounters deploys a new Ethereum contract, binding an instance of Counters to it.

func NewCounters 

func NewCounters(address common.Address, backend bind.ContractBackend) (*Counters, error)

NewCounters creates a new instance of Counters, bound to a specific deployed contract.

type CountersCaller 

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

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

func NewCountersCaller 

func NewCountersCaller(address common.Address, caller bind.ContractCaller) (*CountersCaller, error)

NewCountersCaller creates a new read-only instance of Counters, bound to a specific deployed contract.

type CountersCallerRaw 

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

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

func (*CountersCallerRaw) Call 

func (_Counters *CountersCallerRaw) 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 CountersCallerSession 

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

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

type CountersFilterer 

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

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

func NewCountersFilterer 

func NewCountersFilterer(address common.Address, filterer bind.ContractFilterer) (*CountersFilterer, error)

NewCountersFilterer creates a new log filterer instance of Counters, bound to a specific deployed contract.

type CountersRaw 

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

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

func (*CountersRaw) Call 

func (_Counters *CountersRaw) 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 (*CountersRaw) Transact 

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

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

func (*CountersRaw) Transfer 

func (_Counters *CountersRaw) 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 CountersSession 

type CountersSession struct {
	Contract     *Counters         // 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
}

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

type CountersTransactor 

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

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

func NewCountersTransactor 

func NewCountersTransactor(address common.Address, transactor bind.ContractTransactor) (*CountersTransactor, error)

NewCountersTransactor creates a new write-only instance of Counters, bound to a specific deployed contract.

type CountersTransactorRaw 

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

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

func (*CountersTransactorRaw) Transact 

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

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

func (*CountersTransactorRaw) Transfer 

func (_Counters *CountersTransactorRaw) 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 CountersTransactorSession 

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

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

type EnumerableMap 

type EnumerableMap struct {
	EnumerableMapCaller     // Read-only binding to the contract
	EnumerableMapTransactor // Write-only binding to the contract
	EnumerableMapFilterer   // Log filterer for contract events
}

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

func DeployEnumerableMap 

func DeployEnumerableMap(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EnumerableMap, error)

DeployEnumerableMap deploys a new Ethereum contract, binding an instance of EnumerableMap to it.

func NewEnumerableMap 

func NewEnumerableMap(address common.Address, backend bind.ContractBackend) (*EnumerableMap, error)

NewEnumerableMap creates a new instance of EnumerableMap, bound to a specific deployed contract.

type EnumerableMapCaller 

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

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

func NewEnumerableMapCaller 

func NewEnumerableMapCaller(address common.Address, caller bind.ContractCaller) (*EnumerableMapCaller, error)

NewEnumerableMapCaller creates a new read-only instance of EnumerableMap, bound to a specific deployed contract.

type EnumerableMapCallerRaw 

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

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

func (*EnumerableMapCallerRaw) Call 

func (_EnumerableMap *EnumerableMapCallerRaw) 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 EnumerableMapCallerSession 

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

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

type EnumerableMapFilterer 

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

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

func NewEnumerableMapFilterer 

func NewEnumerableMapFilterer(address common.Address, filterer bind.ContractFilterer) (*EnumerableMapFilterer, error)

NewEnumerableMapFilterer creates a new log filterer instance of EnumerableMap, bound to a specific deployed contract.

type EnumerableMapRaw 

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

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

func (*EnumerableMapRaw) Call 

func (_EnumerableMap *EnumerableMapRaw) 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 (*EnumerableMapRaw) Transact 

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

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

func (*EnumerableMapRaw) Transfer 

func (_EnumerableMap *EnumerableMapRaw) 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 EnumerableMapSession 

type EnumerableMapSession struct {
	Contract     *EnumerableMap    // 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
}

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

type EnumerableMapTransactor 

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

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

func NewEnumerableMapTransactor 

func NewEnumerableMapTransactor(address common.Address, transactor bind.ContractTransactor) (*EnumerableMapTransactor, error)

NewEnumerableMapTransactor creates a new write-only instance of EnumerableMap, bound to a specific deployed contract.

type EnumerableMapTransactorRaw 

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

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

func (*EnumerableMapTransactorRaw) Transact 

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

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

func (*EnumerableMapTransactorRaw) Transfer 

func (_EnumerableMap *EnumerableMapTransactorRaw) 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 EnumerableMapTransactorSession 

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

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

type EnumerableSet 

type EnumerableSet struct {
	EnumerableSetCaller     // Read-only binding to the contract
	EnumerableSetTransactor // Write-only binding to the contract
	EnumerableSetFilterer   // Log filterer for contract events
}

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

func DeployEnumerableSet 

func DeployEnumerableSet(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EnumerableSet, error)

DeployEnumerableSet deploys a new Ethereum contract, binding an instance of EnumerableSet to it.

func NewEnumerableSet 

func NewEnumerableSet(address common.Address, backend bind.ContractBackend) (*EnumerableSet, error)

NewEnumerableSet creates a new instance of EnumerableSet, bound to a specific deployed contract.

type EnumerableSetCaller 

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

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

func NewEnumerableSetCaller 

func NewEnumerableSetCaller(address common.Address, caller bind.ContractCaller) (*EnumerableSetCaller, error)

NewEnumerableSetCaller creates a new read-only instance of EnumerableSet, bound to a specific deployed contract.

type EnumerableSetCallerRaw 

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

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

func (*EnumerableSetCallerRaw) Call 

func (_EnumerableSet *EnumerableSetCallerRaw) 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 EnumerableSetCallerSession 

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

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

type EnumerableSetFilterer 

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

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

func NewEnumerableSetFilterer 

func NewEnumerableSetFilterer(address common.Address, filterer bind.ContractFilterer) (*EnumerableSetFilterer, error)

NewEnumerableSetFilterer creates a new log filterer instance of EnumerableSet, bound to a specific deployed contract.

type EnumerableSetRaw 

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

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

func (*EnumerableSetRaw) Call 

func (_EnumerableSet *EnumerableSetRaw) 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 (*EnumerableSetRaw) Transact 

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

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

func (*EnumerableSetRaw) Transfer 

func (_EnumerableSet *EnumerableSetRaw) 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 EnumerableSetSession 

type EnumerableSetSession struct {
	Contract     *EnumerableSet    // 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
}

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

type EnumerableSetTransactor 

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

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

func NewEnumerableSetTransactor 

func NewEnumerableSetTransactor(address common.Address, transactor bind.ContractTransactor) (*EnumerableSetTransactor, error)

NewEnumerableSetTransactor creates a new write-only instance of EnumerableSet, bound to a specific deployed contract.

type EnumerableSetTransactorRaw 

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

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

func (*EnumerableSetTransactorRaw) Transact 

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

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

func (*EnumerableSetTransactorRaw) Transfer 

func (_EnumerableSet *EnumerableSetTransactorRaw) 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 EnumerableSetTransactorSession 

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

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

type ItemContract 

type ItemContract struct {
	ItemContractCaller     // Read-only binding to the contract
	ItemContractTransactor // Write-only binding to the contract
	ItemContractFilterer   // Log filterer for contract events
}

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

func DeployItemContract 

func DeployItemContract(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ItemContract, error)

DeployItemContract deploys a new Ethereum contract, binding an instance of ItemContract to it.

func NewItemContract 

func NewItemContract(address common.Address, backend bind.ContractBackend) (*ItemContract, error)

NewItemContract creates a new instance of ItemContract, bound to a specific deployed contract.

type ItemContractApproval 

type ItemContractApproval struct {
	From    common.Address
	To      common.Address
	TokenId *big.Int
	Dci     string
	Raw     types.Log // Blockchain specific contextual infos
}

ItemContractApproval represents a Approval event raised by the ItemContract contract.

type ItemContractApprovalIterator 

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

ItemContractApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ItemContract contract.

func (*ItemContractApprovalIterator) Close 

func (it *ItemContractApprovalIterator) Close() error

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

func (*ItemContractApprovalIterator) Error 

func (it *ItemContractApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ItemContractApprovalIterator) Next 

func (it *ItemContractApprovalIterator) 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 ItemContractCaller 

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

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

func NewItemContractCaller 

func NewItemContractCaller(address common.Address, caller bind.ContractCaller) (*ItemContractCaller, error)

NewItemContractCaller creates a new read-only instance of ItemContract, bound to a specific deployed contract.

func (*ItemContractCaller) GetApproved 

func (_ItemContract *ItemContractCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

GetApproved is a free data retrieval call binding the contract method 0x081812fc.

Solidity: function getApproved(tokenId uint256) constant returns(address)

func (*ItemContractCaller) GetCount 

func (_ItemContract *ItemContractCaller) GetCount(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

GetCount is a free data retrieval call binding the contract method 0x4f0cd27b.

Solidity: function getCount(owner address) constant returns(uint256)

func (*ItemContractCaller) GetCreator 

func (_ItemContract *ItemContractCaller) GetCreator(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

GetCreator is a free data retrieval call binding the contract method 0xd48e638a.

Solidity: function getCreator(tokenId uint256) constant returns(address)

func (*ItemContractCaller) GetDCI 

func (_ItemContract *ItemContractCaller) GetDCI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

GetDCI is a free data retrieval call binding the contract method 0xdb157339.

Solidity: function getDCI(tokenId uint256) constant returns(string)

func (*ItemContractCaller) GetName 

func (_ItemContract *ItemContractCaller) GetName(opts *bind.CallOpts, tokenId *big.Int) (string, error)

GetName is a free data retrieval call binding the contract method 0x6b8ff574.

Solidity: function getName(tokenId uint256) constant returns(string)

func (*ItemContractCaller) GetOwner 

func (_ItemContract *ItemContractCaller) GetOwner(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

GetOwner is a free data retrieval call binding the contract method 0xc41a360a.

Solidity: function getOwner(tokenId uint256) constant returns(address)

func (*ItemContractCaller) GetTokenId 

func (_ItemContract *ItemContractCaller) GetTokenId(opts *bind.CallOpts, dci string) (*big.Int, error)

GetTokenId is a free data retrieval call binding the contract method 0x1e7663bc.

Solidity: function getTokenId(dci string) constant returns(uint256)

func (*ItemContractCaller) GetTokenURI 

func (_ItemContract *ItemContractCaller) GetTokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

GetTokenURI is a free data retrieval call binding the contract method 0x3bb3a24d.

Solidity: function getTokenURI(tokenId uint256) constant returns(string)

type ItemContractCallerRaw 

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

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

func (*ItemContractCallerRaw) Call 

func (_ItemContract *ItemContractCallerRaw) 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 ItemContractCallerSession 

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

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

func (*ItemContractCallerSession) GetApproved 

func (_ItemContract *ItemContractCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

GetApproved is a free data retrieval call binding the contract method 0x081812fc.

Solidity: function getApproved(tokenId uint256) constant returns(address)

func (*ItemContractCallerSession) GetCount 

func (_ItemContract *ItemContractCallerSession) GetCount(owner common.Address) (*big.Int, error)

GetCount is a free data retrieval call binding the contract method 0x4f0cd27b.

Solidity: function getCount(owner address) constant returns(uint256)

func (*ItemContractCallerSession) GetCreator 

func (_ItemContract *ItemContractCallerSession) GetCreator(tokenId *big.Int) (common.Address, error)

GetCreator is a free data retrieval call binding the contract method 0xd48e638a.

Solidity: function getCreator(tokenId uint256) constant returns(address)

func (*ItemContractCallerSession) GetDCI 

func (_ItemContract *ItemContractCallerSession) GetDCI(tokenId *big.Int) (string, error)

GetDCI is a free data retrieval call binding the contract method 0xdb157339.

Solidity: function getDCI(tokenId uint256) constant returns(string)

func (*ItemContractCallerSession) GetName 

func (_ItemContract *ItemContractCallerSession) GetName(tokenId *big.Int) (string, error)

GetName is a free data retrieval call binding the contract method 0x6b8ff574.

Solidity: function getName(tokenId uint256) constant returns(string)

func (*ItemContractCallerSession) GetOwner 

func (_ItemContract *ItemContractCallerSession) GetOwner(tokenId *big.Int) (common.Address, error)

GetOwner is a free data retrieval call binding the contract method 0xc41a360a.

Solidity: function getOwner(tokenId uint256) constant returns(address)

func (*ItemContractCallerSession) GetTokenId 

func (_ItemContract *ItemContractCallerSession) GetTokenId(dci string) (*big.Int, error)

GetTokenId is a free data retrieval call binding the contract method 0x1e7663bc.

Solidity: function getTokenId(dci string) constant returns(uint256)

func (*ItemContractCallerSession) GetTokenURI 

func (_ItemContract *ItemContractCallerSession) GetTokenURI(tokenId *big.Int) (string, error)

GetTokenURI is a free data retrieval call binding the contract method 0x3bb3a24d.

Solidity: function getTokenURI(tokenId uint256) constant returns(string)

type ItemContractCreate 

type ItemContractCreate struct {
	From     common.Address
	TokenId  *big.Int
	Dci      string
	Name     string
	TokenURI string
	Raw      types.Log // Blockchain specific contextual infos
}

ItemContractCreate represents a Create event raised by the ItemContract contract.

type ItemContractCreateIterator 

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

ItemContractCreateIterator is returned from FilterCreate and is used to iterate over the raw logs and unpacked data for Create events raised by the ItemContract contract.

func (*ItemContractCreateIterator) Close 

func (it *ItemContractCreateIterator) Close() error

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

func (*ItemContractCreateIterator) Error 

func (it *ItemContractCreateIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ItemContractCreateIterator) Next 

func (it *ItemContractCreateIterator) 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 ItemContractFilterer 

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

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

func NewItemContractFilterer 

func NewItemContractFilterer(address common.Address, filterer bind.ContractFilterer) (*ItemContractFilterer, error)

NewItemContractFilterer creates a new log filterer instance of ItemContract, bound to a specific deployed contract.

func (*ItemContractFilterer) FilterApproval 

func (_ItemContract *ItemContractFilterer) FilterApproval(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*ItemContractApprovalIterator, error)

FilterApproval is a free log retrieval operation binding the contract event 0xfa07013316165a7c424e6be19a166ba4784477c405b341b4bb535985391e7baa.

Solidity: e Approval(from indexed address, to indexed address, tokenId indexed uint256, dci string)

func (*ItemContractFilterer) FilterCreate 

func (_ItemContract *ItemContractFilterer) FilterCreate(opts *bind.FilterOpts, from []common.Address, tokenId []*big.Int) (*ItemContractCreateIterator, error)

FilterCreate is a free log retrieval operation binding the contract event 0xefebf1e9cc6cf1906f62a4ed1545a6c54e027262b597e06b8e00abc4a3d8f501.

Solidity: e Create(from indexed address, tokenId indexed uint256, dci string, name string, tokenURI string)

func (*ItemContractFilterer) FilterTransfer 

func (_ItemContract *ItemContractFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*ItemContractTransferIterator, error)

FilterTransfer is a free log retrieval operation binding the contract event 0xcd6e659e4c2e75c3bfe47fecaccf39aeb368116a0ee52afb532e07f6cba6c0d1.

Solidity: e Transfer(from indexed address, to indexed address, tokenId indexed uint256, dci string)

func (*ItemContractFilterer) WatchApproval 

func (_ItemContract *ItemContractFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ItemContractApproval, from []common.Address, to []common.Address, tokenId []*big.Int) (event.Subscription, error)

WatchApproval is a free log subscription operation binding the contract event 0xfa07013316165a7c424e6be19a166ba4784477c405b341b4bb535985391e7baa.

Solidity: e Approval(from indexed address, to indexed address, tokenId indexed uint256, dci string)

func (*ItemContractFilterer) WatchCreate 

func (_ItemContract *ItemContractFilterer) WatchCreate(opts *bind.WatchOpts, sink chan<- *ItemContractCreate, from []common.Address, tokenId []*big.Int) (event.Subscription, error)

WatchCreate is a free log subscription operation binding the contract event 0xefebf1e9cc6cf1906f62a4ed1545a6c54e027262b597e06b8e00abc4a3d8f501.

Solidity: e Create(from indexed address, tokenId indexed uint256, dci string, name string, tokenURI string)

func (*ItemContractFilterer) WatchTransfer 

func (_ItemContract *ItemContractFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ItemContractTransfer, from []common.Address, to []common.Address, tokenId []*big.Int) (event.Subscription, error)

WatchTransfer is a free log subscription operation binding the contract event 0xcd6e659e4c2e75c3bfe47fecaccf39aeb368116a0ee52afb532e07f6cba6c0d1.

Solidity: e Transfer(from indexed address, to indexed address, tokenId indexed uint256, dci string)

type ItemContractRaw 

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

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

func (*ItemContractRaw) Call 

func (_ItemContract *ItemContractRaw) 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 (*ItemContractRaw) Transact 

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

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

func (*ItemContractRaw) Transfer 

func (_ItemContract *ItemContractRaw) 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 ItemContractSession 

type ItemContractSession struct {
	Contract     *ItemContract     // 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
}

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

func (*ItemContractSession) Approve 

func (_ItemContract *ItemContractSession) Approve(tokenId *big.Int, to common.Address) (*types.Transaction, error)

Approve is a paid mutator transaction binding the contract method 0xfebe4909.

Solidity: function approve(tokenId uint256, to address) returns()

func (*ItemContractSession) Create 

func (_ItemContract *ItemContractSession) Create(dci string, name string, tokenURI string) (*types.Transaction, error)

Create is a paid mutator transaction binding the contract method 0x5d28560a.

Solidity: function create(dci string, name string, tokenURI string) returns()

func (*ItemContractSession) GetApproved 

func (_ItemContract *ItemContractSession) GetApproved(tokenId *big.Int) (common.Address, error)

GetApproved is a free data retrieval call binding the contract method 0x081812fc.

Solidity: function getApproved(tokenId uint256) constant returns(address)

func (*ItemContractSession) GetCount 

func (_ItemContract *ItemContractSession) GetCount(owner common.Address) (*big.Int, error)

GetCount is a free data retrieval call binding the contract method 0x4f0cd27b.

Solidity: function getCount(owner address) constant returns(uint256)

func (*ItemContractSession) GetCreator 

func (_ItemContract *ItemContractSession) GetCreator(tokenId *big.Int) (common.Address, error)

GetCreator is a free data retrieval call binding the contract method 0xd48e638a.

Solidity: function getCreator(tokenId uint256) constant returns(address)

func (*ItemContractSession) GetDCI 

func (_ItemContract *ItemContractSession) GetDCI(tokenId *big.Int) (string, error)

GetDCI is a free data retrieval call binding the contract method 0xdb157339.

Solidity: function getDCI(tokenId uint256) constant returns(string)

func (*ItemContractSession) GetName 

func (_ItemContract *ItemContractSession) GetName(tokenId *big.Int) (string, error)

GetName is a free data retrieval call binding the contract method 0x6b8ff574.

Solidity: function getName(tokenId uint256) constant returns(string)

func (*ItemContractSession) GetOwner 

func (_ItemContract *ItemContractSession) GetOwner(tokenId *big.Int) (common.Address, error)

GetOwner is a free data retrieval call binding the contract method 0xc41a360a.

Solidity: function getOwner(tokenId uint256) constant returns(address)

func (*ItemContractSession) GetTokenId 

func (_ItemContract *ItemContractSession) GetTokenId(dci string) (*big.Int, error)

GetTokenId is a free data retrieval call binding the contract method 0x1e7663bc.

Solidity: function getTokenId(dci string) constant returns(uint256)

func (*ItemContractSession) GetTokenURI 

func (_ItemContract *ItemContractSession) GetTokenURI(tokenId *big.Int) (string, error)

GetTokenURI is a free data retrieval call binding the contract method 0x3bb3a24d.

Solidity: function getTokenURI(tokenId uint256) constant returns(string)

func (*ItemContractSession) Transfer 

func (_ItemContract *ItemContractSession) Transfer(tokenId *big.Int, to common.Address) (*types.Transaction, error)

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

Solidity: function transfer(tokenId uint256, to address) returns()

type ItemContractTransactor 

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

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

func NewItemContractTransactor 

func NewItemContractTransactor(address common.Address, transactor bind.ContractTransactor) (*ItemContractTransactor, error)

NewItemContractTransactor creates a new write-only instance of ItemContract, bound to a specific deployed contract.

func (*ItemContractTransactor) Approve 

func (_ItemContract *ItemContractTransactor) Approve(opts *bind.TransactOpts, tokenId *big.Int, to common.Address) (*types.Transaction, error)

Approve is a paid mutator transaction binding the contract method 0xfebe4909.

Solidity: function approve(tokenId uint256, to address) returns()

func (*ItemContractTransactor) Create 

func (_ItemContract *ItemContractTransactor) Create(opts *bind.TransactOpts, dci string, name string, tokenURI string) (*types.Transaction, error)

Create is a paid mutator transaction binding the contract method 0x5d28560a.

Solidity: function create(dci string, name string, tokenURI string) returns()

func (*ItemContractTransactor) Transfer 

func (_ItemContract *ItemContractTransactor) Transfer(opts *bind.TransactOpts, tokenId *big.Int, to common.Address) (*types.Transaction, error)

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

Solidity: function transfer(tokenId uint256, to address) returns()

type ItemContractTransactorRaw 

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

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

func (*ItemContractTransactorRaw) Transact 

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

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

func (*ItemContractTransactorRaw) Transfer 

func (_ItemContract *ItemContractTransactorRaw) 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 ItemContractTransactorSession 

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

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

func (*ItemContractTransactorSession) Approve 

func (_ItemContract *ItemContractTransactorSession) Approve(tokenId *big.Int, to common.Address) (*types.Transaction, error)

Approve is a paid mutator transaction binding the contract method 0xfebe4909.

Solidity: function approve(tokenId uint256, to address) returns()

func (*ItemContractTransactorSession) Create 

func (_ItemContract *ItemContractTransactorSession) Create(dci string, name string, tokenURI string) (*types.Transaction, error)

Create is a paid mutator transaction binding the contract method 0x5d28560a.

Solidity: function create(dci string, name string, tokenURI string) returns()

func (*ItemContractTransactorSession) Transfer 

func (_ItemContract *ItemContractTransactorSession) Transfer(tokenId *big.Int, to common.Address) (*types.Transaction, error)

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

Solidity: function transfer(tokenId uint256, to address) returns()

type ItemContractTransfer 

type ItemContractTransfer struct {
	From    common.Address
	To      common.Address
	TokenId *big.Int
	Dci     string
	Raw     types.Log // Blockchain specific contextual infos
}

ItemContractTransfer represents a Transfer event raised by the ItemContract contract.

type ItemContractTransferIterator 

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

ItemContractTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ItemContract contract.

func (*ItemContractTransferIterator) Close 

func (it *ItemContractTransferIterator) Close() error

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

func (*ItemContractTransferIterator) Error 

func (it *ItemContractTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ItemContractTransferIterator) Next 

func (it *ItemContractTransferIterator) 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 SafeMath 

type SafeMath struct {
	SafeMathCaller     // Read-only binding to the contract
	SafeMathTransactor // Write-only binding to the contract
	SafeMathFilterer   // Log filterer for contract events
}

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

func DeploySafeMath 

func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error)

DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it.

func NewSafeMath 

func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error)

NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract.

type SafeMathCaller 

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

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

func NewSafeMathCaller 

func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error)

NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathCallerRaw 

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

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

func (*SafeMathCallerRaw) Call 

func (_SafeMath *SafeMathCallerRaw) 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 SafeMathCallerSession 

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

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

type SafeMathFilterer 

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

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

func NewSafeMathFilterer 

func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error)

NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract.

type SafeMathRaw 

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

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

func (*SafeMathRaw) Call 

func (_SafeMath *SafeMathRaw) 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 (*SafeMathRaw) Transact 

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

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

func (*SafeMathRaw) Transfer 

func (_SafeMath *SafeMathRaw) 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 SafeMathSession 

type SafeMathSession struct {
	Contract     *SafeMath         // 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
}

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

type SafeMathTransactor 

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

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

func NewSafeMathTransactor 

func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error)

NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathTransactorRaw 

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

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

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

func (_SafeMath *SafeMathTransactorRaw) 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 SafeMathTransactorSession 

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

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

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.