nft

package
v0.0.0-...-c21ee82 Latest Latest
Warning

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

 Go to latest Published: Sep 5, 2024 License: GPL-3.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	AddSignatureFactHint = hint.MustNewHint("mitum-nft-add-signature-operation-fact-v0.0.1")
	AddSignatureHint     = hint.MustNewHint("mitum-nft-add-signature-operation-v0.0.1")
)
View Source 
var (
	ApproveFactHint = hint.MustNewHint("mitum-nft-approve-operation-fact-v0.0.1")
	ApproveHint     = hint.MustNewHint("mitum-nft-approve-operation-v0.0.1")
)
View Source 
var (
	ApproveAllFactHint = hint.MustNewHint("mitum-nft-approve-all-operation-fact-v0.0.1")
	ApproveAllHint     = hint.MustNewHint("mitum-nft-approve-all-operation-v0.0.1")
)
View Source 
var (
	ApproveAllAllow  = ApproveAllMode("allow")
	ApproveAllCancel = ApproveAllMode("cancel")
)
View Source 
var (
	MintFactHint = hint.MustNewHint("mitum-nft-mint-operation-fact-v0.0.1")
	MintHint     = hint.MustNewHint("mitum-nft-mint-operation-v0.0.1")
)
View Source 
var (
	RegisterModelFactHint = hint.MustNewHint("mitum-nft-register-model-operation-fact-v0.0.1")
	RegisterModelHint     = hint.MustNewHint("mitum-nft-register-model-operation-v0.0.1")
)
View Source 
var (
	TransferFactHint = hint.MustNewHint("mitum-nft-transfer-operation-fact-v0.0.1")
	TransferHint     = hint.MustNewHint("mitum-nft-transfer-operation-v0.0.1")
)
View Source 
var (
	UpdateModelConfigFactHint = hint.MustNewHint("mitum-nft-update-model-config-operation-fact-v0.0.1")
	UpdateModelConfigHint     = hint.MustNewHint("mitum-nft-update-model-config-operation-v0.0.1")
)
View Source 
var AddSignatureItemHint = hint.MustNewHint("mitum-nft-add-signature-item-v0.0.1")
View Source 
var ApproveAllItemHint = hint.MustNewHint("mitum-nft-approve-all-item-v0.0.1")
View Source 
var ApproveItemHint = hint.MustNewHint("mitum-nft-approve-item-v0.0.1")
View Source 
var MaxAddSignatureItems = 100
View Source 
var MaxApproveAllItems = 100
View Source 
var MaxApproveItems = 100
View Source 
var MaxMintItems = 100
View Source 
var MaxTransferItems = 100
View Source 
var MintItemHint = hint.MustNewHint("mitum-nft-mint-item-v0.0.1")
View Source 
var TransferItemHint = hint.MustNewHint("mitum-nft-transfer-item-v0.0.1")

Functions

func CalculateCollectionItemsFee 

func CalculateCollectionItemsFee(getStateFunc mitumbase.GetStateFunc, items []CollectionItem) (
	map[currencytypes.CurrencyID]mitumbase.State, map[currencytypes.CurrencyID][2]common.Big, error)

func NewApproveProcessor 

func NewApproveProcessor() currencytypes.GetNewProcessor

func NewDelegateProcessor 

func NewDelegateProcessor() currencytypes.GetNewProcessor

func NewMintProcessor 

func NewMintProcessor() currencytypes.GetNewProcessor

func NewRegisterModelProcessor 

func NewRegisterModelProcessor() ctypes.GetNewProcessor

func NewSignProcessor 

func NewSignProcessor() currencytypes.GetNewProcessor

func NewTransferProcessor 

func NewTransferProcessor() currencytypes.GetNewProcessor

func NewUpdateModelConfigProcessor 

func NewUpdateModelConfigProcessor() currencytypes.GetNewProcessor

Types

type AddSignature 

type AddSignature struct {
	common.BaseOperation
}

func NewSign 

func NewSign(fact AddSignatureFact) (AddSignature, error)

func (*AddSignature) DecodeBSON 

func (op *AddSignature) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*AddSignature) DecodeJSON 

func (op *AddSignature) DecodeJSON(b []byte, enc encoder.Encoder) error

func (AddSignature) MarshalBSON 

func (op AddSignature) MarshalBSON() ([]byte, error)

func (AddSignature) MarshalJSON 

func (op AddSignature) MarshalJSON() ([]byte, error)

func (AddSignature) Process 

func (AddSignature) Process(
	_ context.Context, _ mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error)

type AddSignatureFact 

type AddSignatureFact struct {
	mitumbase.BaseFact
	// contains filtered or unexported fields
}

func NewAddSignatureFact 

func NewAddSignatureFact(token []byte, sender mitumbase.Address, items []AddSignatureItem) AddSignatureFact

func (AddSignatureFact) Addresses 

func (fact AddSignatureFact) Addresses() ([]mitumbase.Address, error)

func (AddSignatureFact) Bytes 

func (fact AddSignatureFact) Bytes() []byte

func (*AddSignatureFact) DecodeBSON 

func (fact *AddSignatureFact) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*AddSignatureFact) DecodeJSON 

func (fact *AddSignatureFact) DecodeJSON(b []byte, enc encoder.Encoder) error

func (AddSignatureFact) GenerateHash 

func (fact AddSignatureFact) GenerateHash() util.Hash

func (AddSignatureFact) Hash 

func (fact AddSignatureFact) Hash() util.Hash

func (AddSignatureFact) IsValid 

func (fact AddSignatureFact) IsValid(b []byte) error

func (AddSignatureFact) Items 

func (fact AddSignatureFact) Items() []AddSignatureItem

func (AddSignatureFact) MarshalBSON 

func (fact AddSignatureFact) MarshalBSON() ([]byte, error)

func (AddSignatureFact) MarshalJSON 

func (fact AddSignatureFact) MarshalJSON() ([]byte, error)

func (AddSignatureFact) Sender 

func (fact AddSignatureFact) Sender() mitumbase.Address

func (AddSignatureFact) Token 

func (fact AddSignatureFact) Token() mitumbase.Token

type AddSignatureFactBSONUnmarshaler 

type AddSignatureFactBSONUnmarshaler struct {
	Hint   string   `bson:"_hint"`
	Sender string   `bson:"sender"`
	Items  bson.Raw `bson:"items"`
}

type AddSignatureFactJSONMarshaler 

type AddSignatureFactJSONMarshaler struct {
	mitumbase.BaseFactJSONMarshaler
	Sender mitumbase.Address  `json:"sender"`
	Items  []AddSignatureItem `json:"items"`
}

type AddSignatureFactJSONUnmarshaler 

type AddSignatureFactJSONUnmarshaler struct {
	mitumbase.BaseFactJSONUnmarshaler
	Sender string          `json:"sender"`
	Items  json.RawMessage `json:"items"`
}

type AddSignatureItem 

type AddSignatureItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

func NewAddSignatureItem 

func NewAddSignatureItem(contract mitumbase.Address, nfxIdx uint64, currency types.CurrencyID) AddSignatureItem

func (AddSignatureItem) Bytes 

func (it AddSignatureItem) Bytes() []byte

func (AddSignatureItem) Contract 

func (it AddSignatureItem) Contract() mitumbase.Address

func (AddSignatureItem) Currency 

func (it AddSignatureItem) Currency() types.CurrencyID

func (*AddSignatureItem) DecodeBSON 

func (it *AddSignatureItem) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*AddSignatureItem) DecodeJSON 

func (it *AddSignatureItem) DecodeJSON(b []byte, enc encoder.Encoder) error

func (AddSignatureItem) IsValid 

func (it AddSignatureItem) IsValid([]byte) error

func (AddSignatureItem) MarshalBSON 

func (it AddSignatureItem) MarshalBSON() ([]byte, error)

func (AddSignatureItem) MarshalJSON 

func (it AddSignatureItem) MarshalJSON() ([]byte, error)

func (AddSignatureItem) NFT 

func (it AddSignatureItem) NFT() uint64

type AddSignatureItemBSONUnmarshaler 

type AddSignatureItemBSONUnmarshaler struct {
	Hint     string `bson:"_hint"`
	Contract string `bson:"contract"`
	NFTIdx   uint64 `bson:"nft_idx"`
	Currency string `bson:"currency"`
}

type AddSignatureItemJSONMarshaler 

type AddSignatureItemJSONMarshaler struct {
	hint.BaseHinter
	Contract mitumbase.Address `json:"contract"`
	NFTIdx   uint64            `json:"nft_idx"`
	Currency types.CurrencyID  `json:"currency"`
}

type AddSignatureItemJSONUnmarshaler 

type AddSignatureItemJSONUnmarshaler struct {
	Hint     hint.Hint `json:"_hint"`
	Contract string    `json:"contract"`
	NFTIdx   uint64    `json:"nft_idx"`
	Currency string    `json:"currency"`
}

type AddSignatureMarshaler 

type AddSignatureMarshaler struct {
	common.BaseOperationJSONMarshaler
}

type Approve 

type Approve struct {
	common.BaseOperation
}

func NewApprove 

func NewApprove(fact ApproveFact) (Approve, error)

func (*Approve) DecodeBSON 

func (op *Approve) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*Approve) DecodeJSON 

func (op *Approve) DecodeJSON(b []byte, enc encoder.Encoder) error

func (Approve) MarshalBSON 

func (op Approve) MarshalBSON() ([]byte, error)

func (Approve) MarshalJSON 

func (op Approve) MarshalJSON() ([]byte, error)

func (Approve) Process 

func (Approve) Process(
	_ context.Context, _ mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error)

type ApproveAll 

type ApproveAll struct {
	common.BaseOperation
}

func NewDelegate 

func NewDelegate(fact ApproveAllFact) (ApproveAll, error)

func (*ApproveAll) DecodeBSON 

func (op *ApproveAll) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*ApproveAll) DecodeJSON 

func (op *ApproveAll) DecodeJSON(b []byte, enc encoder.Encoder) error

func (ApproveAll) MarshalBSON 

func (op ApproveAll) MarshalBSON() ([]byte, error)

func (ApproveAll) MarshalJSON 

func (op ApproveAll) MarshalJSON() ([]byte, error)

func (ApproveAll) Process 

func (ApproveAll) Process(
	_ context.Context, _ mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error)

type ApproveAllFact 

type ApproveAllFact struct {
	mitumbase.BaseFact
	// contains filtered or unexported fields
}

func NewApproveAllFact 

func NewApproveAllFact(token []byte, sender mitumbase.Address, items []ApproveAllItem) ApproveAllFact

func (ApproveAllFact) Addresses 

func (fact ApproveAllFact) Addresses() ([]mitumbase.Address, error)

func (ApproveAllFact) Bytes 

func (fact ApproveAllFact) Bytes() []byte

func (*ApproveAllFact) DecodeBSON 

func (fact *ApproveAllFact) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*ApproveAllFact) DecodeJSON 

func (fact *ApproveAllFact) DecodeJSON(b []byte, enc encoder.Encoder) error

func (ApproveAllFact) GenerateHash 

func (fact ApproveAllFact) GenerateHash() util.Hash

func (ApproveAllFact) Hash 

func (fact ApproveAllFact) Hash() util.Hash

func (ApproveAllFact) IsValid 

func (fact ApproveAllFact) IsValid(b []byte) error

func (ApproveAllFact) Items 

func (fact ApproveAllFact) Items() []ApproveAllItem

func (ApproveAllFact) MarshalBSON 

func (fact ApproveAllFact) MarshalBSON() ([]byte, error)

func (ApproveAllFact) MarshalJSON 

func (fact ApproveAllFact) MarshalJSON() ([]byte, error)

func (ApproveAllFact) Sender 

func (fact ApproveAllFact) Sender() mitumbase.Address

func (ApproveAllFact) Token 

func (fact ApproveAllFact) Token() mitumbase.Token

type ApproveAllFactBSONUnmarshaler 

type ApproveAllFactBSONUnmarshaler struct {
	Hint   string   `bson:"_hint"`
	Sender string   `bson:"sender"`
	Items  bson.Raw `bson:"items"`
}

type ApproveAllFactJSONMarshaler 

type ApproveAllFactJSONMarshaler struct {
	mitumbase.BaseFactJSONMarshaler
	Sender mitumbase.Address `json:"sender"`
	Items  []ApproveAllItem  `json:"items"`
}

type ApproveAllFactJSONUnmarshaler 

type ApproveAllFactJSONUnmarshaler struct {
	mitumbase.BaseFactJSONUnmarshaler
	Sender string          `json:"sender"`
	Items  json.RawMessage `json:"items"`
}

type ApproveAllItem 

type ApproveAllItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

func NewApproveAllItem 

func NewApproveAllItem(
	contract mitumbase.Address, approved mitumbase.Address, mode ApproveAllMode, currency types.CurrencyID) ApproveAllItem

func (ApproveAllItem) Addresses 

func (it ApproveAllItem) Addresses() ([]mitumbase.Address, error)

func (ApproveAllItem) Approved 

func (it ApproveAllItem) Approved() mitumbase.Address

func (ApproveAllItem) Bytes 

func (it ApproveAllItem) Bytes() []byte

func (ApproveAllItem) Contract 

func (it ApproveAllItem) Contract() mitumbase.Address

func (ApproveAllItem) Currency 

func (it ApproveAllItem) Currency() types.CurrencyID

func (*ApproveAllItem) DecodeBSON 

func (it *ApproveAllItem) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*ApproveAllItem) DecodeJSON 

func (it *ApproveAllItem) DecodeJSON(b []byte, enc encoder.Encoder) error

func (ApproveAllItem) IsValid 

func (it ApproveAllItem) IsValid([]byte) error

func (ApproveAllItem) MarshalBSON 

func (it ApproveAllItem) MarshalBSON() ([]byte, error)

func (ApproveAllItem) MarshalJSON 

func (it ApproveAllItem) MarshalJSON() ([]byte, error)

func (ApproveAllItem) Mode 

func (it ApproveAllItem) Mode() ApproveAllMode

type ApproveAllItemJSONMarshaler 

type ApproveAllItemJSONMarshaler struct {
	hint.BaseHinter
	Contract mitumbase.Address `json:"contract"`
	Approved mitumbase.Address `json:"approved"`
	Mode     ApproveAllMode    `json:"mode"`
	Currency types.CurrencyID  `json:"currency"`
}

type ApproveAllItemJSONUnmarshaler 

type ApproveAllItemJSONUnmarshaler struct {
	Hint     hint.Hint `json:"_hint"`
	Contract string    `json:"contract"`
	Approved string    `json:"approved"`
	Mode     string    `json:"mode"`
	Currency string    `json:"currency"`
}

type ApproveAllMarshaler 

type ApproveAllMarshaler struct {
	common.BaseOperationJSONMarshaler
}

type ApproveAllMode 

type ApproveAllMode string

func (ApproveAllMode) Bytes 

func (mode ApproveAllMode) Bytes() []byte

func (ApproveAllMode) Equal 

func (mode ApproveAllMode) Equal(cmode ApproveAllMode) bool

func (ApproveAllMode) IsValid 

func (mode ApproveAllMode) IsValid([]byte) error

func (ApproveAllMode) String 

func (mode ApproveAllMode) String() string

type ApproveFact 

type ApproveFact struct {
	mitumbase.BaseFact
	// contains filtered or unexported fields
}

func NewApproveFact 

func NewApproveFact(token []byte, sender mitumbase.Address, items []ApproveItem) ApproveFact

func (ApproveFact) Addresses 

func (fact ApproveFact) Addresses() ([]mitumbase.Address, error)

func (ApproveFact) Bytes 

func (fact ApproveFact) Bytes() []byte

func (*ApproveFact) DecodeBSON 

func (fact *ApproveFact) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*ApproveFact) DecodeJSON 

func (fact *ApproveFact) DecodeJSON(b []byte, enc encoder.Encoder) error

func (ApproveFact) GenerateHash 

func (fact ApproveFact) GenerateHash() util.Hash

func (ApproveFact) Hash 

func (fact ApproveFact) Hash() util.Hash

func (ApproveFact) IsValid 

func (fact ApproveFact) IsValid(b []byte) error

func (ApproveFact) Items 

func (fact ApproveFact) Items() []ApproveItem

func (ApproveFact) MarshalBSON 

func (fact ApproveFact) MarshalBSON() ([]byte, error)

func (ApproveFact) MarshalJSON 

func (fact ApproveFact) MarshalJSON() ([]byte, error)

func (ApproveFact) Sender 

func (fact ApproveFact) Sender() mitumbase.Address

func (ApproveFact) Token 

func (fact ApproveFact) Token() mitumbase.Token

type ApproveFactBSONUnmarshaler 

type ApproveFactBSONUnmarshaler struct {
	Hint   string   `bson:"_hint"`
	Sender string   `bson:"sender"`
	Items  bson.Raw `bson:"items"`
}

type ApproveFactJSONMarshaler 

type ApproveFactJSONMarshaler struct {
	mitumbase.BaseFactJSONMarshaler
	Sender mitumbase.Address `json:"sender"`
	Items  []ApproveItem     `json:"items"`
}

type ApproveFactJSONUnmarshaler 

type ApproveFactJSONUnmarshaler struct {
	mitumbase.BaseFactJSONUnmarshaler
	Sender string          `json:"sender"`
	Items  json.RawMessage `json:"items"`
}

type ApproveItem 

type ApproveItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

func NewApproveItem 

func NewApproveItem(
	contract mitumbase.Address, approved mitumbase.Address, nftIdx uint64, currency types.CurrencyID) ApproveItem

func (ApproveItem) Addresses 

func (it ApproveItem) Addresses() ([]mitumbase.Address, error)

func (ApproveItem) Approved 

func (it ApproveItem) Approved() mitumbase.Address

func (ApproveItem) Bytes 

func (it ApproveItem) Bytes() []byte

func (ApproveItem) Contract 

func (it ApproveItem) Contract() mitumbase.Address

func (ApproveItem) Currency 

func (it ApproveItem) Currency() types.CurrencyID

func (*ApproveItem) DecodeBSON 

func (it *ApproveItem) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*ApproveItem) DecodeJSON 

func (it *ApproveItem) DecodeJSON(b []byte, enc encoder.Encoder) error

func (ApproveItem) IsValid 

func (it ApproveItem) IsValid([]byte) error

func (ApproveItem) MarshalBSON 

func (it ApproveItem) MarshalBSON() ([]byte, error)

func (ApproveItem) MarshalJSON 

func (it ApproveItem) MarshalJSON() ([]byte, error)

func (ApproveItem) NFTIdx 

func (it ApproveItem) NFTIdx() uint64

type ApproveItemBSONUnmarshaler 

type ApproveItemBSONUnmarshaler struct {
	Hint     string `bson:"_hint"`
	Contract string `bson:"contract"`
	Approved string `bson:"approved"`
	NFTIdx   uint64 `bson:"nft_idx"`
	Currency string `bson:"currency"`
}

type ApproveItemJSONMarshaler 

type ApproveItemJSONMarshaler struct {
	hint.BaseHinter
	Contract mitumbase.Address `json:"contract"`
	Approved mitumbase.Address `json:"approved"`
	NFTIdx   uint64            `json:"nft_idx"`
	Currency types.CurrencyID  `json:"currency"`
}

type ApproveItemJSONUnmarshaler 

type ApproveItemJSONUnmarshaler struct {
	Hint     hint.Hint `json:"_hint"`
	Contract string    `json:"contract"`
	Approved string    `json:"approved"`
	NFTIdx   uint64    `json:"nft_idx"`
	Currency string    `json:"currency"`
}

type ApproveItemProcessor 

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

func (*ApproveItemProcessor) Close 

func (ipp *ApproveItemProcessor) Close()

func (*ApproveItemProcessor) PreProcess 

func (ipp *ApproveItemProcessor) PreProcess(
	_ context.Context, _ mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) error

func (*ApproveItemProcessor) Process 

func (ipp *ApproveItemProcessor) Process(
	_ context.Context, _ mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, error)

type ApproveProcessor 

type ApproveProcessor struct {
	*mitumbase.BaseOperationProcessor
}

func (*ApproveProcessor) Close 

func (opp *ApproveProcessor) Close() error

func (*ApproveProcessor) PreProcess 

func (opp *ApproveProcessor) PreProcess(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) (context.Context, mitumbase.OperationProcessReasonError, error)

func (*ApproveProcessor) Process 

func (opp *ApproveProcessor) Process(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc) (
	[]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error,
)

type CollectionItem 

type CollectionItem interface {
	util.Byter
	util.IsValider
	Currency() currencytypes.CurrencyID
}

type DelegateItemBSONUnmarshaler 

type DelegateItemBSONUnmarshaler struct {
	Hint     string `bson:"_hint"`
	Contract string `bson:"contract"`
	Approved string `bson:"approved"`
	Mode     string `bson:"mode"`
	Currency string `bson:"currency"`
}

type DelegateItemProcessor 

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

func (*DelegateItemProcessor) Close 

func (ipp *DelegateItemProcessor) Close()

func (*DelegateItemProcessor) PreProcess 

func (ipp *DelegateItemProcessor) PreProcess(
	_ context.Context, _ mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) error

func (*DelegateItemProcessor) Process 

func (ipp *DelegateItemProcessor) Process(
	_ context.Context, _ mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, error)

type DelegateProcessor 

type DelegateProcessor struct {
	*mitumbase.BaseOperationProcessor
}

func (*DelegateProcessor) Close 

func (opp *DelegateProcessor) Close() error

func (*DelegateProcessor) PreProcess 

func (opp *DelegateProcessor) PreProcess(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) (context.Context, mitumbase.OperationProcessReasonError, error)

func (*DelegateProcessor) Process 

func (opp *DelegateProcessor) Process(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc) (
	[]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error,
)

type Mint 

type Mint struct {
	common.BaseOperation
}

func NewMint 

func NewMint(fact MintFact) (Mint, error)

func (*Mint) DecodeBSON 

func (op *Mint) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*Mint) DecodeJSON 

func (op *Mint) DecodeJSON(b []byte, enc encoder.Encoder) error

func (Mint) MarshalBSON 

func (op Mint) MarshalBSON() ([]byte, error)

func (Mint) MarshalJSON 

func (op Mint) MarshalJSON() ([]byte, error)

func (Mint) Process 

func (Mint) Process(
	_ context.Context, _ base.GetStateFunc,
) ([]base.StateMergeValue, base.OperationProcessReasonError, error)

type MintFact 

type MintFact struct {
	mitumbase.BaseFact
	// contains filtered or unexported fields
}

func NewMintFact 

func NewMintFact(token []byte, sender mitumbase.Address, items []MintItem) MintFact

func (MintFact) Addresses 

func (fact MintFact) Addresses() ([]mitumbase.Address, error)

func (MintFact) Bytes 

func (fact MintFact) Bytes() []byte

func (*MintFact) DecodeBSON 

func (fact *MintFact) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*MintFact) DecodeJSON 

func (fact *MintFact) DecodeJSON(b []byte, enc encoder.Encoder) error

func (MintFact) GenerateHash 

func (fact MintFact) GenerateHash() util.Hash

func (MintFact) Hash 

func (fact MintFact) Hash() util.Hash

func (MintFact) IsValid 

func (fact MintFact) IsValid(b []byte) error

func (MintFact) Items 

func (fact MintFact) Items() []MintItem

func (MintFact) MarshalBSON 

func (fact MintFact) MarshalBSON() ([]byte, error)

func (MintFact) MarshalJSON 

func (fact MintFact) MarshalJSON() ([]byte, error)

func (MintFact) Sender 

func (fact MintFact) Sender() mitumbase.Address

func (MintFact) Token 

func (fact MintFact) Token() mitumbase.Token

type MintFactBSONUnmarshaler 

type MintFactBSONUnmarshaler struct {
	Hint   string   `bson:"_hint"`
	Sender string   `bson:"sender"`
	Items  bson.Raw `bson:"items"`
}

type MintFactJSONMarshaler 

type MintFactJSONMarshaler struct {
	mitumbase.BaseFactJSONMarshaler
	Sender mitumbase.Address `json:"sender"`
	Items  []MintItem        `json:"items"`
}

type MintFactJSONUnmarshaler 

type MintFactJSONUnmarshaler struct {
	mitumbase.BaseFactJSONUnmarshaler
	Sender string          `json:"sender"`
	Items  json.RawMessage `json:"items"`
}

type MintItem 

type MintItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

func NewMintItem 

func NewMintItem(
	contract mitumbase.Address,
	receiver mitumbase.Address,
	hash types.NFTHash,
	uri types.URI,
	creators types.Signers,
	currency currencytypes.CurrencyID,
) MintItem

func (MintItem) Addresses 

func (it MintItem) Addresses() ([]mitumbase.Address, error)

func (MintItem) Bytes 

func (it MintItem) Bytes() []byte

func (MintItem) Contract 

func (it MintItem) Contract() mitumbase.Address

func (MintItem) Creators 

func (it MintItem) Creators() types.Signers

func (MintItem) Currency 

func (it MintItem) Currency() currencytypes.CurrencyID

func (*MintItem) DecodeBSON 

func (it *MintItem) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*MintItem) DecodeJSON 

func (it *MintItem) DecodeJSON(b []byte, enc encoder.Encoder) error

func (MintItem) IsValid 

func (it MintItem) IsValid([]byte) error

func (MintItem) MarshalBSON 

func (it MintItem) MarshalBSON() ([]byte, error)

func (MintItem) MarshalJSON 

func (it MintItem) MarshalJSON() ([]byte, error)

func (MintItem) NFTHash 

func (it MintItem) NFTHash() types.NFTHash

func (MintItem) Receiver 

func (it MintItem) Receiver() mitumbase.Address

func (MintItem) URI 

func (it MintItem) URI() types.URI

type MintItemBSONUnmarshaler 

type MintItemBSONUnmarshaler struct {
	Hint     string   `bson:"_hint"`
	Contract string   `bson:"contract"`
	Receiver string   `bson:"receiver"`
	Hash     string   `bson:"hash"`
	Uri      string   `bson:"uri"`
	Creators bson.Raw `bson:"creators"`
	Currency string   `bson:"currency"`
}

type MintItemJSONMarshaler 

type MintItemJSONMarshaler struct {
	hint.BaseHinter
	Contract mitumbase.Address        `json:"contract"`
	Receiver mitumbase.Address        `json:"receiver"`
	Hash     types.NFTHash            `json:"hash"`
	Uri      types.URI                `json:"uri"`
	Creators types.Signers            `json:"creators"`
	Currency currencytypes.CurrencyID `json:"currency"`
}

type MintItemJSONUnmarshaler 

type MintItemJSONUnmarshaler struct {
	Hint     hint.Hint       `json:"_hint"`
	Contract string          `json:"contract"`
	Receiver string          `json:"receiver"`
	Hash     string          `json:"hash"`
	Uri      string          `json:"uri"`
	Creators json.RawMessage `json:"creators"`
	Currency string          `json:"currency"`
}

type MintItemProcessor 

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

func (*MintItemProcessor) Close 

func (ipp *MintItemProcessor) Close()

func (*MintItemProcessor) PreProcess 

func (ipp *MintItemProcessor) PreProcess(
	_ context.Context, _ base.Operation, getStateFunc base.GetStateFunc,
) error

func (*MintItemProcessor) Process 

func (ipp *MintItemProcessor) Process(
	_ context.Context, _ base.Operation, getStateFunc base.GetStateFunc,
) ([]base.StateMergeValue, error)

type MintProcessor 

type MintProcessor struct {
	*base.BaseOperationProcessor
}

func (*MintProcessor) Close 

func (opp *MintProcessor) Close() error

func (*MintProcessor) PreProcess 

func (opp *MintProcessor) PreProcess(
	ctx context.Context, op base.Operation, getStateFunc base.GetStateFunc,
) (context.Context, base.OperationProcessReasonError, error)

func (*MintProcessor) Process 

func (opp *MintProcessor) Process(
	ctx context.Context, op base.Operation, getStateFunc base.GetStateFunc) (
	[]base.StateMergeValue, base.OperationProcessReasonError, error,
)

type RegisterModel 

type RegisterModel struct {
	common.BaseOperation
}

func NewRegisterModel 

func NewRegisterModel(fact RegisterModelFact) (RegisterModel, error)

func (*RegisterModel) DecodeBSON 

func (op *RegisterModel) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*RegisterModel) DecodeJSON 

func (op *RegisterModel) DecodeJSON(b []byte, enc encoder.Encoder) error

func (RegisterModel) MarshalBSON 

func (op RegisterModel) MarshalBSON() ([]byte, error)

func (RegisterModel) MarshalJSON 

func (op RegisterModel) MarshalJSON() ([]byte, error)

func (RegisterModel) Process 

func (RegisterModel) Process(
	_ context.Context, _ mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error)

type RegisterModelFact 

type RegisterModelFact struct {
	base.BaseFact
	// contains filtered or unexported fields
}

func NewRegisterModelFact 

func NewRegisterModelFact(
	token []byte,
	sender base.Address,
	contract base.Address,
	name types.CollectionName,
	royalty types.PaymentParameter,
	uri types.URI,
	whitelist []base.Address,
	currency currencytypes.CurrencyID,
) RegisterModelFact

func (RegisterModelFact) Addresses 

func (fact RegisterModelFact) Addresses() ([]base.Address, error)

func (RegisterModelFact) Bytes 

func (fact RegisterModelFact) Bytes() []byte

func (RegisterModelFact) Contract 

func (fact RegisterModelFact) Contract() base.Address

func (RegisterModelFact) Currency 

func (fact RegisterModelFact) Currency() currencytypes.CurrencyID

func (*RegisterModelFact) DecodeBSON 

func (fact *RegisterModelFact) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*RegisterModelFact) DecodeJSON 

func (fact *RegisterModelFact) DecodeJSON(b []byte, enc encoder.Encoder) error

func (RegisterModelFact) GenerateHash 

func (fact RegisterModelFact) GenerateHash() util.Hash

func (RegisterModelFact) Hash 

func (fact RegisterModelFact) Hash() util.Hash

func (RegisterModelFact) IsValid 

func (fact RegisterModelFact) IsValid(b []byte) error

func (RegisterModelFact) MarshalBSON 

func (fact RegisterModelFact) MarshalBSON() ([]byte, error)

func (RegisterModelFact) MarshalJSON 

func (fact RegisterModelFact) MarshalJSON() ([]byte, error)

func (RegisterModelFact) Name 

func (fact RegisterModelFact) Name() types.CollectionName

func (RegisterModelFact) Royalty 

func (fact RegisterModelFact) Royalty() types.PaymentParameter

func (RegisterModelFact) Sender 

func (fact RegisterModelFact) Sender() base.Address

func (RegisterModelFact) Token 

func (fact RegisterModelFact) Token() base.Token

func (RegisterModelFact) URI 

func (fact RegisterModelFact) URI() types.URI

func (RegisterModelFact) WhiteList 

func (fact RegisterModelFact) WhiteList() []base.Address

type RegisterModelFactBSONUnmarshaler 

type RegisterModelFactBSONUnmarshaler struct {
	Hint      string   `bson:"_hint"`
	Sender    string   `bson:"sender"`
	Contract  string   `bson:"contract"`
	Name      string   `bson:"name"`
	Royalty   uint     `bson:"royalty"`
	URI       string   `bson:"uri"`
	Whitelist []string `bson:"minter_whitelist"`
	Currency  string   `bson:"currency"`
}

type RegisterModelFactJSONMarshaler 

type RegisterModelFactJSONMarshaler struct {
	mitumbase.BaseFactJSONMarshaler
	Sender    mitumbase.Address        `json:"sender"`
	Contract  mitumbase.Address        `json:"contract"`
	Name      types.CollectionName     `json:"name"`
	Royalty   types.PaymentParameter   `json:"royalty"`
	URI       types.URI                `json:"uri"`
	Whitelist []mitumbase.Address      `json:"minter_whitelist"`
	Currency  currencytypes.CurrencyID `json:"currency"`
}

type RegisterModelFactJSONUnmarshaler 

type RegisterModelFactJSONUnmarshaler struct {
	mitumbase.BaseFactJSONUnmarshaler
	Sender    string   `json:"sender"`
	Contract  string   `json:"contract"`
	Name      string   `json:"name"`
	Royalty   uint     `json:"royalty"`
	URI       string   `json:"uri"`
	Whitelist []string `json:"minter_whitelist"`
	Currency  string   `json:"currency"`
}

type RegisterModelMarshaler 

type RegisterModelMarshaler struct {
	common.BaseOperationJSONMarshaler
}

type RegisterModelProcessor 

type RegisterModelProcessor struct {
	*mitumbase.BaseOperationProcessor
}

func (*RegisterModelProcessor) Close 

func (opp *RegisterModelProcessor) Close() error

func (*RegisterModelProcessor) PreProcess 

func (opp *RegisterModelProcessor) PreProcess(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) (context.Context, mitumbase.OperationProcessReasonError, error)

func (*RegisterModelProcessor) Process 

func (opp *RegisterModelProcessor) Process(
	_ context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc) (
	[]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error,
)

type SignItemProcessor 

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

func (*SignItemProcessor) Close 

func (ipp *SignItemProcessor) Close()

func (*SignItemProcessor) PreProcess 

func (ipp *SignItemProcessor) PreProcess(
	_ context.Context, _ mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) error

func (*SignItemProcessor) Process 

func (ipp *SignItemProcessor) Process(
	_ context.Context, _ mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, error)

type SignProcessor 

type SignProcessor struct {
	*mitumbase.BaseOperationProcessor
}

func (*SignProcessor) Close 

func (opp *SignProcessor) Close() error

func (*SignProcessor) PreProcess 

func (opp *SignProcessor) PreProcess(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) (context.Context, mitumbase.OperationProcessReasonError, error)

func (*SignProcessor) Process 

func (opp *SignProcessor) Process(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc) (
	[]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error,
)

type TestApproveProcessor 

type TestApproveProcessor struct {
	*test.BaseTestOperationProcessorWithItem[Approve, ApproveItem]
	// contains filtered or unexported fields
}

func NewTestApproveProcessor 

func NewTestApproveProcessor(tp *test.TestProcessor) TestApproveProcessor

func (*TestApproveProcessor) Create 

func (t *TestApproveProcessor) Create() *TestApproveProcessor

func (*TestApproveProcessor) Decode 

func (t *TestApproveProcessor) Decode(fileName string) *TestApproveProcessor

func (*TestApproveProcessor) IsValid 

func (t *TestApproveProcessor) IsValid() *TestApproveProcessor

func (*TestApproveProcessor) LoadOperation 

func (t *TestApproveProcessor) LoadOperation(fileName string,
) *TestApproveProcessor

func (*TestApproveProcessor) MakeItem 

func (t *TestApproveProcessor) MakeItem(
	target test.Account, approved test.Account, idx uint64, currency types.CurrencyID, targetItems []ApproveItem,
) *TestApproveProcessor

func (*TestApproveProcessor) MakeOperation 

func (t *TestApproveProcessor) MakeOperation(
	sender base.Address, privatekey base.Privatekey, items []ApproveItem,
) *TestApproveProcessor

func (*TestApproveProcessor) Print 

func (t *TestApproveProcessor) Print(fileName string,
) *TestApproveProcessor

func (*TestApproveProcessor) RunPreProcess 

func (t *TestApproveProcessor) RunPreProcess() *TestApproveProcessor

func (*TestApproveProcessor) RunProcess 

func (t *TestApproveProcessor) RunProcess() *TestApproveProcessor

func (*TestApproveProcessor) SetAccount 

func (t *TestApproveProcessor) SetAccount(
	priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestApproveProcessor

func (*TestApproveProcessor) SetAmount 

func (t *TestApproveProcessor) SetAmount(
	am int64, cid types.CurrencyID, target []types.Amount,
) *TestApproveProcessor

func (*TestApproveProcessor) SetContractAccount 

func (t *TestApproveProcessor) SetContractAccount(
	owner base.Address, priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestApproveProcessor

func (*TestApproveProcessor) SetCurrency 

func (t *TestApproveProcessor) SetCurrency(
	cid string, am int64, addr base.Address, target []types.CurrencyID, instate bool,
) *TestApproveProcessor

func (*TestApproveProcessor) SetDesign 

func (t *TestApproveProcessor) SetDesign(
	name string,
	royalty uint,
	uri string,
) *TestApproveProcessor

func (*TestApproveProcessor) SetNFT 

func (t *TestApproveProcessor) SetNFT(contract, owner base.Address, nfthash, uri string, creators nfttypes.Signers) *TestApproveProcessor

func (*TestApproveProcessor) SetService 

func (t *TestApproveProcessor) SetService(
	sender, contract base.Address, whitelist []test.Account,
) *TestApproveProcessor

func (*TestApproveProcessor) SetSigner 

func (t *TestApproveProcessor) SetSigner(
	signer test.Account, share uint, signed bool, target []nfttypes.Signer,
) *TestApproveProcessor

func (*TestApproveProcessor) SetSigners 

func (t *TestApproveProcessor) SetSigners(
	signers []nfttypes.Signer, target []nfttypes.Signers,
) *TestApproveProcessor

type TestCreateCollectionProcessor 

type TestCreateCollectionProcessor struct {
	*test.BaseTestOperationProcessorNoItem[RegisterModel]
	// contains filtered or unexported fields
}

func NewTestCreateCollectionProcessor 

func NewTestCreateCollectionProcessor(tp *test.TestProcessor) TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) Create 

func (t *TestCreateCollectionProcessor) Create() *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) Decode 

func (t *TestCreateCollectionProcessor) Decode(fileName string) *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) IsValid 

func (t *TestCreateCollectionProcessor) IsValid() *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) LoadOperation 

func (t *TestCreateCollectionProcessor) LoadOperation(fileName string,
) *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) MakeOperation 

func (t *TestCreateCollectionProcessor) MakeOperation(
	sender base.Address, privatekey base.Privatekey, contract base.Address, whitelist []test.Account, currency types.CurrencyID,
) *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) Print 

func (t *TestCreateCollectionProcessor) Print(fileName string,
) *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) RunPreProcess 

func (t *TestCreateCollectionProcessor) RunPreProcess() *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) RunProcess 

func (t *TestCreateCollectionProcessor) RunProcess() *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) SetAccount 

func (t *TestCreateCollectionProcessor) SetAccount(
	priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) SetAmount 

func (t *TestCreateCollectionProcessor) SetAmount(
	am int64, cid types.CurrencyID, target []types.Amount,
) *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) SetContractAccount 

func (t *TestCreateCollectionProcessor) SetContractAccount(
	owner base.Address, priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) SetCurrency 

func (t *TestCreateCollectionProcessor) SetCurrency(
	cid string, am int64, addr base.Address, target []types.CurrencyID, instate bool,
) *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) SetDesign 

func (t *TestCreateCollectionProcessor) SetDesign(
	name string,
	royalty uint,
	uri string,
) *TestCreateCollectionProcessor

func (*TestCreateCollectionProcessor) SetService 

func (t *TestCreateCollectionProcessor) SetService(
	sender, contract base.Address, whitelist []test.Account,
) *TestCreateCollectionProcessor

type TestDelegateProcessor 

type TestDelegateProcessor struct {
	*test.BaseTestOperationProcessorWithItem[ApproveAll, ApproveAllItem]
	// contains filtered or unexported fields
}

func NewTestDelegateProcessor 

func NewTestDelegateProcessor(tp *test.TestProcessor) TestDelegateProcessor

func (*TestDelegateProcessor) Create 

func (t *TestDelegateProcessor) Create() *TestDelegateProcessor

func (*TestDelegateProcessor) Decode 

func (t *TestDelegateProcessor) Decode(fileName string) *TestDelegateProcessor

func (*TestDelegateProcessor) IsValid 

func (t *TestDelegateProcessor) IsValid() *TestDelegateProcessor

func (*TestDelegateProcessor) LoadOperation 

func (t *TestDelegateProcessor) LoadOperation(fileName string,
) *TestDelegateProcessor

func (*TestDelegateProcessor) MakeItem 

func (t *TestDelegateProcessor) MakeItem(
	target test.Account, operator test.Account, mode ApproveAllMode, currency types.CurrencyID, targetItems []ApproveAllItem,
) *TestDelegateProcessor

func (*TestDelegateProcessor) MakeOperation 

func (t *TestDelegateProcessor) MakeOperation(
	sender base.Address, privatekey base.Privatekey, items []ApproveAllItem,
) *TestDelegateProcessor

func (*TestDelegateProcessor) Print 

func (t *TestDelegateProcessor) Print(fileName string,
) *TestDelegateProcessor

func (*TestDelegateProcessor) RunPreProcess 

func (t *TestDelegateProcessor) RunPreProcess() *TestDelegateProcessor

func (*TestDelegateProcessor) RunProcess 

func (t *TestDelegateProcessor) RunProcess() *TestDelegateProcessor

func (*TestDelegateProcessor) SetAccount 

func (t *TestDelegateProcessor) SetAccount(
	priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestDelegateProcessor

func (*TestDelegateProcessor) SetAmount 

func (t *TestDelegateProcessor) SetAmount(
	am int64, cid types.CurrencyID, target []types.Amount,
) *TestDelegateProcessor

func (*TestDelegateProcessor) SetContractAccount 

func (t *TestDelegateProcessor) SetContractAccount(
	owner base.Address, priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestDelegateProcessor

func (*TestDelegateProcessor) SetCurrency 

func (t *TestDelegateProcessor) SetCurrency(
	cid string, am int64, addr base.Address, target []types.CurrencyID, instate bool,
) *TestDelegateProcessor

func (*TestDelegateProcessor) SetDesign 

func (t *TestDelegateProcessor) SetDesign(
	name string,
	royalty uint,
	uri string,
) *TestDelegateProcessor

func (*TestDelegateProcessor) SetNFT 

func (t *TestDelegateProcessor) SetNFT(contract, owner base.Address, nfthash, uri string, creators nfttypes.Signers) *TestDelegateProcessor

func (*TestDelegateProcessor) SetService 

func (t *TestDelegateProcessor) SetService(
	sender, contract base.Address, whitelist []test.Account,
) *TestDelegateProcessor

func (*TestDelegateProcessor) SetSigner 

func (t *TestDelegateProcessor) SetSigner(
	signer test.Account, share uint, signed bool, target []nfttypes.Signer,
) *TestDelegateProcessor

func (*TestDelegateProcessor) SetSigners 

func (t *TestDelegateProcessor) SetSigners(
	signers []nfttypes.Signer, target []nfttypes.Signers,
) *TestDelegateProcessor

type TestMintProcessor 

type TestMintProcessor struct {
	*test.BaseTestOperationProcessorWithItem[Mint, MintItem]
	// contains filtered or unexported fields
}

func NewTestMintProcessor 

func NewTestMintProcessor(tp *test.TestProcessor) TestMintProcessor

func (*TestMintProcessor) Create 

func (t *TestMintProcessor) Create() *TestMintProcessor

func (*TestMintProcessor) Decode 

func (t *TestMintProcessor) Decode(fileName string) *TestMintProcessor

func (*TestMintProcessor) IsValid 

func (t *TestMintProcessor) IsValid() *TestMintProcessor

func (*TestMintProcessor) LoadOperation 

func (t *TestMintProcessor) LoadOperation(fileName string,
) *TestMintProcessor

func (*TestMintProcessor) MakeItem 

func (t *TestMintProcessor) MakeItem(
	target test.Account, receiver test.Account, hash, uri string, creators nfttypes.Signers, currency types.CurrencyID,
	targetItems []MintItem,
) *TestMintProcessor

func (*TestMintProcessor) MakeOperation 

func (t *TestMintProcessor) MakeOperation(
	sender base.Address, privatekey base.Privatekey, items []MintItem,
) *TestMintProcessor

func (*TestMintProcessor) Print 

func (t *TestMintProcessor) Print(fileName string,
) *TestMintProcessor

func (*TestMintProcessor) RunPreProcess 

func (t *TestMintProcessor) RunPreProcess() *TestMintProcessor

func (*TestMintProcessor) RunProcess 

func (t *TestMintProcessor) RunProcess() *TestMintProcessor

func (*TestMintProcessor) SetAccount 

func (t *TestMintProcessor) SetAccount(
	priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestMintProcessor

func (*TestMintProcessor) SetAmount 

func (t *TestMintProcessor) SetAmount(
	am int64, cid types.CurrencyID, target []types.Amount,
) *TestMintProcessor

func (*TestMintProcessor) SetContractAccount 

func (t *TestMintProcessor) SetContractAccount(
	owner base.Address, priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestMintProcessor

func (*TestMintProcessor) SetCurrency 

func (t *TestMintProcessor) SetCurrency(
	cid string, am int64, addr base.Address, target []types.CurrencyID, instate bool,
) *TestMintProcessor

func (*TestMintProcessor) SetDesign 

func (t *TestMintProcessor) SetDesign(
	name string,
	royalty uint,
	uri string,
) *TestMintProcessor

func (*TestMintProcessor) SetNFT 

func (t *TestMintProcessor) SetNFT(contract, owner base.Address, nfthash, uri string, creators nfttypes.Signers) *TestMintProcessor

func (*TestMintProcessor) SetService 

func (t *TestMintProcessor) SetService(
	sender, contract base.Address, whitelist []test.Account,
) *TestMintProcessor

func (*TestMintProcessor) SetSigner 

func (t *TestMintProcessor) SetSigner(
	signer test.Account, share uint, signed bool, target []nfttypes.Signer,
) *TestMintProcessor

func (*TestMintProcessor) SetSigners 

func (t *TestMintProcessor) SetSigners(
	signers []nfttypes.Signer, target []nfttypes.Signers,
) *TestMintProcessor

type TestTransferProcessor 

type TestTransferProcessor struct {
	*test.BaseTestOperationProcessorWithItem[Transfer, TransferItem]
	// contains filtered or unexported fields
}

func NewTestTransferProcessor 

func NewTestTransferProcessor(tp *test.TestProcessor) TestTransferProcessor

func (*TestTransferProcessor) Create 

func (t *TestTransferProcessor) Create() *TestTransferProcessor

func (*TestTransferProcessor) Decode 

func (t *TestTransferProcessor) Decode(fileName string) *TestTransferProcessor

func (*TestTransferProcessor) IsValid 

func (t *TestTransferProcessor) IsValid() *TestTransferProcessor

func (*TestTransferProcessor) LoadOperation 

func (t *TestTransferProcessor) LoadOperation(fileName string,
) *TestTransferProcessor

func (*TestTransferProcessor) MakeItem 

func (t *TestTransferProcessor) MakeItem(
	target test.Account, receiver test.Account, nftID uint64, currency types.CurrencyID,
	targetItems []TransferItem,
) *TestTransferProcessor

func (*TestTransferProcessor) MakeOperation 

func (t *TestTransferProcessor) MakeOperation(
	sender base.Address, privatekey base.Privatekey, items []TransferItem,
) *TestTransferProcessor

func (*TestTransferProcessor) Print 

func (t *TestTransferProcessor) Print(fileName string,
) *TestTransferProcessor

func (*TestTransferProcessor) RunPreProcess 

func (t *TestTransferProcessor) RunPreProcess() *TestTransferProcessor

func (*TestTransferProcessor) RunProcess 

func (t *TestTransferProcessor) RunProcess() *TestTransferProcessor

func (*TestTransferProcessor) SetAccount 

func (t *TestTransferProcessor) SetAccount(
	priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestTransferProcessor

func (*TestTransferProcessor) SetAmount 

func (t *TestTransferProcessor) SetAmount(
	am int64, cid types.CurrencyID, target []types.Amount,
) *TestTransferProcessor

func (*TestTransferProcessor) SetContractAccount 

func (t *TestTransferProcessor) SetContractAccount(
	owner base.Address, priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestTransferProcessor

func (*TestTransferProcessor) SetCurrency 

func (t *TestTransferProcessor) SetCurrency(
	cid string, am int64, addr base.Address, target []types.CurrencyID, instate bool,
) *TestTransferProcessor

func (*TestTransferProcessor) SetDesign 

func (t *TestTransferProcessor) SetDesign(
	name string,
	royalty uint,
	uri string,
) *TestTransferProcessor

func (*TestTransferProcessor) SetNFT 

func (t *TestTransferProcessor) SetNFT(
	contract, owner base.Address, nfthash, uri string, creators nfttypes.Signers,
) *TestTransferProcessor

func (*TestTransferProcessor) SetService 

func (t *TestTransferProcessor) SetService(
	sender, contract base.Address, whitelist []test.Account,
) *TestTransferProcessor

func (*TestTransferProcessor) SetSigner 

func (t *TestTransferProcessor) SetSigner(
	signer test.Account, share uint, signed bool, target []nfttypes.Signer,
) *TestTransferProcessor

func (*TestTransferProcessor) SetSigners 

func (t *TestTransferProcessor) SetSigners(
	signers []nfttypes.Signer, target []nfttypes.Signers,
) *TestTransferProcessor

type TestUpdateCollectionPolicyProcessor 

type TestUpdateCollectionPolicyProcessor struct {
	*test.BaseTestOperationProcessorNoItem[UpdateModelConfig]
	// contains filtered or unexported fields
}

func NewTestUpdateCollectionPolicyProcessor 

func NewTestUpdateCollectionPolicyProcessor(tp *test.TestProcessor) TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) Create 

func (t *TestUpdateCollectionPolicyProcessor) Create() *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) Decode 

func (t *TestUpdateCollectionPolicyProcessor) Decode(fileName string) *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) IsValid 

func (t *TestUpdateCollectionPolicyProcessor) IsValid() *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) LoadOperation 

func (t *TestUpdateCollectionPolicyProcessor) LoadOperation(fileName string,
) *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) MakeOperation 

func (t *TestUpdateCollectionPolicyProcessor) MakeOperation(
	sender base.Address, privatekey base.Privatekey, contract base.Address, whitelist []test.Account, currency types.CurrencyID,
) *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) Print 

func (t *TestUpdateCollectionPolicyProcessor) Print(fileName string,
) *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) RunPreProcess 

func (t *TestUpdateCollectionPolicyProcessor) RunPreProcess() *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) RunProcess 

func (t *TestUpdateCollectionPolicyProcessor) RunProcess() *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) SetAccount 

func (t *TestUpdateCollectionPolicyProcessor) SetAccount(
	priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) SetAmount 

func (t *TestUpdateCollectionPolicyProcessor) SetAmount(
	am int64, cid types.CurrencyID, target []types.Amount,
) *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) SetContractAccount 

func (t *TestUpdateCollectionPolicyProcessor) SetContractAccount(
	owner base.Address, priv string, amount int64, cid types.CurrencyID, target []test.Account, inState bool,
) *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) SetCurrency 

func (t *TestUpdateCollectionPolicyProcessor) SetCurrency(
	cid string, am int64, addr base.Address, target []types.CurrencyID, instate bool,
) *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) SetDesign 

func (t *TestUpdateCollectionPolicyProcessor) SetDesign(
	name string,
	royalty uint,
	uri string,
) *TestUpdateCollectionPolicyProcessor

func (*TestUpdateCollectionPolicyProcessor) SetService 

func (t *TestUpdateCollectionPolicyProcessor) SetService(
	sender, contract base.Address, whitelist []test.Account,
) *TestUpdateCollectionPolicyProcessor

type Transfer 

type Transfer struct {
	common.BaseOperation
}

func NewTransfer 

func NewTransfer(fact TransferFact) (Transfer, error)

func (*Transfer) DecodeBSON 

func (op *Transfer) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*Transfer) DecodeJSON 

func (op *Transfer) DecodeJSON(b []byte, enc encoder.Encoder) error

func (Transfer) MarshalBSON 

func (op Transfer) MarshalBSON() ([]byte, error)

func (Transfer) MarshalJSON 

func (op Transfer) MarshalJSON() ([]byte, error)

func (Transfer) Process 

func (Transfer) Process(
	_ context.Context, _ mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error)

type TransferFact 

type TransferFact struct {
	mitumbase.BaseFact
	// contains filtered or unexported fields
}

func NewTransferFact 

func NewTransferFact(token []byte, sender mitumbase.Address, items []TransferItem) TransferFact

func (TransferFact) Addresses 

func (fact TransferFact) Addresses() ([]mitumbase.Address, error)

func (TransferFact) Bytes 

func (fact TransferFact) Bytes() []byte

func (*TransferFact) DecodeBSON 

func (fact *TransferFact) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*TransferFact) DecodeJSON 

func (fact *TransferFact) DecodeJSON(b []byte, enc encoder.Encoder) error

func (TransferFact) GenerateHash 

func (fact TransferFact) GenerateHash() util.Hash

func (TransferFact) Hash 

func (fact TransferFact) Hash() util.Hash

func (TransferFact) IsValid 

func (fact TransferFact) IsValid(b []byte) error

func (TransferFact) Items 

func (fact TransferFact) Items() []TransferItem

func (TransferFact) MarshalBSON 

func (fact TransferFact) MarshalBSON() ([]byte, error)

func (TransferFact) MarshalJSON 

func (fact TransferFact) MarshalJSON() ([]byte, error)

func (TransferFact) Sender 

func (fact TransferFact) Sender() mitumbase.Address

func (TransferFact) Token 

func (fact TransferFact) Token() mitumbase.Token

type TransferFactBSONUnmarshaler 

type TransferFactBSONUnmarshaler struct {
	Hint   string   `bson:"_hint"`
	Sender string   `bson:"sender"`
	Items  bson.Raw `bson:"items"`
}

type TransferFactJSONMarshaler 

type TransferFactJSONMarshaler struct {
	mitumbase.BaseFactJSONMarshaler
	Sender mitumbase.Address `json:"sender"`
	Items  []TransferItem    `json:"items"`
}

type TransferFactJSONUnmarshaler 

type TransferFactJSONUnmarshaler struct {
	mitumbase.BaseFactJSONUnmarshaler
	Sender string          `json:"sender"`
	Items  json.RawMessage `json:"items"`
}

type TransferItem 

type TransferItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

func NewTransferItem 

func NewTransferItem(contract mitumbase.Address, receiver mitumbase.Address, nft uint64, currency types.CurrencyID) TransferItem

func (TransferItem) Addresses 

func (it TransferItem) Addresses() ([]mitumbase.Address, error)

func (TransferItem) Bytes 

func (it TransferItem) Bytes() []byte

func (TransferItem) Contract 

func (it TransferItem) Contract() mitumbase.Address

func (TransferItem) Currency 

func (it TransferItem) Currency() types.CurrencyID

func (*TransferItem) DecodeBSON 

func (it *TransferItem) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*TransferItem) DecodeJSON 

func (it *TransferItem) DecodeJSON(b []byte, enc encoder.Encoder) error

func (TransferItem) IsValid 

func (it TransferItem) IsValid([]byte) error

func (TransferItem) MarshalBSON 

func (it TransferItem) MarshalBSON() ([]byte, error)

func (TransferItem) MarshalJSON 

func (it TransferItem) MarshalJSON() ([]byte, error)

func (TransferItem) NFT 

func (it TransferItem) NFT() uint64

func (TransferItem) Receiver 

func (it TransferItem) Receiver() mitumbase.Address

type TransferItemBSONUnmarshaler 

type TransferItemBSONUnmarshaler struct {
	Hint     string `bson:"_hint"`
	Contract string `bson:"contract"`
	Receiver string `bson:"receiver"`
	NFTIdx   uint64 `bson:"nft_idx"`
	Currency string `bson:"currency"`
}

type TransferItemJSONMarshaler 

type TransferItemJSONMarshaler struct {
	hint.BaseHinter
	Contract mitumbase.Address `json:"contract"`
	Receiver mitumbase.Address `json:"receiver"`
	NFTIdx   uint64            `json:"nft_idx"`
	Currency types.CurrencyID  `json:"currency"`
}

type TransferItemJSONUnmarshaler 

type TransferItemJSONUnmarshaler struct {
	Hint     hint.Hint `json:"_hint"`
	Contract string    `json:"contract"`
	Receiver string    `json:"receiver"`
	NFTIdx   uint64    `json:"nft_idx"`
	Currency string    `json:"currency"`
}

type TransferItemProcessor 

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

func (*TransferItemProcessor) Close 

func (ipp *TransferItemProcessor) Close()

func (*TransferItemProcessor) PreProcess 

func (ipp *TransferItemProcessor) PreProcess(
	_ context.Context, _ mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) error

func (*TransferItemProcessor) Process 

func (ipp *TransferItemProcessor) Process(
	_ context.Context, _ mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, error)

type TransferProcessor 

type TransferProcessor struct {
	*mitumbase.BaseOperationProcessor
}

func (*TransferProcessor) Close 

func (opp *TransferProcessor) Close() error

func (*TransferProcessor) PreProcess 

func (opp *TransferProcessor) PreProcess(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) (context.Context, mitumbase.OperationProcessReasonError, error)

func (*TransferProcessor) Process 

func (opp *TransferProcessor) Process(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc) (
	[]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error,
)

type UpdateModelConfig 

type UpdateModelConfig struct {
	common.BaseOperation
}

func NewUpdateModelConfig 

func NewUpdateModelConfig(fact UpdateModelConfigFact) (UpdateModelConfig, error)

func (*UpdateModelConfig) DecodeBSON 

func (op *UpdateModelConfig) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*UpdateModelConfig) DecodeJSON 

func (op *UpdateModelConfig) DecodeJSON(b []byte, enc encoder.Encoder) error

func (UpdateModelConfig) MarshalBSON 

func (op UpdateModelConfig) MarshalBSON() ([]byte, error)

func (UpdateModelConfig) MarshalJSON 

func (op UpdateModelConfig) MarshalJSON() ([]byte, error)

func (UpdateModelConfig) Process 

func (UpdateModelConfig) Process(
	_ context.Context, _ mitumbase.GetStateFunc,
) ([]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error)

type UpdateModelConfigFact 

type UpdateModelConfigFact struct {
	mitumbase.BaseFact
	// contains filtered or unexported fields
}

func NewUpdateModelConfigFact 

func NewUpdateModelConfigFact(
	token []byte,
	sender, contract mitumbase.Address,
	name types.CollectionName,
	royalty types.PaymentParameter,
	uri types.URI,
	whitelist []mitumbase.Address,
	currency currencytypes.CurrencyID,
) UpdateModelConfigFact

func (UpdateModelConfigFact) Addresses 

func (fact UpdateModelConfigFact) Addresses() ([]mitumbase.Address, error)

func (UpdateModelConfigFact) Bytes 

func (fact UpdateModelConfigFact) Bytes() []byte

func (UpdateModelConfigFact) Contract 

func (fact UpdateModelConfigFact) Contract() mitumbase.Address

func (UpdateModelConfigFact) Currency 

func (fact UpdateModelConfigFact) Currency() currencytypes.CurrencyID

func (*UpdateModelConfigFact) DecodeBSON 

func (fact *UpdateModelConfigFact) DecodeBSON(b []byte, enc *bsonenc.Encoder) error

func (*UpdateModelConfigFact) DecodeJSON 

func (fact *UpdateModelConfigFact) DecodeJSON(b []byte, enc encoder.Encoder) error

func (UpdateModelConfigFact) GenerateHash 

func (fact UpdateModelConfigFact) GenerateHash() util.Hash

func (UpdateModelConfigFact) Hash 

func (fact UpdateModelConfigFact) Hash() util.Hash

func (UpdateModelConfigFact) IsValid 

func (fact UpdateModelConfigFact) IsValid(b []byte) error

func (UpdateModelConfigFact) MarshalBSON 

func (fact UpdateModelConfigFact) MarshalBSON() ([]byte, error)

func (UpdateModelConfigFact) MarshalJSON 

func (fact UpdateModelConfigFact) MarshalJSON() ([]byte, error)

func (UpdateModelConfigFact) Name 

func (fact UpdateModelConfigFact) Name() types.CollectionName

func (UpdateModelConfigFact) Royalty 

func (fact UpdateModelConfigFact) Royalty() types.PaymentParameter

func (UpdateModelConfigFact) Sender 

func (fact UpdateModelConfigFact) Sender() mitumbase.Address

func (UpdateModelConfigFact) Token 

func (fact UpdateModelConfigFact) Token() mitumbase.Token

func (UpdateModelConfigFact) URI 

func (fact UpdateModelConfigFact) URI() types.URI

func (UpdateModelConfigFact) Whitelist 

func (fact UpdateModelConfigFact) Whitelist() []mitumbase.Address

type UpdateModelConfigFactBSONUnmarshaler 

type UpdateModelConfigFactBSONUnmarshaler struct {
	Hint      string   `bson:"_hint"`
	Sender    string   `bson:"sender"`
	Contract  string   `bson:"contract"`
	Name      string   `bson:"name"`
	Royalty   uint     `bson:"royalty"`
	URI       string   `bson:"uri"`
	Whitelist []string `bson:"minter_whitelist"`
	Currency  string   `bson:"currency"`
}

type UpdateModelConfigFactJSONMarshaler 

type UpdateModelConfigFactJSONMarshaler struct {
	mitumbase.BaseFactJSONMarshaler
	Sender    mitumbase.Address        `json:"sender"`
	Contract  mitumbase.Address        `json:"contract"`
	Name      types.CollectionName     `json:"name"`
	Royalty   types.PaymentParameter   `json:"royalty"`
	URI       types.URI                `json:"uri"`
	Whitelist []mitumbase.Address      `json:"minter_whitelist"`
	Currency  currencytypes.CurrencyID `json:"currency"`
}

type UpdateModelConfigFactJSONUnmarshaler 

type UpdateModelConfigFactJSONUnmarshaler struct {
	mitumbase.BaseFactJSONUnmarshaler
	Sender    string   `json:"sender"`
	Contract  string   `json:"contract"`
	Name      string   `json:"name"`
	Royalty   uint     `json:"royalty"`
	URI       string   `json:"uri"`
	Whitelist []string `json:"minter_whitelist"`
	Currency  string   `json:"currency"`
}

type UpdateModelConfigMarshaler 

type UpdateModelConfigMarshaler struct {
	common.BaseOperationJSONMarshaler
}

type UpdateModelConfigProcessor 

type UpdateModelConfigProcessor struct {
	*mitumbase.BaseOperationProcessor
}

func (*UpdateModelConfigProcessor) Close 

func (opp *UpdateModelConfigProcessor) Close() error

func (*UpdateModelConfigProcessor) PreProcess 

func (opp *UpdateModelConfigProcessor) PreProcess(
	ctx context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc,
) (context.Context, mitumbase.OperationProcessReasonError, error)

func (*UpdateModelConfigProcessor) Process 

func (opp *UpdateModelConfigProcessor) Process(
	_ context.Context, op mitumbase.Operation, getStateFunc mitumbase.GetStateFunc) (
	[]mitumbase.StateMergeValue, mitumbase.OperationProcessReasonError, error,
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

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