scnft

package

Go to main page

Versions in this module

v1

v1.12.1

Feb 1, 2024

v1.12.1-rc.2

Jan 31, 2024

v1.12.1-rc.1

Jan 19, 2024

v1.12.0

Dec 11, 2023

Changes in this version

+ var AddressMetaData = &bind.MetaData

+ var CountersMetaData = &bind.MetaData

+ var ERC165MetaData = &bind.MetaData

+ var ERC721BurnableMetaData = &bind.MetaData

+ var ERC721EnumerableMetaData = &bind.MetaData

+ var ERC721FullMetaData = &bind.MetaData

+ var ERC721MetaData = &bind.MetaData

+ var ERC721MetadataMetaData = &bind.MetaData

+ var ERC721MetadataMintableMetaData = &bind.MetaData

+ var ERC721ServiceChainMetaData = &bind.MetaData

+ var IERC165MetaData = &bind.MetaData

+ var IERC721BridgeReceiverMetaData = &bind.MetaData

+ var IERC721EnumerableMetaData = &bind.MetaData

+ var IERC721MetaData = &bind.MetaData

+ var IERC721MetadataMetaData = &bind.MetaData

+ var IERC721ReceiverMetaData = &bind.MetaData

+ var MinterRoleMetaData = &bind.MetaData

+ var OwnableMetaData = &bind.MetaData

+ var RolesMetaData = &bind.MetaData

+ var SafeMathMetaData = &bind.MetaData

+ var ServiceChainNFTMetaData = &bind.MetaData

v1.12.0-rc.10

Dec 17, 2023

v1.12.0-rc.3

Dec 8, 2023

v1.12.0-rc.2

Dec 5, 2023

v1.12.0-rc.1

Nov 21, 2023

v1.11.1

Sep 12, 2023

v1.11.1-rc.1

Sep 11, 2023

v1.11.0

Aug 14, 2023

v1.11.0-rc.4

Aug 11, 2023

v1.11.0-rc.3

Aug 10, 2023

v1.11.0-rc.2

Aug 8, 2023

v1.11.0-rc.1

Jul 27, 2023

v1.10.2

Mar 17, 2023

v1.10.2-rc.4

Mar 17, 2023

v1.10.2-rc.3

Feb 28, 2023

v1.10.2-rc.2

Feb 27, 2023

v1.10.2-rc.1

Feb 27, 2023

v1.10.1

Jan 6, 2023

v1.10.1-rc.1

Jan 6, 2023

v1.10.0

Dec 27, 2022

v1.10.0-rc.6

Dec 27, 2022

v1.10.0-rc.5

Dec 19, 2022

v1.10.0-rc.4

Dec 6, 2022

v1.10.0-rc.3

Nov 29, 2022

v1.10.0-rc.2

Nov 23, 2022

v1.10.0-rc.1

Nov 22, 2022

v1.9.1

Aug 19, 2022

v1.9.1-rc.1

Aug 18, 2022

v1.9.0

Jul 28, 2022

v1.9.0-rc.6

Jul 28, 2022

v1.9.0-rc.5

Jul 28, 2022

v1.9.0-rc.4

Jul 28, 2022

v1.9.0-rc.3

Jul 22, 2022

v1.9.0-rc.2

Jul 15, 2022

v1.9.0-rc.1

Jul 8, 2022

v1.8.4

May 20, 2022

Changes in this version

+ var ERC165FuncSigs = map[string]string

+ var ERC721BurnableFuncSigs = map[string]string

+ var ERC721EnumerableFuncSigs = map[string]string

+ var ERC721FullFuncSigs = map[string]string

+ var ERC721FuncSigs = map[string]string

+ var ERC721MetadataFuncSigs = map[string]string

+ var ERC721MetadataMintableFuncSigs = map[string]string

+ var ERC721ServiceChainFuncSigs = map[string]string

+ var IERC165FuncSigs = map[string]string

+ var IERC721BridgeReceiverFuncSigs = map[string]string

+ var IERC721EnumerableFuncSigs = map[string]string

+ var IERC721FuncSigs = map[string]string

+ var IERC721MetadataFuncSigs = map[string]string

+ var IERC721ReceiverFuncSigs = map[string]string

+ var MinterRoleFuncSigs = map[string]string

+ var OwnableFuncSigs = map[string]string

+ var ServiceChainNFTFuncSigs = map[string]string

type ERC721BurnableFilterer

+ func (_ERC721Burnable *ERC721BurnableFilterer) ParseApproval(log types.Log) (*ERC721BurnableApproval, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) ParseApprovalForAll(log types.Log) (*ERC721BurnableApprovalForAll, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) ParseTransfer(log types.Log) (*ERC721BurnableTransfer, error)

type ERC721BurnableSession

+ func (_ERC721Burnable *ERC721BurnableSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721BurnableTransactor

+ func (_ERC721Burnable *ERC721BurnableTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type ERC721BurnableTransactorSession

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721EnumerableFilterer

+ func (_ERC721Enumerable *ERC721EnumerableFilterer) ParseApproval(log types.Log) (*ERC721EnumerableApproval, error)

+ func (_ERC721Enumerable *ERC721EnumerableFilterer) ParseApprovalForAll(log types.Log) (*ERC721EnumerableApprovalForAll, error)

+ func (_ERC721Enumerable *ERC721EnumerableFilterer) ParseTransfer(log types.Log) (*ERC721EnumerableTransfer, error)

type ERC721EnumerableSession

+ func (_ERC721Enumerable *ERC721EnumerableSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721EnumerableTransactor

+ func (_ERC721Enumerable *ERC721EnumerableTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type ERC721EnumerableTransactorSession

+ func (_ERC721Enumerable *ERC721EnumerableTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721Filterer

+ func (_ERC721 *ERC721Filterer) ParseApproval(log types.Log) (*ERC721Approval, error)

+ func (_ERC721 *ERC721Filterer) ParseApprovalForAll(log types.Log) (*ERC721ApprovalForAll, error)

+ func (_ERC721 *ERC721Filterer) ParseTransfer(log types.Log) (*ERC721Transfer, error)

type ERC721FullFilterer

+ func (_ERC721Full *ERC721FullFilterer) ParseApproval(log types.Log) (*ERC721FullApproval, error)

+ func (_ERC721Full *ERC721FullFilterer) ParseApprovalForAll(log types.Log) (*ERC721FullApprovalForAll, error)

+ func (_ERC721Full *ERC721FullFilterer) ParseTransfer(log types.Log) (*ERC721FullTransfer, error)

type ERC721FullSession

+ func (_ERC721Full *ERC721FullSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721FullTransactor

+ func (_ERC721Full *ERC721FullTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type ERC721FullTransactorSession

+ func (_ERC721Full *ERC721FullTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721MetadataFilterer

+ func (_ERC721Metadata *ERC721MetadataFilterer) ParseApproval(log types.Log) (*ERC721MetadataApproval, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) ParseApprovalForAll(log types.Log) (*ERC721MetadataApprovalForAll, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) ParseTransfer(log types.Log) (*ERC721MetadataTransfer, error)

type ERC721MetadataMintableFilterer

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) ParseApproval(log types.Log) (*ERC721MetadataMintableApproval, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) ParseApprovalForAll(log types.Log) (*ERC721MetadataMintableApprovalForAll, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) ParseMinterAdded(log types.Log) (*ERC721MetadataMintableMinterAdded, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) ParseMinterRemoved(log types.Log) (*ERC721MetadataMintableMinterRemoved, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) ParseTransfer(log types.Log) (*ERC721MetadataMintableTransfer, error)

type ERC721MetadataMintableSession

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721MetadataMintableTransactor

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type ERC721MetadataMintableTransactorSession

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721MetadataSession

+ func (_ERC721Metadata *ERC721MetadataSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721MetadataTransactor

+ func (_ERC721Metadata *ERC721MetadataTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type ERC721MetadataTransactorSession

+ func (_ERC721Metadata *ERC721MetadataTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721ServiceChainFilterer

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) ParseApproval(log types.Log) (*ERC721ServiceChainApproval, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) ParseApprovalForAll(log types.Log) (*ERC721ServiceChainApprovalForAll, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) ParseOwnershipTransferred(log types.Log) (*ERC721ServiceChainOwnershipTransferred, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) ParseTransfer(log types.Log) (*ERC721ServiceChainTransfer, error)

type ERC721ServiceChainSession

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721ServiceChainTransactor

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type ERC721ServiceChainTransactorSession

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721Session

+ func (_ERC721 *ERC721Session) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ERC721Transactor

+ func (_ERC721 *ERC721Transactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type ERC721TransactorSession

+ func (_ERC721 *ERC721TransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type IERC721EnumerableFilterer

+ func (_IERC721Enumerable *IERC721EnumerableFilterer) ParseApproval(log types.Log) (*IERC721EnumerableApproval, error)

+ func (_IERC721Enumerable *IERC721EnumerableFilterer) ParseApprovalForAll(log types.Log) (*IERC721EnumerableApprovalForAll, error)

+ func (_IERC721Enumerable *IERC721EnumerableFilterer) ParseTransfer(log types.Log) (*IERC721EnumerableTransfer, error)

type IERC721EnumerableSession

+ func (_IERC721Enumerable *IERC721EnumerableSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

type IERC721EnumerableTransactor

+ func (_IERC721Enumerable *IERC721EnumerableTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type IERC721EnumerableTransactorSession

+ func (_IERC721Enumerable *IERC721EnumerableTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

type IERC721Filterer

+ func (_IERC721 *IERC721Filterer) ParseApproval(log types.Log) (*IERC721Approval, error)

+ func (_IERC721 *IERC721Filterer) ParseApprovalForAll(log types.Log) (*IERC721ApprovalForAll, error)

+ func (_IERC721 *IERC721Filterer) ParseTransfer(log types.Log) (*IERC721Transfer, error)

type IERC721MetadataFilterer

+ func (_IERC721Metadata *IERC721MetadataFilterer) ParseApproval(log types.Log) (*IERC721MetadataApproval, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) ParseApprovalForAll(log types.Log) (*IERC721MetadataApprovalForAll, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) ParseTransfer(log types.Log) (*IERC721MetadataTransfer, error)

type IERC721MetadataSession

+ func (_IERC721Metadata *IERC721MetadataSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

type IERC721MetadataTransactor

+ func (_IERC721Metadata *IERC721MetadataTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type IERC721MetadataTransactorSession

+ func (_IERC721Metadata *IERC721MetadataTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

type IERC721Session

+ func (_IERC721 *IERC721Session) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

type IERC721Transactor

+ func (_IERC721 *IERC721Transactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type IERC721TransactorSession

+ func (_IERC721 *IERC721TransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

type MinterRoleFilterer

+ func (_MinterRole *MinterRoleFilterer) ParseMinterAdded(log types.Log) (*MinterRoleMinterAdded, error)

+ func (_MinterRole *MinterRoleFilterer) ParseMinterRemoved(log types.Log) (*MinterRoleMinterRemoved, error)

type OwnableFilterer

+ func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error)

type ServiceChainNFTFilterer

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) ParseApproval(log types.Log) (*ServiceChainNFTApproval, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) ParseApprovalForAll(log types.Log) (*ServiceChainNFTApprovalForAll, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) ParseMinterAdded(log types.Log) (*ServiceChainNFTMinterAdded, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) ParseMinterRemoved(log types.Log) (*ServiceChainNFTMinterRemoved, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) ParseOwnershipTransferred(log types.Log) (*ServiceChainNFTOwnershipTransferred, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) ParseTransfer(log types.Log) (*ServiceChainNFTTransfer, error)

type ServiceChainNFTSession

+ func (_ServiceChainNFT *ServiceChainNFTSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

type ServiceChainNFTTransactor

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

type ServiceChainNFTTransactorSession

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

v1.8.4-rc.3

May 19, 2022

v1.8.4-rc.2

May 18, 2022

v1.8.4-rc.1

May 13, 2022

v1.8.3

Apr 27, 2022

v1.8.3-rc.4

Apr 26, 2022

v1.8.3-rc.3

Apr 26, 2022

v1.8.3-rc.2

Apr 24, 2022

v1.8.3-rc.1

Apr 19, 2022

v1.8.2

Mar 23, 2022

v1.8.2-rc.2

Mar 23, 2022

v1.8.2-rc.1

Mar 22, 2022

v1.8.1

Mar 18, 2022

v1.8.1-rc.1

Mar 18, 2022

v1.8.0

Mar 16, 2022

v1.8.0-rc.4

Mar 11, 2022

v1.8.0-rc.3

Mar 4, 2022

v1.8.0-rc.2

Feb 22, 2022

v1.8.0-rc.1

Feb 15, 2022

v1.7.3

Dec 27, 2021

v1.7.3-rc.2

Dec 27, 2021

v1.7.3-rc.1

Dec 17, 2021

v1.7.2

Dec 7, 2021

v1.7.2-rc.1

Dec 2, 2021

v1.7.1

Nov 16, 2021

v1.7.1-rc.1

Nov 16, 2021

v1.7.0

Oct 19, 2021

v1.7.0-rc.4

Oct 5, 2021

v1.7.0-rc.3

Oct 1, 2021

v1.7.0-rc.2

Sep 15, 2021

v1.7.0-rc.1

Jul 22, 2021

v1.6.4

Oct 1, 2021

v1.6.4-rc.1

Sep 30, 2021

v1.6.3

Jul 1, 2021

v1.6.3-rc.1

Jul 1, 2021

v1.6.2

May 18, 2021

v1.6.2-rc.3

May 17, 2021

v1.6.2-rc.2

May 17, 2021

v1.6.2-rc.1

May 13, 2021

v1.6.1

Apr 26, 2021

v1.6.1-rc.2

Apr 5, 2021

v1.6.1-rc.1

Mar 17, 2021

v1.6.0

Feb 16, 2021

v1.6.0-rc.4

Feb 18, 2021

v1.6.0-rc.3

Feb 1, 2021

v1.6.0-rc.2

Jan 27, 2021

v1.6.0-rc.1

Jan 25, 2021

v1.5.3

Oct 28, 2020

v1.5.3-rc.2

Oct 27, 2020

v1.5.3-rc.1

Oct 12, 2020

v1.5.2

Sep 22, 2020

v1.5.2-rc.4

Sep 22, 2020

v1.5.2-rc.3

Sep 22, 2020

v1.5.2-rc.2

Sep 2, 2020

v1.5.2-rc.1

Aug 19, 2020

v1.5.1

Aug 11, 2020

v1.5.1-rc.1

Aug 10, 2020

v1.5.0

Jul 8, 2020

v1.5.0-rc.2

Jun 30, 2020

v1.5.0-rc.1

Jun 25, 2020

v1.5.0-anchoring

Jul 9, 2020

v1.4.2

Apr 8, 2020

v1.4.2-rc.1

Apr 7, 2020

v1.4.1

Apr 1, 2020

v1.4.1-rc.1

Apr 1, 2020

v1.4.0

Mar 26, 2020

v1.4.0-rc.2

Mar 26, 2020

v1.4.0-rc.1

Mar 26, 2020

v1.3.0

Dec 16, 2019

v1.3.0-rc.2

Dec 9, 2019

v1.3.0-rc.1

Dec 9, 2019

v1.2.0

Oct 21, 2019

v1.2.0-rc.1

Sep 17, 2019

v1.1.1

Aug 21, 2019

Changes in this version

+ const CountersABI

+ const CountersBin

+ const CountersBinRuntime

+ type Counters struct

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

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

+ type CountersCaller struct

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

+ type CountersCallerRaw struct

+ Contract *CountersCaller

+ func (_Counters *CountersCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type CountersCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *CountersCaller

+ type CountersFilterer struct

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

+ type CountersRaw struct

+ Contract *Counters

+ func (_Counters *CountersRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_Counters *CountersRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CountersSession struct

+ CallOpts bind.CallOpts

+ Contract *Counters

+ TransactOpts bind.TransactOpts

+ type CountersTransactor struct

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

+ type CountersTransactorRaw struct

+ Contract *CountersTransactor

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

+ func (_Counters *CountersTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CountersTransactorSession struct

+ Contract *CountersTransactor

+ TransactOpts bind.TransactOpts

v1.1.0

Aug 14, 2019

Changes in this version

+ const AddressABI

+ const AddressBin

+ const AddressBinRuntime

+ const ERC165ABI

+ const ERC165Bin

+ const ERC165BinRuntime

+ const ERC721ABI

+ const ERC721Bin

+ const ERC721BinRuntime

+ const ERC721BurnableABI

+ const ERC721BurnableBin

+ const ERC721BurnableBinRuntime

+ const ERC721EnumerableABI

+ const ERC721EnumerableBin

+ const ERC721EnumerableBinRuntime

+ const ERC721FullABI

+ const ERC721FullBin

+ const ERC721FullBinRuntime

+ const ERC721MetadataABI

+ const ERC721MetadataBin

+ const ERC721MetadataBinRuntime

+ const ERC721MetadataMintableABI

+ const ERC721MetadataMintableBin

+ const ERC721MetadataMintableBinRuntime

+ const ERC721ServiceChainABI

+ const ERC721ServiceChainBin

+ const ERC721ServiceChainBinRuntime

+ const IERC165ABI

+ const IERC165Bin

+ const IERC165BinRuntime

+ const IERC721ABI

+ const IERC721Bin

+ const IERC721BinRuntime

+ const IERC721BridgeReceiverABI

+ const IERC721BridgeReceiverBin

+ const IERC721BridgeReceiverBinRuntime

+ const IERC721EnumerableABI

+ const IERC721EnumerableBin

+ const IERC721EnumerableBinRuntime

+ const IERC721MetadataABI

+ const IERC721MetadataBin

+ const IERC721MetadataBinRuntime

+ const IERC721ReceiverABI

+ const IERC721ReceiverBin

+ const IERC721ReceiverBinRuntime

+ const MinterRoleABI

+ const MinterRoleBin

+ const MinterRoleBinRuntime

+ const OwnableABI

+ const OwnableBin

+ const OwnableBinRuntime

+ const RolesABI

+ const RolesBin

+ const RolesBinRuntime

+ const SafeMathABI

+ const SafeMathBin

+ const SafeMathBinRuntime

+ const ServiceChainNFTABI

+ const ServiceChainNFTBin

+ const ServiceChainNFTBinRuntime

+ type Address struct

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

+ func NewAddress(address common.Address, backend bind.ContractBackend) (*Address, error)

+ type AddressCaller struct

+ func NewAddressCaller(address common.Address, caller bind.ContractCaller) (*AddressCaller, error)

+ type AddressCallerRaw struct

+ Contract *AddressCaller

+ func (_Address *AddressCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type AddressCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AddressCaller

+ type AddressFilterer struct

+ func NewAddressFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressFilterer, error)

+ type AddressRaw struct

+ Contract *Address

+ func (_Address *AddressRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_Address *AddressRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Address *AddressRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressSession struct

+ CallOpts bind.CallOpts

+ Contract *Address

+ TransactOpts bind.TransactOpts

+ type AddressTransactor struct

+ func NewAddressTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressTransactor, error)

+ type AddressTransactorRaw struct

+ Contract *AddressTransactor

+ func (_Address *AddressTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Address *AddressTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressTransactorSession struct

+ Contract *AddressTransactor

+ TransactOpts bind.TransactOpts

+ type ERC165 struct

+ func DeployERC165(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC165, error)

+ func NewERC165(address common.Address, backend bind.ContractBackend) (*ERC165, error)

+ type ERC165Caller struct

+ func NewERC165Caller(address common.Address, caller bind.ContractCaller) (*ERC165Caller, error)

+ func (_ERC165 *ERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type ERC165CallerRaw struct

+ Contract *ERC165Caller

+ func (_ERC165 *ERC165CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC165CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC165Caller

+ func (_ERC165 *ERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type ERC165Filterer struct

+ func NewERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC165Filterer, error)

+ type ERC165Raw struct

+ Contract *ERC165

+ func (_ERC165 *ERC165Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ERC165 *ERC165Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC165 *ERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC165Session struct

+ CallOpts bind.CallOpts

+ Contract *ERC165

+ TransactOpts bind.TransactOpts

+ func (_ERC165 *ERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type ERC165Transactor struct

+ func NewERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC165Transactor, error)

+ type ERC165TransactorRaw struct

+ Contract *ERC165Transactor

+ func (_ERC165 *ERC165TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC165 *ERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC165TransactorSession struct

+ Contract *ERC165Transactor

+ TransactOpts bind.TransactOpts

+ type ERC721 struct

+ func DeployERC721(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC721, error)

+ func NewERC721(address common.Address, backend bind.ContractBackend) (*ERC721, error)

+ type ERC721Approval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721ApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721ApprovalForAllIterator struct

+ Event *ERC721ApprovalForAll

+ func (it *ERC721ApprovalForAllIterator) Close() error

+ func (it *ERC721ApprovalForAllIterator) Error() error

+ func (it *ERC721ApprovalForAllIterator) Next() bool

+ type ERC721ApprovalIterator struct

+ Event *ERC721Approval

+ func (it *ERC721ApprovalIterator) Close() error

+ func (it *ERC721ApprovalIterator) Error() error

+ func (it *ERC721ApprovalIterator) Next() bool

+ type ERC721Burnable struct

+ func DeployERC721Burnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC721Burnable, error)

+ func NewERC721Burnable(address common.Address, backend bind.ContractBackend) (*ERC721Burnable, error)

+ type ERC721BurnableApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721BurnableApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721BurnableApprovalForAllIterator struct

+ Event *ERC721BurnableApprovalForAll

+ func (it *ERC721BurnableApprovalForAllIterator) Close() error

+ func (it *ERC721BurnableApprovalForAllIterator) Error() error

+ func (it *ERC721BurnableApprovalForAllIterator) Next() bool

+ type ERC721BurnableApprovalIterator struct

+ Event *ERC721BurnableApproval

+ func (it *ERC721BurnableApprovalIterator) Close() error

+ func (it *ERC721BurnableApprovalIterator) Error() error

+ func (it *ERC721BurnableApprovalIterator) Next() bool

+ type ERC721BurnableCaller struct

+ func NewERC721BurnableCaller(address common.Address, caller bind.ContractCaller) (*ERC721BurnableCaller, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type ERC721BurnableCallerRaw struct

+ Contract *ERC721BurnableCaller

+ func (_ERC721Burnable *ERC721BurnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721BurnableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721BurnableCaller

+ func (_ERC721Burnable *ERC721BurnableCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Burnable *ERC721BurnableCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Burnable *ERC721BurnableCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type ERC721BurnableFilterer struct

+ func NewERC721BurnableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721BurnableFilterer, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721BurnableApprovalIterator, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721BurnableApprovalForAllIterator, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721BurnableTransferIterator, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721BurnableApproval, ...) (event.Subscription, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721BurnableApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721Burnable *ERC721BurnableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721BurnableTransfer, ...) (event.Subscription, error)

+ type ERC721BurnableRaw struct

+ Contract *ERC721Burnable

+ func (_ERC721Burnable *ERC721BurnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ERC721Burnable *ERC721BurnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721BurnableSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721Burnable

+ TransactOpts bind.TransactOpts

+ func (_ERC721Burnable *ERC721BurnableSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Burnable *ERC721BurnableSession) Burn(tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Burnable *ERC721BurnableSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Burnable *ERC721BurnableSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Burnable *ERC721BurnableSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721BurnableTransactor struct

+ func NewERC721BurnableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721BurnableTransactor, error)

+ func (_ERC721Burnable *ERC721BurnableTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactor) Burn(opts *bind.TransactOpts, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type ERC721BurnableTransactorRaw struct

+ Contract *ERC721BurnableTransactor

+ func (_ERC721Burnable *ERC721BurnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721BurnableTransactorSession struct

+ Contract *ERC721BurnableTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) Burn(tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Burnable *ERC721BurnableTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721BurnableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721BurnableTransferIterator struct

+ Event *ERC721BurnableTransfer

+ func (it *ERC721BurnableTransferIterator) Close() error

+ func (it *ERC721BurnableTransferIterator) Error() error

+ func (it *ERC721BurnableTransferIterator) Next() bool

+ type ERC721Caller struct

+ func NewERC721Caller(address common.Address, caller bind.ContractCaller) (*ERC721Caller, error)

+ func (_ERC721 *ERC721Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721 *ERC721Caller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721Caller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721 *ERC721Caller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type ERC721CallerRaw struct

+ Contract *ERC721Caller

+ func (_ERC721 *ERC721CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721Caller

+ func (_ERC721 *ERC721CallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721 *ERC721CallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721CallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721 *ERC721CallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type ERC721Enumerable struct

+ func DeployERC721Enumerable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC721Enumerable, error)

+ func NewERC721Enumerable(address common.Address, backend bind.ContractBackend) (*ERC721Enumerable, error)

+ type ERC721EnumerableApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721EnumerableApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721EnumerableApprovalForAllIterator struct

+ Event *ERC721EnumerableApprovalForAll

+ func (it *ERC721EnumerableApprovalForAllIterator) Close() error

+ func (it *ERC721EnumerableApprovalForAllIterator) Error() error

+ func (it *ERC721EnumerableApprovalForAllIterator) Next() bool

+ type ERC721EnumerableApprovalIterator struct

+ Event *ERC721EnumerableApproval

+ func (it *ERC721EnumerableApprovalIterator) Close() error

+ func (it *ERC721EnumerableApprovalIterator) Error() error

+ func (it *ERC721EnumerableApprovalIterator) Next() bool

+ type ERC721EnumerableCaller struct

+ func NewERC721EnumerableCaller(address common.Address, caller bind.ContractCaller) (*ERC721EnumerableCaller, error)

+ func (_ERC721Enumerable *ERC721EnumerableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Enumerable *ERC721EnumerableCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Enumerable *ERC721EnumerableCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Enumerable *ERC721EnumerableCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_ERC721Enumerable *ERC721EnumerableCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC721EnumerableCallerRaw struct

+ Contract *ERC721EnumerableCaller

+ func (_ERC721Enumerable *ERC721EnumerableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721EnumerableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721EnumerableCaller

+ func (_ERC721Enumerable *ERC721EnumerableCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Enumerable *ERC721EnumerableCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Enumerable *ERC721EnumerableCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Enumerable *ERC721EnumerableCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Enumerable *ERC721EnumerableCallerSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableCallerSession) TotalSupply() (*big.Int, error)

+ type ERC721EnumerableFilterer struct

+ func NewERC721EnumerableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721EnumerableFilterer, error)

+ func (_ERC721Enumerable *ERC721EnumerableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721EnumerableApprovalIterator, error)

+ func (_ERC721Enumerable *ERC721EnumerableFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721EnumerableApprovalForAllIterator, error)

+ func (_ERC721Enumerable *ERC721EnumerableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721EnumerableTransferIterator, error)

+ func (_ERC721Enumerable *ERC721EnumerableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721EnumerableApproval, ...) (event.Subscription, error)

+ func (_ERC721Enumerable *ERC721EnumerableFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721EnumerableApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721Enumerable *ERC721EnumerableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721EnumerableTransfer, ...) (event.Subscription, error)

+ type ERC721EnumerableRaw struct

+ Contract *ERC721Enumerable

+ func (_ERC721Enumerable *ERC721EnumerableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ERC721Enumerable *ERC721EnumerableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721EnumerableSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721Enumerable

+ TransactOpts bind.TransactOpts

+ func (_ERC721Enumerable *ERC721EnumerableSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) TotalSupply() (*big.Int, error)

+ func (_ERC721Enumerable *ERC721EnumerableSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721EnumerableTransactor struct

+ func NewERC721EnumerableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721EnumerableTransactor, error)

+ func (_ERC721Enumerable *ERC721EnumerableTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type ERC721EnumerableTransactorRaw struct

+ Contract *ERC721EnumerableTransactor

+ func (_ERC721Enumerable *ERC721EnumerableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721EnumerableTransactorSession struct

+ Contract *ERC721EnumerableTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721Enumerable *ERC721EnumerableTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Enumerable *ERC721EnumerableTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721EnumerableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721EnumerableTransferIterator struct

+ Event *ERC721EnumerableTransfer

+ func (it *ERC721EnumerableTransferIterator) Close() error

+ func (it *ERC721EnumerableTransferIterator) Error() error

+ func (it *ERC721EnumerableTransferIterator) Next() bool

+ type ERC721Filterer struct

+ func NewERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC721Filterer, error)

+ func (_ERC721 *ERC721Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721ApprovalIterator, error)

+ func (_ERC721 *ERC721Filterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721ApprovalForAllIterator, error)

+ func (_ERC721 *ERC721Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721TransferIterator, error)

+ func (_ERC721 *ERC721Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_ERC721 *ERC721Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721ApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721 *ERC721Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721Transfer, from []common.Address, ...) (event.Subscription, error)

+ type ERC721Full struct

+ func DeployERC721Full(auth *bind.TransactOpts, backend bind.ContractBackend, name string, ...) (common.Address, *types.Transaction, *ERC721Full, error)

+ func NewERC721Full(address common.Address, backend bind.ContractBackend) (*ERC721Full, error)

+ type ERC721FullApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721FullApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721FullApprovalForAllIterator struct

+ Event *ERC721FullApprovalForAll

+ func (it *ERC721FullApprovalForAllIterator) Close() error

+ func (it *ERC721FullApprovalForAllIterator) Error() error

+ func (it *ERC721FullApprovalForAllIterator) Next() bool

+ type ERC721FullApprovalIterator struct

+ Event *ERC721FullApproval

+ func (it *ERC721FullApprovalIterator) Close() error

+ func (it *ERC721FullApprovalIterator) Error() error

+ func (it *ERC721FullApprovalIterator) Next() bool

+ type ERC721FullCaller struct

+ func NewERC721FullCaller(address common.Address, caller bind.ContractCaller) (*ERC721FullCaller, error)

+ func (_ERC721Full *ERC721FullCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721Full *ERC721FullCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Full *ERC721FullCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Full *ERC721FullCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC721Full *ERC721FullCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Full *ERC721FullCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_ERC721Full *ERC721FullCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC721Full *ERC721FullCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error)

+ func (_ERC721Full *ERC721FullCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error)

+ func (_ERC721Full *ERC721FullCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ func (_ERC721Full *ERC721FullCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC721FullCallerRaw struct

+ Contract *ERC721FullCaller

+ func (_ERC721Full *ERC721FullCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721FullCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721FullCaller

+ func (_ERC721Full *ERC721FullCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Full *ERC721FullCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Full *ERC721FullCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Full *ERC721FullCallerSession) Name() (string, error)

+ func (_ERC721Full *ERC721FullCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Full *ERC721FullCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Full *ERC721FullCallerSession) Symbol() (string, error)

+ func (_ERC721Full *ERC721FullCallerSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_ERC721Full *ERC721FullCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_ERC721Full *ERC721FullCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_ERC721Full *ERC721FullCallerSession) TotalSupply() (*big.Int, error)

+ type ERC721FullFilterer struct

+ func NewERC721FullFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721FullFilterer, error)

+ func (_ERC721Full *ERC721FullFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721FullApprovalIterator, error)

+ func (_ERC721Full *ERC721FullFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721FullApprovalForAllIterator, error)

+ func (_ERC721Full *ERC721FullFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721FullTransferIterator, error)

+ func (_ERC721Full *ERC721FullFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721FullApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_ERC721Full *ERC721FullFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721FullApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721Full *ERC721FullFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721FullTransfer, from []common.Address, ...) (event.Subscription, error)

+ type ERC721FullRaw struct

+ Contract *ERC721Full

+ func (_ERC721Full *ERC721FullRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ERC721Full *ERC721FullRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721FullSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721Full

+ TransactOpts bind.TransactOpts

+ func (_ERC721Full *ERC721FullSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Full *ERC721FullSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Full *ERC721FullSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Full *ERC721FullSession) Name() (string, error)

+ func (_ERC721Full *ERC721FullSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Full *ERC721FullSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Full *ERC721FullSession) Symbol() (string, error)

+ func (_ERC721Full *ERC721FullSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_ERC721Full *ERC721FullSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_ERC721Full *ERC721FullSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_ERC721Full *ERC721FullSession) TotalSupply() (*big.Int, error)

+ func (_ERC721Full *ERC721FullSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721FullTransactor struct

+ func NewERC721FullTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721FullTransactor, error)

+ func (_ERC721Full *ERC721FullTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type ERC721FullTransactorRaw struct

+ Contract *ERC721FullTransactor

+ func (_ERC721Full *ERC721FullTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721FullTransactorSession struct

+ Contract *ERC721FullTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721Full *ERC721FullTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Full *ERC721FullTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721FullTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721FullTransferIterator struct

+ Event *ERC721FullTransfer

+ func (it *ERC721FullTransferIterator) Close() error

+ func (it *ERC721FullTransferIterator) Error() error

+ func (it *ERC721FullTransferIterator) Next() bool

+ type ERC721Metadata struct

+ func DeployERC721Metadata(auth *bind.TransactOpts, backend bind.ContractBackend, name string, ...) (common.Address, *types.Transaction, *ERC721Metadata, error)

+ func NewERC721Metadata(address common.Address, backend bind.ContractBackend) (*ERC721Metadata, error)

+ type ERC721MetadataApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721MetadataApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721MetadataApprovalForAllIterator struct

+ Event *ERC721MetadataApprovalForAll

+ func (it *ERC721MetadataApprovalForAllIterator) Close() error

+ func (it *ERC721MetadataApprovalForAllIterator) Error() error

+ func (it *ERC721MetadataApprovalForAllIterator) Next() bool

+ type ERC721MetadataApprovalIterator struct

+ Event *ERC721MetadataApproval

+ func (it *ERC721MetadataApprovalIterator) Close() error

+ func (it *ERC721MetadataApprovalIterator) Error() error

+ func (it *ERC721MetadataApprovalIterator) Next() bool

+ type ERC721MetadataCaller struct

+ func NewERC721MetadataCaller(address common.Address, caller bind.ContractCaller) (*ERC721MetadataCaller, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC721Metadata *ERC721MetadataCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ type ERC721MetadataCallerRaw struct

+ Contract *ERC721MetadataCaller

+ func (_ERC721Metadata *ERC721MetadataCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721MetadataCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721MetadataCaller

+ func (_ERC721Metadata *ERC721MetadataCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) Name() (string, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) Symbol() (string, error)

+ func (_ERC721Metadata *ERC721MetadataCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ type ERC721MetadataFilterer struct

+ func NewERC721MetadataFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721MetadataFilterer, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721MetadataApprovalIterator, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721MetadataApprovalForAllIterator, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721MetadataTransferIterator, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721MetadataApproval, ...) (event.Subscription, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721MetadataApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721Metadata *ERC721MetadataFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721MetadataTransfer, ...) (event.Subscription, error)

+ type ERC721MetadataMintable struct

+ func DeployERC721MetadataMintable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC721MetadataMintable, error)

+ func NewERC721MetadataMintable(address common.Address, backend bind.ContractBackend) (*ERC721MetadataMintable, error)

+ type ERC721MetadataMintableApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721MetadataMintableApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721MetadataMintableApprovalForAllIterator struct

+ Event *ERC721MetadataMintableApprovalForAll

+ func (it *ERC721MetadataMintableApprovalForAllIterator) Close() error

+ func (it *ERC721MetadataMintableApprovalForAllIterator) Error() error

+ func (it *ERC721MetadataMintableApprovalForAllIterator) Next() bool

+ type ERC721MetadataMintableApprovalIterator struct

+ Event *ERC721MetadataMintableApproval

+ func (it *ERC721MetadataMintableApprovalIterator) Close() error

+ func (it *ERC721MetadataMintableApprovalIterator) Error() error

+ func (it *ERC721MetadataMintableApprovalIterator) Next() bool

+ type ERC721MetadataMintableCaller struct

+ func NewERC721MetadataMintableCaller(address common.Address, caller bind.ContractCaller) (*ERC721MetadataMintableCaller, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ type ERC721MetadataMintableCallerRaw struct

+ Contract *ERC721MetadataMintableCaller

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721MetadataMintableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721MetadataMintableCaller

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) IsMinter(account common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) Name() (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) Symbol() (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ type ERC721MetadataMintableFilterer struct

+ func NewERC721MetadataMintableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721MetadataMintableFilterer, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721MetadataMintableApprovalIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721MetadataMintableApprovalForAllIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*ERC721MetadataMintableMinterAddedIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*ERC721MetadataMintableMinterRemovedIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721MetadataMintableTransferIterator, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableApproval, ...) (event.Subscription, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableMinterAdded, ...) (event.Subscription, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableMinterRemoved, ...) (event.Subscription, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721MetadataMintableTransfer, ...) (event.Subscription, error)

+ type ERC721MetadataMintableMinterAdded struct

+ Account common.Address

+ Raw types.Log

+ type ERC721MetadataMintableMinterAddedIterator struct

+ Event *ERC721MetadataMintableMinterAdded

+ func (it *ERC721MetadataMintableMinterAddedIterator) Close() error

+ func (it *ERC721MetadataMintableMinterAddedIterator) Error() error

+ func (it *ERC721MetadataMintableMinterAddedIterator) Next() bool

+ type ERC721MetadataMintableMinterRemoved struct

+ Account common.Address

+ Raw types.Log

+ type ERC721MetadataMintableMinterRemovedIterator struct

+ Event *ERC721MetadataMintableMinterRemoved

+ func (it *ERC721MetadataMintableMinterRemovedIterator) Close() error

+ func (it *ERC721MetadataMintableMinterRemovedIterator) Error() error

+ func (it *ERC721MetadataMintableMinterRemovedIterator) Next() bool

+ type ERC721MetadataMintableRaw struct

+ Contract *ERC721MetadataMintable

+ func (_ERC721MetadataMintable *ERC721MetadataMintableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ERC721MetadataMintable *ERC721MetadataMintableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721MetadataMintableSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721MetadataMintable

+ TransactOpts bind.TransactOpts

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) IsMinter(account common.Address) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) MintWithTokenURI(to common.Address, tokenId *big.Int, tokenURI string) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) Name() (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) RenounceMinter() (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) Symbol() (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721MetadataMintableTransactor struct

+ func NewERC721MetadataMintableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721MetadataMintableTransactor, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) MintWithTokenURI(opts *bind.TransactOpts, to common.Address, tokenId *big.Int, tokenURI string) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type ERC721MetadataMintableTransactorRaw struct

+ Contract *ERC721MetadataMintableTransactor

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721MetadataMintableTransactorSession struct

+ Contract *ERC721MetadataMintableTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) MintWithTokenURI(to common.Address, tokenId *big.Int, tokenURI string) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) RenounceMinter() (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721MetadataMintable *ERC721MetadataMintableTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721MetadataMintableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721MetadataMintableTransferIterator struct

+ Event *ERC721MetadataMintableTransfer

+ func (it *ERC721MetadataMintableTransferIterator) Close() error

+ func (it *ERC721MetadataMintableTransferIterator) Error() error

+ func (it *ERC721MetadataMintableTransferIterator) Next() bool

+ type ERC721MetadataRaw struct

+ Contract *ERC721Metadata

+ func (_ERC721Metadata *ERC721MetadataRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ERC721Metadata *ERC721MetadataRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721MetadataSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721Metadata

+ TransactOpts bind.TransactOpts

+ func (_ERC721Metadata *ERC721MetadataSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721Metadata *ERC721MetadataSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataSession) Name() (string, error)

+ func (_ERC721Metadata *ERC721MetadataSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721Metadata *ERC721MetadataSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721Metadata *ERC721MetadataSession) Symbol() (string, error)

+ func (_ERC721Metadata *ERC721MetadataSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_ERC721Metadata *ERC721MetadataSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721MetadataTransactor struct

+ func NewERC721MetadataTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721MetadataTransactor, error)

+ func (_ERC721Metadata *ERC721MetadataTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type ERC721MetadataTransactorRaw struct

+ Contract *ERC721MetadataTransactor

+ func (_ERC721Metadata *ERC721MetadataTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721MetadataTransactorSession struct

+ Contract *ERC721MetadataTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721Metadata *ERC721MetadataTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721Metadata *ERC721MetadataTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721MetadataTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721MetadataTransferIterator struct

+ Event *ERC721MetadataTransfer

+ func (it *ERC721MetadataTransferIterator) Close() error

+ func (it *ERC721MetadataTransferIterator) Error() error

+ func (it *ERC721MetadataTransferIterator) Next() bool

+ type ERC721Raw struct

+ Contract *ERC721

+ func (_ERC721 *ERC721Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ERC721 *ERC721Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721 *ERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721ServiceChain struct

+ func DeployERC721ServiceChain(auth *bind.TransactOpts, backend bind.ContractBackend, _bridge common.Address) (common.Address, *types.Transaction, *ERC721ServiceChain, error)

+ func NewERC721ServiceChain(address common.Address, backend bind.ContractBackend) (*ERC721ServiceChain, error)

+ type ERC721ServiceChainApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ERC721ServiceChainApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ERC721ServiceChainApprovalForAllIterator struct

+ Event *ERC721ServiceChainApprovalForAll

+ func (it *ERC721ServiceChainApprovalForAllIterator) Close() error

+ func (it *ERC721ServiceChainApprovalForAllIterator) Error() error

+ func (it *ERC721ServiceChainApprovalForAllIterator) Next() bool

+ type ERC721ServiceChainApprovalIterator struct

+ Event *ERC721ServiceChainApproval

+ func (it *ERC721ServiceChainApprovalIterator) Close() error

+ func (it *ERC721ServiceChainApprovalIterator) Error() error

+ func (it *ERC721ServiceChainApprovalIterator) Next() bool

+ type ERC721ServiceChainCaller struct

+ func NewERC721ServiceChainCaller(address common.Address, caller bind.ContractCaller) (*ERC721ServiceChainCaller, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ type ERC721ServiceChainCallerRaw struct

+ Contract *ERC721ServiceChainCaller

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC721ServiceChainCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721ServiceChainCaller

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) Bridge() (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) IsOwner() (bool, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) Name() (string, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) Owner() (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) Symbol() (string, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ type ERC721ServiceChainFilterer struct

+ func NewERC721ServiceChainFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721ServiceChainFilterer, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ERC721ServiceChainApprovalIterator, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721ServiceChainApprovalForAllIterator, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*ERC721ServiceChainOwnershipTransferredIterator, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ERC721ServiceChainTransferIterator, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721ServiceChainApproval, ...) (event.Subscription, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721ServiceChainApprovalForAll, ...) (event.Subscription, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ERC721ServiceChainOwnershipTransferred, ...) (event.Subscription, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721ServiceChainTransfer, ...) (event.Subscription, error)

+ type ERC721ServiceChainOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type ERC721ServiceChainOwnershipTransferredIterator struct

+ Event *ERC721ServiceChainOwnershipTransferred

+ func (it *ERC721ServiceChainOwnershipTransferredIterator) Close() error

+ func (it *ERC721ServiceChainOwnershipTransferredIterator) Error() error

+ func (it *ERC721ServiceChainOwnershipTransferredIterator) Next() bool

+ type ERC721ServiceChainRaw struct

+ Contract *ERC721ServiceChain

+ func (_ERC721ServiceChain *ERC721ServiceChainRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ERC721ServiceChain *ERC721ServiceChainRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721ServiceChainSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC721ServiceChain

+ TransactOpts bind.TransactOpts

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) Bridge() (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) IsOwner() (bool, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) Name() (string, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) Owner() (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) RequestValueTransfer(_uid *big.Int, _to common.Address, _extraData []*big.Int) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) SetBridge(_bridge common.Address) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) Symbol() (string, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type ERC721ServiceChainTransactor struct

+ func NewERC721ServiceChainTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721ServiceChainTransactor, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactor) RequestValueTransfer(opts *bind.TransactOpts, _uid *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactor) SetBridge(opts *bind.TransactOpts, _bridge common.Address) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type ERC721ServiceChainTransactorRaw struct

+ Contract *ERC721ServiceChainTransactor

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721ServiceChainTransactorSession struct

+ Contract *ERC721ServiceChainTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorSession) RequestValueTransfer(_uid *big.Int, _to common.Address, _extraData []*big.Int) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorSession) SetBridge(_bridge common.Address) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721ServiceChain *ERC721ServiceChainTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type ERC721ServiceChainTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721ServiceChainTransferIterator struct

+ Event *ERC721ServiceChainTransfer

+ func (it *ERC721ServiceChainTransferIterator) Close() error

+ func (it *ERC721ServiceChainTransferIterator) Error() error

+ func (it *ERC721ServiceChainTransferIterator) Next() bool

+ type ERC721Session struct

+ CallOpts bind.CallOpts

+ Contract *ERC721

+ TransactOpts bind.TransactOpts

+ func (_ERC721 *ERC721Session) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721 *ERC721Session) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ERC721 *ERC721Session) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721Session) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ERC721 *ERC721Session) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ERC721 *ERC721Session) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721 *ERC721Session) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721 *ERC721Session) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ERC721 *ERC721Session) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721Transactor struct

+ func NewERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC721Transactor, error)

+ func (_ERC721 *ERC721Transactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721 *ERC721Transactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ERC721 *ERC721Transactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721 *ERC721Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type ERC721TransactorRaw struct

+ Contract *ERC721Transactor

+ func (_ERC721 *ERC721TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC721 *ERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC721TransactorSession struct

+ Contract *ERC721Transactor

+ TransactOpts bind.TransactOpts

+ func (_ERC721 *ERC721TransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ERC721 *ERC721TransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ERC721 *ERC721TransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ERC721 *ERC721TransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type ERC721Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ERC721TransferIterator struct

+ Event *ERC721Transfer

+ func (it *ERC721TransferIterator) Close() error

+ func (it *ERC721TransferIterator) Error() error

+ func (it *ERC721TransferIterator) Next() bool

+ type IERC165 struct

+ func DeployIERC165(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC165, error)

+ func NewIERC165(address common.Address, backend bind.ContractBackend) (*IERC165, error)

+ type IERC165Caller struct

+ func NewIERC165Caller(address common.Address, caller bind.ContractCaller) (*IERC165Caller, error)

+ func (_IERC165 *IERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type IERC165CallerRaw struct

+ Contract *IERC165Caller

+ func (_IERC165 *IERC165CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC165CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC165Caller

+ func (_IERC165 *IERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type IERC165Filterer struct

+ func NewIERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC165Filterer, error)

+ type IERC165Raw struct

+ Contract *IERC165

+ func (_IERC165 *IERC165Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_IERC165 *IERC165Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC165 *IERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC165Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC165

+ TransactOpts bind.TransactOpts

+ func (_IERC165 *IERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type IERC165Transactor struct

+ func NewIERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC165Transactor, error)

+ type IERC165TransactorRaw struct

+ Contract *IERC165Transactor

+ func (_IERC165 *IERC165TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC165 *IERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC165TransactorSession struct

+ Contract *IERC165Transactor

+ TransactOpts bind.TransactOpts

+ type IERC721 struct

+ func DeployIERC721(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC721, error)

+ func NewIERC721(address common.Address, backend bind.ContractBackend) (*IERC721, error)

+ type IERC721Approval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type IERC721ApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type IERC721ApprovalForAllIterator struct

+ Event *IERC721ApprovalForAll

+ func (it *IERC721ApprovalForAllIterator) Close() error

+ func (it *IERC721ApprovalForAllIterator) Error() error

+ func (it *IERC721ApprovalForAllIterator) Next() bool

+ type IERC721ApprovalIterator struct

+ Event *IERC721Approval

+ func (it *IERC721ApprovalIterator) Close() error

+ func (it *IERC721ApprovalIterator) Error() error

+ func (it *IERC721ApprovalIterator) Next() bool

+ type IERC721BridgeReceiver struct

+ func DeployIERC721BridgeReceiver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC721BridgeReceiver, error)

+ func NewIERC721BridgeReceiver(address common.Address, backend bind.ContractBackend) (*IERC721BridgeReceiver, error)

+ type IERC721BridgeReceiverCaller struct

+ func NewIERC721BridgeReceiverCaller(address common.Address, caller bind.ContractCaller) (*IERC721BridgeReceiverCaller, error)

+ type IERC721BridgeReceiverCallerRaw struct

+ Contract *IERC721BridgeReceiverCaller

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC721BridgeReceiverCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721BridgeReceiverCaller

+ type IERC721BridgeReceiverFilterer struct

+ func NewIERC721BridgeReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721BridgeReceiverFilterer, error)

+ type IERC721BridgeReceiverRaw struct

+ Contract *IERC721BridgeReceiver

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721BridgeReceiverSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721BridgeReceiver

+ TransactOpts bind.TransactOpts

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverSession) OnERC721Received(_from common.Address, _tokenId *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ type IERC721BridgeReceiverTransactor struct

+ func NewIERC721BridgeReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721BridgeReceiverTransactor, error)

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverTransactor) OnERC721Received(opts *bind.TransactOpts, _from common.Address, _tokenId *big.Int, ...) (*types.Transaction, error)

+ type IERC721BridgeReceiverTransactorRaw struct

+ Contract *IERC721BridgeReceiverTransactor

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721BridgeReceiverTransactorSession struct

+ Contract *IERC721BridgeReceiverTransactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721BridgeReceiver *IERC721BridgeReceiverTransactorSession) OnERC721Received(_from common.Address, _tokenId *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ type IERC721Caller struct

+ func NewIERC721Caller(address common.Address, caller bind.ContractCaller) (*IERC721Caller, error)

+ func (_IERC721 *IERC721Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_IERC721 *IERC721Caller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Caller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721 *IERC721Caller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ type IERC721CallerRaw struct

+ Contract *IERC721Caller

+ func (_IERC721 *IERC721CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC721CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721Caller

+ func (_IERC721 *IERC721CallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721 *IERC721CallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721CallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721 *IERC721CallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ type IERC721Enumerable struct

+ func DeployIERC721Enumerable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC721Enumerable, error)

+ func NewIERC721Enumerable(address common.Address, backend bind.ContractBackend) (*IERC721Enumerable, error)

+ type IERC721EnumerableApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type IERC721EnumerableApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type IERC721EnumerableApprovalForAllIterator struct

+ Event *IERC721EnumerableApprovalForAll

+ func (it *IERC721EnumerableApprovalForAllIterator) Close() error

+ func (it *IERC721EnumerableApprovalForAllIterator) Error() error

+ func (it *IERC721EnumerableApprovalForAllIterator) Next() bool

+ type IERC721EnumerableApprovalIterator struct

+ Event *IERC721EnumerableApproval

+ func (it *IERC721EnumerableApprovalIterator) Close() error

+ func (it *IERC721EnumerableApprovalIterator) Error() error

+ func (it *IERC721EnumerableApprovalIterator) Next() bool

+ type IERC721EnumerableCaller struct

+ func NewIERC721EnumerableCaller(address common.Address, caller bind.ContractCaller) (*IERC721EnumerableCaller, error)

+ func (_IERC721Enumerable *IERC721EnumerableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721Enumerable *IERC721EnumerableCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721Enumerable *IERC721EnumerableCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721Enumerable *IERC721EnumerableCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_IERC721Enumerable *IERC721EnumerableCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type IERC721EnumerableCallerRaw struct

+ Contract *IERC721EnumerableCaller

+ func (_IERC721Enumerable *IERC721EnumerableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC721EnumerableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721EnumerableCaller

+ func (_IERC721Enumerable *IERC721EnumerableCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Enumerable *IERC721EnumerableCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721Enumerable *IERC721EnumerableCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Enumerable *IERC721EnumerableCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_IERC721Enumerable *IERC721EnumerableCallerSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableCallerSession) TotalSupply() (*big.Int, error)

+ type IERC721EnumerableFilterer struct

+ func NewIERC721EnumerableFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721EnumerableFilterer, error)

+ func (_IERC721Enumerable *IERC721EnumerableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*IERC721EnumerableApprovalIterator, error)

+ func (_IERC721Enumerable *IERC721EnumerableFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*IERC721EnumerableApprovalForAllIterator, error)

+ func (_IERC721Enumerable *IERC721EnumerableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*IERC721EnumerableTransferIterator, error)

+ func (_IERC721Enumerable *IERC721EnumerableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721EnumerableApproval, ...) (event.Subscription, error)

+ func (_IERC721Enumerable *IERC721EnumerableFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721EnumerableApprovalForAll, ...) (event.Subscription, error)

+ func (_IERC721Enumerable *IERC721EnumerableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721EnumerableTransfer, ...) (event.Subscription, error)

+ type IERC721EnumerableRaw struct

+ Contract *IERC721Enumerable

+ func (_IERC721Enumerable *IERC721EnumerableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_IERC721Enumerable *IERC721EnumerableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721EnumerableSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721Enumerable

+ TransactOpts bind.TransactOpts

+ func (_IERC721Enumerable *IERC721EnumerableSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) TotalSupply() (*big.Int, error)

+ func (_IERC721Enumerable *IERC721EnumerableSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721EnumerableTransactor struct

+ func NewIERC721EnumerableTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721EnumerableTransactor, error)

+ func (_IERC721Enumerable *IERC721EnumerableTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type IERC721EnumerableTransactorRaw struct

+ Contract *IERC721EnumerableTransactor

+ func (_IERC721Enumerable *IERC721EnumerableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721EnumerableTransactorSession struct

+ Contract *IERC721EnumerableTransactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721Enumerable *IERC721EnumerableTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableTransactorSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721Enumerable *IERC721EnumerableTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721EnumerableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type IERC721EnumerableTransferIterator struct

+ Event *IERC721EnumerableTransfer

+ func (it *IERC721EnumerableTransferIterator) Close() error

+ func (it *IERC721EnumerableTransferIterator) Error() error

+ func (it *IERC721EnumerableTransferIterator) Next() bool

+ type IERC721Filterer struct

+ func NewIERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC721Filterer, error)

+ func (_IERC721 *IERC721Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*IERC721ApprovalIterator, error)

+ func (_IERC721 *IERC721Filterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*IERC721ApprovalForAllIterator, error)

+ func (_IERC721 *IERC721Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*IERC721TransferIterator, error)

+ func (_IERC721 *IERC721Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_IERC721 *IERC721Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721ApprovalForAll, ...) (event.Subscription, error)

+ func (_IERC721 *IERC721Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721Transfer, from []common.Address, ...) (event.Subscription, error)

+ type IERC721Metadata struct

+ func DeployIERC721Metadata(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC721Metadata, error)

+ func NewIERC721Metadata(address common.Address, backend bind.ContractBackend) (*IERC721Metadata, error)

+ type IERC721MetadataApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type IERC721MetadataApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type IERC721MetadataApprovalForAllIterator struct

+ Event *IERC721MetadataApprovalForAll

+ func (it *IERC721MetadataApprovalForAllIterator) Close() error

+ func (it *IERC721MetadataApprovalForAllIterator) Error() error

+ func (it *IERC721MetadataApprovalForAllIterator) Next() bool

+ type IERC721MetadataApprovalIterator struct

+ Event *IERC721MetadataApproval

+ func (it *IERC721MetadataApprovalIterator) Close() error

+ func (it *IERC721MetadataApprovalIterator) Error() error

+ func (it *IERC721MetadataApprovalIterator) Next() bool

+ type IERC721MetadataCaller struct

+ func NewIERC721MetadataCaller(address common.Address, caller bind.ContractCaller) (*IERC721MetadataCaller, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_IERC721Metadata *IERC721MetadataCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ type IERC721MetadataCallerRaw struct

+ Contract *IERC721MetadataCaller

+ func (_IERC721Metadata *IERC721MetadataCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC721MetadataCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721MetadataCaller

+ func (_IERC721Metadata *IERC721MetadataCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) Name() (string, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) Symbol() (string, error)

+ func (_IERC721Metadata *IERC721MetadataCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ type IERC721MetadataFilterer struct

+ func NewIERC721MetadataFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721MetadataFilterer, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*IERC721MetadataApprovalIterator, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*IERC721MetadataApprovalForAllIterator, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*IERC721MetadataTransferIterator, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721MetadataApproval, ...) (event.Subscription, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721MetadataApprovalForAll, ...) (event.Subscription, error)

+ func (_IERC721Metadata *IERC721MetadataFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721MetadataTransfer, ...) (event.Subscription, error)

+ type IERC721MetadataRaw struct

+ Contract *IERC721Metadata

+ func (_IERC721Metadata *IERC721MetadataRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_IERC721Metadata *IERC721MetadataRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721MetadataSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721Metadata

+ TransactOpts bind.TransactOpts

+ func (_IERC721Metadata *IERC721MetadataSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721Metadata *IERC721MetadataSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataSession) Name() (string, error)

+ func (_IERC721Metadata *IERC721MetadataSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721Metadata *IERC721MetadataSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_IERC721Metadata *IERC721MetadataSession) Symbol() (string, error)

+ func (_IERC721Metadata *IERC721MetadataSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_IERC721Metadata *IERC721MetadataSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721MetadataTransactor struct

+ func NewIERC721MetadataTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721MetadataTransactor, error)

+ func (_IERC721Metadata *IERC721MetadataTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type IERC721MetadataTransactorRaw struct

+ Contract *IERC721MetadataTransactor

+ func (_IERC721Metadata *IERC721MetadataTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721MetadataTransactorSession struct

+ Contract *IERC721MetadataTransactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721Metadata *IERC721MetadataTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactorSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721Metadata *IERC721MetadataTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721MetadataTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type IERC721MetadataTransferIterator struct

+ Event *IERC721MetadataTransfer

+ func (it *IERC721MetadataTransferIterator) Close() error

+ func (it *IERC721MetadataTransferIterator) Error() error

+ func (it *IERC721MetadataTransferIterator) Next() bool

+ type IERC721Raw struct

+ Contract *IERC721

+ func (_IERC721 *IERC721Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_IERC721 *IERC721Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721 *IERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721Receiver struct

+ func DeployIERC721Receiver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *IERC721Receiver, error)

+ func NewIERC721Receiver(address common.Address, backend bind.ContractBackend) (*IERC721Receiver, error)

+ type IERC721ReceiverCaller struct

+ func NewIERC721ReceiverCaller(address common.Address, caller bind.ContractCaller) (*IERC721ReceiverCaller, error)

+ type IERC721ReceiverCallerRaw struct

+ Contract *IERC721ReceiverCaller

+ func (_IERC721Receiver *IERC721ReceiverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type IERC721ReceiverCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721ReceiverCaller

+ type IERC721ReceiverFilterer struct

+ func NewIERC721ReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721ReceiverFilterer, error)

+ type IERC721ReceiverRaw struct

+ Contract *IERC721Receiver

+ func (_IERC721Receiver *IERC721ReceiverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_IERC721Receiver *IERC721ReceiverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721Receiver *IERC721ReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721ReceiverSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC721Receiver

+ TransactOpts bind.TransactOpts

+ func (_IERC721Receiver *IERC721ReceiverSession) OnERC721Received(operator common.Address, from common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ type IERC721ReceiverTransactor struct

+ func NewIERC721ReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721ReceiverTransactor, error)

+ func (_IERC721Receiver *IERC721ReceiverTransactor) OnERC721Received(opts *bind.TransactOpts, operator common.Address, from common.Address, ...) (*types.Transaction, error)

+ type IERC721ReceiverTransactorRaw struct

+ Contract *IERC721ReceiverTransactor

+ func (_IERC721Receiver *IERC721ReceiverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721Receiver *IERC721ReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721ReceiverTransactorSession struct

+ Contract *IERC721ReceiverTransactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721Receiver *IERC721ReceiverTransactorSession) OnERC721Received(operator common.Address, from common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ type IERC721Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC721

+ TransactOpts bind.TransactOpts

+ func (_IERC721 *IERC721Session) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_IERC721 *IERC721Session) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Session) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_IERC721 *IERC721Session) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_IERC721 *IERC721Session) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721 *IERC721Session) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_IERC721 *IERC721Session) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721Transactor struct

+ func NewIERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC721Transactor, error)

+ func (_IERC721 *IERC721Transactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721Transactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_IERC721 *IERC721Transactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721 *IERC721Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ type IERC721TransactorRaw struct

+ Contract *IERC721Transactor

+ func (_IERC721 *IERC721TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC721TransactorSession struct

+ Contract *IERC721Transactor

+ TransactOpts bind.TransactOpts

+ func (_IERC721 *IERC721TransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error)

+ func (_IERC721 *IERC721TransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ type IERC721Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type IERC721TransferIterator struct

+ Event *IERC721Transfer

+ func (it *IERC721TransferIterator) Close() error

+ func (it *IERC721TransferIterator) Error() error

+ func (it *IERC721TransferIterator) Next() bool

+ type MinterRole struct

+ func DeployMinterRole(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MinterRole, error)

+ func NewMinterRole(address common.Address, backend bind.ContractBackend) (*MinterRole, error)

+ type MinterRoleCaller struct

+ func NewMinterRoleCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleCaller, error)

+ func (_MinterRole *MinterRoleCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error)

+ type MinterRoleCallerRaw struct

+ Contract *MinterRoleCaller

+ func (_MinterRole *MinterRoleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type MinterRoleCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MinterRoleCaller

+ func (_MinterRole *MinterRoleCallerSession) IsMinter(account common.Address) (bool, error)

+ type MinterRoleFilterer struct

+ func NewMinterRoleFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleFilterer, error)

+ func (_MinterRole *MinterRoleFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterAddedIterator, error)

+ func (_MinterRole *MinterRoleFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterRemovedIterator, error)

+ func (_MinterRole *MinterRoleFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterAdded, ...) (event.Subscription, error)

+ func (_MinterRole *MinterRoleFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterRemoved, ...) (event.Subscription, error)

+ type MinterRoleMinterAdded struct

+ Account common.Address

+ Raw types.Log

+ type MinterRoleMinterAddedIterator struct

+ Event *MinterRoleMinterAdded

+ func (it *MinterRoleMinterAddedIterator) Close() error

+ func (it *MinterRoleMinterAddedIterator) Error() error

+ func (it *MinterRoleMinterAddedIterator) Next() bool

+ type MinterRoleMinterRemoved struct

+ Account common.Address

+ Raw types.Log

+ type MinterRoleMinterRemovedIterator struct

+ Event *MinterRoleMinterRemoved

+ func (it *MinterRoleMinterRemovedIterator) Close() error

+ func (it *MinterRoleMinterRemovedIterator) Error() error

+ func (it *MinterRoleMinterRemovedIterator) Next() bool

+ type MinterRoleRaw struct

+ Contract *MinterRole

+ func (_MinterRole *MinterRoleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_MinterRole *MinterRoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MinterRole *MinterRoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MinterRoleSession struct

+ CallOpts bind.CallOpts

+ Contract *MinterRole

+ TransactOpts bind.TransactOpts

+ func (_MinterRole *MinterRoleSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_MinterRole *MinterRoleSession) IsMinter(account common.Address) (bool, error)

+ func (_MinterRole *MinterRoleSession) RenounceMinter() (*types.Transaction, error)

+ type MinterRoleTransactor struct

+ func NewMinterRoleTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleTransactor, error)

+ func (_MinterRole *MinterRoleTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_MinterRole *MinterRoleTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MinterRoleTransactorRaw struct

+ Contract *MinterRoleTransactor

+ func (_MinterRole *MinterRoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MinterRole *MinterRoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MinterRoleTransactorSession struct

+ Contract *MinterRoleTransactor

+ TransactOpts bind.TransactOpts

+ func (_MinterRole *MinterRoleTransactorSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_MinterRole *MinterRoleTransactorSession) RenounceMinter() (*types.Transaction, error)

+ type Ownable struct

+ func DeployOwnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Ownable, error)

+ func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error)

+ type OwnableCaller struct

+ func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error)

+ func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type OwnableCallerRaw struct

+ Contract *OwnableCaller

+ func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type OwnableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OwnableCaller

+ func (_Ownable *OwnableCallerSession) IsOwner() (bool, error)

+ func (_Ownable *OwnableCallerSession) Owner() (common.Address, error)

+ type OwnableFilterer struct

+ func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error)

+ func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OwnableOwnershipTransferredIterator, error)

+ func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, ...) (event.Subscription, error)

+ type OwnableOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OwnableOwnershipTransferredIterator struct

+ Event *OwnableOwnershipTransferred

+ func (it *OwnableOwnershipTransferredIterator) Close() error

+ func (it *OwnableOwnershipTransferredIterator) Error() error

+ func (it *OwnableOwnershipTransferredIterator) Next() bool

+ type OwnableRaw struct

+ Contract *Ownable

+ func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableSession struct

+ CallOpts bind.CallOpts

+ Contract *Ownable

+ TransactOpts bind.TransactOpts

+ func (_Ownable *OwnableSession) IsOwner() (bool, error)

+ func (_Ownable *OwnableSession) Owner() (common.Address, error)

+ func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type OwnableTransactor struct

+ func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error)

+ func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type OwnableTransactorRaw struct

+ Contract *OwnableTransactor

+ func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableTransactorSession struct

+ Contract *OwnableTransactor

+ TransactOpts bind.TransactOpts

+ func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type Roles struct

+ func DeployRoles(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Roles, error)

+ func NewRoles(address common.Address, backend bind.ContractBackend) (*Roles, error)

+ type RolesCaller struct

+ func NewRolesCaller(address common.Address, caller bind.ContractCaller) (*RolesCaller, error)

+ type RolesCallerRaw struct

+ Contract *RolesCaller

+ func (_Roles *RolesCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type RolesCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *RolesCaller

+ type RolesFilterer struct

+ func NewRolesFilterer(address common.Address, filterer bind.ContractFilterer) (*RolesFilterer, error)

+ type RolesRaw struct

+ Contract *Roles

+ func (_Roles *RolesRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_Roles *RolesRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Roles *RolesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RolesSession struct

+ CallOpts bind.CallOpts

+ Contract *Roles

+ TransactOpts bind.TransactOpts

+ type RolesTransactor struct

+ func NewRolesTransactor(address common.Address, transactor bind.ContractTransactor) (*RolesTransactor, error)

+ type RolesTransactorRaw struct

+ Contract *RolesTransactor

+ func (_Roles *RolesTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Roles *RolesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type RolesTransactorSession struct

+ Contract *RolesTransactor

+ TransactOpts bind.TransactOpts

+ type SafeMath struct

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

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

+ type SafeMathCaller struct

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

+ type SafeMathCallerRaw struct

+ Contract *SafeMathCaller

+ func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type SafeMathCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMathCaller

+ type SafeMathFilterer struct

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

+ type SafeMathRaw struct

+ Contract *SafeMath

+ func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMath

+ TransactOpts bind.TransactOpts

+ type SafeMathTransactor struct

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

+ type SafeMathTransactorRaw struct

+ Contract *SafeMathTransactor

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

+ func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathTransactorSession struct

+ Contract *SafeMathTransactor

+ TransactOpts bind.TransactOpts

+ type ServiceChainNFT struct

+ func DeployServiceChainNFT(auth *bind.TransactOpts, backend bind.ContractBackend, _bridge common.Address) (common.Address, *types.Transaction, *ServiceChainNFT, error)

+ func NewServiceChainNFT(address common.Address, backend bind.ContractBackend) (*ServiceChainNFT, error)

+ type ServiceChainNFTApproval struct

+ Approved common.Address

+ Owner common.Address

+ Raw types.Log

+ TokenId *big.Int

+ type ServiceChainNFTApprovalForAll struct

+ Approved bool

+ Operator common.Address

+ Owner common.Address

+ Raw types.Log

+ type ServiceChainNFTApprovalForAllIterator struct

+ Event *ServiceChainNFTApprovalForAll

+ func (it *ServiceChainNFTApprovalForAllIterator) Close() error

+ func (it *ServiceChainNFTApprovalForAllIterator) Error() error

+ func (it *ServiceChainNFTApprovalForAllIterator) Next() bool

+ type ServiceChainNFTApprovalIterator struct

+ Event *ServiceChainNFTApproval

+ func (it *ServiceChainNFTApprovalIterator) Close() error

+ func (it *ServiceChainNFTApprovalIterator) Error() error

+ func (it *ServiceChainNFTApprovalIterator) Next() bool

+ type ServiceChainNFTCaller struct

+ func NewServiceChainNFTCaller(address common.Address, caller bind.ContractCaller) (*ServiceChainNFTCaller, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) Bridge(opts *bind.CallOpts) (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error)

+ func (_ServiceChainNFT *ServiceChainNFTCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ServiceChainNFTCallerRaw struct

+ Contract *ServiceChainNFTCaller

+ func (_ServiceChainNFT *ServiceChainNFTCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ServiceChainNFTCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ServiceChainNFTCaller

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) Bridge() (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) IsMinter(account common.Address) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) IsOwner() (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) Name() (string, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) Owner() (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) Symbol() (string, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_ServiceChainNFT *ServiceChainNFTCallerSession) TotalSupply() (*big.Int, error)

+ type ServiceChainNFTFilterer struct

+ func NewServiceChainNFTFilterer(address common.Address, filterer bind.ContractFilterer) (*ServiceChainNFTFilterer, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, ...) (*ServiceChainNFTApprovalIterator, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ServiceChainNFTApprovalForAllIterator, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*ServiceChainNFTMinterAddedIterator, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*ServiceChainNFTMinterRemovedIterator, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*ServiceChainNFTOwnershipTransferredIterator, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, ...) (*ServiceChainNFTTransferIterator, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ServiceChainNFTApproval, ...) (event.Subscription, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ServiceChainNFTApprovalForAll, ...) (event.Subscription, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *ServiceChainNFTMinterAdded, ...) (event.Subscription, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *ServiceChainNFTMinterRemoved, ...) (event.Subscription, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ServiceChainNFTOwnershipTransferred, ...) (event.Subscription, error)

+ func (_ServiceChainNFT *ServiceChainNFTFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ServiceChainNFTTransfer, ...) (event.Subscription, error)

+ type ServiceChainNFTMinterAdded struct

+ Account common.Address

+ Raw types.Log

+ type ServiceChainNFTMinterAddedIterator struct

+ Event *ServiceChainNFTMinterAdded

+ func (it *ServiceChainNFTMinterAddedIterator) Close() error

+ func (it *ServiceChainNFTMinterAddedIterator) Error() error

+ func (it *ServiceChainNFTMinterAddedIterator) Next() bool

+ type ServiceChainNFTMinterRemoved struct

+ Account common.Address

+ Raw types.Log

+ type ServiceChainNFTMinterRemovedIterator struct

+ Event *ServiceChainNFTMinterRemoved

+ func (it *ServiceChainNFTMinterRemovedIterator) Close() error

+ func (it *ServiceChainNFTMinterRemovedIterator) Error() error

+ func (it *ServiceChainNFTMinterRemovedIterator) Next() bool

+ type ServiceChainNFTOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type ServiceChainNFTOwnershipTransferredIterator struct

+ Event *ServiceChainNFTOwnershipTransferred

+ func (it *ServiceChainNFTOwnershipTransferredIterator) Close() error

+ func (it *ServiceChainNFTOwnershipTransferredIterator) Error() error

+ func (it *ServiceChainNFTOwnershipTransferredIterator) Next() bool

+ type ServiceChainNFTRaw struct

+ Contract *ServiceChainNFT

+ func (_ServiceChainNFT *ServiceChainNFTRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ func (_ServiceChainNFT *ServiceChainNFTRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ServiceChainNFTSession struct

+ CallOpts bind.CallOpts

+ Contract *ServiceChainNFT

+ TransactOpts bind.TransactOpts

+ func (_ServiceChainNFT *ServiceChainNFTSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) BalanceOf(owner common.Address) (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) Bridge() (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) Burn(tokenId *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) GetApproved(tokenId *big.Int) (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) IsMinter(account common.Address) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) IsOwner() (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) MintWithTokenURI(to common.Address, tokenId *big.Int, tokenURI string) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) Name() (string, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) Owner() (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) OwnerOf(tokenId *big.Int) (common.Address, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) RegisterBulk(_user common.Address, _startID *big.Int, _endID *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) RenounceMinter() (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) RequestValueTransfer(_uid *big.Int, _to common.Address, _extraData []*big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) SetBridge(_bridge common.Address) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) SupportsInterface(interfaceId [4]byte) (bool, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) Symbol() (string, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) TokenByIndex(index *big.Int) (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) TokenURI(tokenId *big.Int) (string, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) TotalSupply() (*big.Int, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type ServiceChainNFTTransactor struct

+ func NewServiceChainNFTTransactor(address common.Address, transactor bind.ContractTransactor) (*ServiceChainNFTTransactor, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) Burn(opts *bind.TransactOpts, tokenId *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) MintWithTokenURI(opts *bind.TransactOpts, to common.Address, tokenId *big.Int, tokenURI string) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) RegisterBulk(opts *bind.TransactOpts, _user common.Address, _startID *big.Int, ...) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) RequestValueTransfer(opts *bind.TransactOpts, _uid *big.Int, _to common.Address, ...) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) SetBridge(opts *bind.TransactOpts, _bridge common.Address) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, ...) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type ServiceChainNFTTransactorRaw struct

+ Contract *ServiceChainNFTTransactor

+ func (_ServiceChainNFT *ServiceChainNFTTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ServiceChainNFTTransactorSession struct

+ Contract *ServiceChainNFTTransactor

+ TransactOpts bind.TransactOpts

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) AddMinter(account common.Address) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) Burn(tokenId *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) MintWithTokenURI(to common.Address, tokenId *big.Int, tokenURI string) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) RegisterBulk(_user common.Address, _startID *big.Int, _endID *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) RenounceMinter() (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) RequestValueTransfer(_uid *big.Int, _to common.Address, _extraData []*big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) SetBridge(_bridge common.Address) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error)

+ func (_ServiceChainNFT *ServiceChainNFTTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type ServiceChainNFTTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ TokenId *big.Int

+ type ServiceChainNFTTransferIterator struct

+ Event *ServiceChainNFTTransfer

+ func (it *ServiceChainNFTTransferIterator) Close() error

+ func (it *ServiceChainNFTTransferIterator) Error() error

+ func (it *ServiceChainNFTTransferIterator) Next() bool

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL