bcs

package
v0.0.0-...-2e449e2 Latest Latest
Warning

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

 Go to latest Published: Dec 12, 2024 License: Apache-2.0, MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AbortLocation 

type AbortLocation interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeAbortLocation 

func BcsDeserializeAbortLocation(input []byte) (AbortLocation, error)

func DeserializeAbortLocation 

func DeserializeAbortLocation(deserializer serde.Deserializer) (AbortLocation, error)

type AbortLocation__Module 

type AbortLocation__Module struct {
	Value ModuleId
}

func (*AbortLocation__Module) BcsSerialize 

func (obj *AbortLocation__Module) BcsSerialize() ([]byte, error)

func (*AbortLocation__Module) Serialize 

func (obj *AbortLocation__Module) Serialize(serializer serde.Serializer) error

type AbortLocation__Script 

type AbortLocation__Script struct {
}

func (*AbortLocation__Script) BcsSerialize 

func (obj *AbortLocation__Script) BcsSerialize() ([]byte, error)

func (*AbortLocation__Script) Serialize 

func (obj *AbortLocation__Script) Serialize(serializer serde.Serializer) error

type AccountAddress 

type AccountAddress [32]uint8

func BcsDeserializeAccountAddress 

func BcsDeserializeAccountAddress(input []byte) (AccountAddress, error)

func DeserializeAccountAddress 

func DeserializeAccountAddress(deserializer serde.Deserializer) (AccountAddress, error)

func (*AccountAddress) BcsSerialize 

func (obj *AccountAddress) BcsSerialize() ([]byte, error)

func (*AccountAddress) Serialize 

func (obj *AccountAddress) Serialize(serializer serde.Serializer) error

type Argument 

type Argument interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeArgument 

func BcsDeserializeArgument(input []byte) (Argument, error)

func DeserializeArgument 

func DeserializeArgument(deserializer serde.Deserializer) (Argument, error)

type Argument__GasCoin 

type Argument__GasCoin struct {
}

func (*Argument__GasCoin) BcsSerialize 

func (obj *Argument__GasCoin) BcsSerialize() ([]byte, error)

func (*Argument__GasCoin) Serialize 

func (obj *Argument__GasCoin) Serialize(serializer serde.Serializer) error

type Argument__Input 

type Argument__Input uint16

func (*Argument__Input) BcsSerialize 

func (obj *Argument__Input) BcsSerialize() ([]byte, error)

func (*Argument__Input) Serialize 

func (obj *Argument__Input) Serialize(serializer serde.Serializer) error

type Argument__NestedResult 

type Argument__NestedResult struct {
	Field0 uint16
	Field1 uint16
}

func (*Argument__NestedResult) BcsSerialize 

func (obj *Argument__NestedResult) BcsSerialize() ([]byte, error)

func (*Argument__NestedResult) Serialize 

func (obj *Argument__NestedResult) Serialize(serializer serde.Serializer) error

type Argument__Result 

type Argument__Result uint16

func (*Argument__Result) BcsSerialize 

func (obj *Argument__Result) BcsSerialize() ([]byte, error)

func (*Argument__Result) Serialize 

func (obj *Argument__Result) Serialize(serializer serde.Serializer) error

type AuthorityPublicKeyBytes 

type AuthorityPublicKeyBytes []byte

func BcsDeserializeAuthorityPublicKeyBytes 

func BcsDeserializeAuthorityPublicKeyBytes(input []byte) (AuthorityPublicKeyBytes, error)

func DeserializeAuthorityPublicKeyBytes 

func DeserializeAuthorityPublicKeyBytes(deserializer serde.Deserializer) (AuthorityPublicKeyBytes, error)

func (*AuthorityPublicKeyBytes) BcsSerialize 

func (obj *AuthorityPublicKeyBytes) BcsSerialize() ([]byte, error)

func (*AuthorityPublicKeyBytes) Serialize 

func (obj *AuthorityPublicKeyBytes) Serialize(serializer serde.Serializer) error

type CallArg 

type CallArg interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeCallArg 

func BcsDeserializeCallArg(input []byte) (CallArg, error)

func DeserializeCallArg 

func DeserializeCallArg(deserializer serde.Deserializer) (CallArg, error)

type CallArg__Object 

type CallArg__Object struct {
	Value ObjectArg
}

func (*CallArg__Object) BcsSerialize 

func (obj *CallArg__Object) BcsSerialize() ([]byte, error)

func (*CallArg__Object) Serialize 

func (obj *CallArg__Object) Serialize(serializer serde.Serializer) error

type CallArg__Pure 

type CallArg__Pure []uint8

func (*CallArg__Pure) BcsSerialize 

func (obj *CallArg__Pure) BcsSerialize() ([]byte, error)

func (*CallArg__Pure) Serialize 

func (obj *CallArg__Pure) Serialize(serializer serde.Serializer) error

type ChangeEpoch 

type ChangeEpoch struct {
	Epoch                   uint64
	ProtocolVersion         ProtocolVersion
	StorageCharge           uint64
	ComputationCharge       uint64
	StorageRebate           uint64
	NonRefundableStorageFee uint64
	EpochStartTimestampMs   uint64
	SystemPackages          []struct {
		Field0 SequenceNumber
		Field1 [][]uint8
		Field2 []ObjectID
	}
}

func BcsDeserializeChangeEpoch 

func BcsDeserializeChangeEpoch(input []byte) (ChangeEpoch, error)

func DeserializeChangeEpoch 

func DeserializeChangeEpoch(deserializer serde.Deserializer) (ChangeEpoch, error)

func (*ChangeEpoch) BcsSerialize 

func (obj *ChangeEpoch) BcsSerialize() ([]byte, error)

func (*ChangeEpoch) Serialize 

func (obj *ChangeEpoch) Serialize(serializer serde.Serializer) error

type CheckpointCommitment 

type CheckpointCommitment interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeCheckpointCommitment 

func BcsDeserializeCheckpointCommitment(input []byte) (CheckpointCommitment, error)

func DeserializeCheckpointCommitment 

func DeserializeCheckpointCommitment(deserializer serde.Deserializer) (CheckpointCommitment, error)

type CheckpointCommitment__EcmhLiveObjectSetDigest 

type CheckpointCommitment__EcmhLiveObjectSetDigest struct {
	Value ECMHLiveObjectSetDigest
}

func (*CheckpointCommitment__EcmhLiveObjectSetDigest) BcsSerialize 

func (obj *CheckpointCommitment__EcmhLiveObjectSetDigest) BcsSerialize() ([]byte, error)

func (*CheckpointCommitment__EcmhLiveObjectSetDigest) Serialize 

func (obj *CheckpointCommitment__EcmhLiveObjectSetDigest) Serialize(serializer serde.Serializer) error

type CheckpointContents 

type CheckpointContents interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeCheckpointContents 

func BcsDeserializeCheckpointContents(input []byte) (CheckpointContents, error)

func DeserializeCheckpointContents 

func DeserializeCheckpointContents(deserializer serde.Deserializer) (CheckpointContents, error)

type CheckpointContentsDigest 

type CheckpointContentsDigest struct {
	Value Digest
}

func BcsDeserializeCheckpointContentsDigest 

func BcsDeserializeCheckpointContentsDigest(input []byte) (CheckpointContentsDigest, error)

func DeserializeCheckpointContentsDigest 

func DeserializeCheckpointContentsDigest(deserializer serde.Deserializer) (CheckpointContentsDigest, error)

func (*CheckpointContentsDigest) BcsSerialize 

func (obj *CheckpointContentsDigest) BcsSerialize() ([]byte, error)

func (*CheckpointContentsDigest) Serialize 

func (obj *CheckpointContentsDigest) Serialize(serializer serde.Serializer) error

type CheckpointContentsV1 

type CheckpointContentsV1 struct {
	Transactions   []ExecutionDigests
	UserSignatures [][]GenericSignature
}

func BcsDeserializeCheckpointContentsV1 

func BcsDeserializeCheckpointContentsV1(input []byte) (CheckpointContentsV1, error)

func DeserializeCheckpointContentsV1 

func DeserializeCheckpointContentsV1(deserializer serde.Deserializer) (CheckpointContentsV1, error)

func (*CheckpointContentsV1) BcsSerialize 

func (obj *CheckpointContentsV1) BcsSerialize() ([]byte, error)

func (*CheckpointContentsV1) Serialize 

func (obj *CheckpointContentsV1) Serialize(serializer serde.Serializer) error

type CheckpointContents__V1 

type CheckpointContents__V1 struct {
	Value CheckpointContentsV1
}

func (*CheckpointContents__V1) BcsSerialize 

func (obj *CheckpointContents__V1) BcsSerialize() ([]byte, error)

func (*CheckpointContents__V1) Serialize 

func (obj *CheckpointContents__V1) Serialize(serializer serde.Serializer) error

type CheckpointDigest 

type CheckpointDigest struct {
	Value Digest
}

func BcsDeserializeCheckpointDigest 

func BcsDeserializeCheckpointDigest(input []byte) (CheckpointDigest, error)

func DeserializeCheckpointDigest 

func DeserializeCheckpointDigest(deserializer serde.Deserializer) (CheckpointDigest, error)

func (*CheckpointDigest) BcsSerialize 

func (obj *CheckpointDigest) BcsSerialize() ([]byte, error)

func (*CheckpointDigest) Serialize 

func (obj *CheckpointDigest) Serialize(serializer serde.Serializer) error

type CheckpointSummary 

type CheckpointSummary struct {
	Epoch                      uint64
	SequenceNumber             uint64
	NetworkTotalTransactions   uint64
	ContentDigest              CheckpointContentsDigest
	PreviousDigest             *CheckpointDigest
	EpochRollingGasCostSummary GasCostSummary
	TimestampMs                uint64
	CheckpointCommitments      []CheckpointCommitment
	EndOfEpochData             *EndOfEpochData
	VersionSpecificData        []uint8
}

func BcsDeserializeCheckpointSummary 

func BcsDeserializeCheckpointSummary(input []byte) (CheckpointSummary, error)

func DeserializeCheckpointSummary 

func DeserializeCheckpointSummary(deserializer serde.Deserializer) (CheckpointSummary, error)

func (*CheckpointSummary) BcsSerialize 

func (obj *CheckpointSummary) BcsSerialize() ([]byte, error)

func (*CheckpointSummary) Serialize 

func (obj *CheckpointSummary) Serialize(serializer serde.Serializer) error

type Command 

type Command interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeCommand 

func BcsDeserializeCommand(input []byte) (Command, error)

func DeserializeCommand 

func DeserializeCommand(deserializer serde.Deserializer) (Command, error)

type CommandArgumentError 

type CommandArgumentError interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeCommandArgumentError 

func BcsDeserializeCommandArgumentError(input []byte) (CommandArgumentError, error)

func DeserializeCommandArgumentError 

func DeserializeCommandArgumentError(deserializer serde.Deserializer) (CommandArgumentError, error)

type CommandArgumentError__IndexOutOfBounds 

type CommandArgumentError__IndexOutOfBounds struct {
	Idx uint16
}

func (*CommandArgumentError__IndexOutOfBounds) BcsSerialize 

func (obj *CommandArgumentError__IndexOutOfBounds) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__IndexOutOfBounds) Serialize 

func (obj *CommandArgumentError__IndexOutOfBounds) Serialize(serializer serde.Serializer) error

type CommandArgumentError__InvalidArgumentToPrivateEntryFunction 

type CommandArgumentError__InvalidArgumentToPrivateEntryFunction struct {
}

func (*CommandArgumentError__InvalidArgumentToPrivateEntryFunction) BcsSerialize 

func (obj *CommandArgumentError__InvalidArgumentToPrivateEntryFunction) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__InvalidArgumentToPrivateEntryFunction) Serialize 

func (obj *CommandArgumentError__InvalidArgumentToPrivateEntryFunction) Serialize(serializer serde.Serializer) error

type CommandArgumentError__InvalidBcsBytes 

type CommandArgumentError__InvalidBcsBytes struct {
}

func (*CommandArgumentError__InvalidBcsBytes) BcsSerialize 

func (obj *CommandArgumentError__InvalidBcsBytes) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__InvalidBcsBytes) Serialize 

func (obj *CommandArgumentError__InvalidBcsBytes) Serialize(serializer serde.Serializer) error

type CommandArgumentError__InvalidGasCoinUsage 

type CommandArgumentError__InvalidGasCoinUsage struct {
}

func (*CommandArgumentError__InvalidGasCoinUsage) BcsSerialize 

func (obj *CommandArgumentError__InvalidGasCoinUsage) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__InvalidGasCoinUsage) Serialize 

func (obj *CommandArgumentError__InvalidGasCoinUsage) Serialize(serializer serde.Serializer) error

type CommandArgumentError__InvalidObjectByMutRef 

type CommandArgumentError__InvalidObjectByMutRef struct {
}

func (*CommandArgumentError__InvalidObjectByMutRef) BcsSerialize 

func (obj *CommandArgumentError__InvalidObjectByMutRef) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__InvalidObjectByMutRef) Serialize 

func (obj *CommandArgumentError__InvalidObjectByMutRef) Serialize(serializer serde.Serializer) error

type CommandArgumentError__InvalidObjectByValue 

type CommandArgumentError__InvalidObjectByValue struct {
}

func (*CommandArgumentError__InvalidObjectByValue) BcsSerialize 

func (obj *CommandArgumentError__InvalidObjectByValue) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__InvalidObjectByValue) Serialize 

func (obj *CommandArgumentError__InvalidObjectByValue) Serialize(serializer serde.Serializer) error

type CommandArgumentError__InvalidResultArity 

type CommandArgumentError__InvalidResultArity struct {
	ResultIdx uint16
}

func (*CommandArgumentError__InvalidResultArity) BcsSerialize 

func (obj *CommandArgumentError__InvalidResultArity) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__InvalidResultArity) Serialize 

func (obj *CommandArgumentError__InvalidResultArity) Serialize(serializer serde.Serializer) error

type CommandArgumentError__InvalidUsageOfPureArg 

type CommandArgumentError__InvalidUsageOfPureArg struct {
}

func (*CommandArgumentError__InvalidUsageOfPureArg) BcsSerialize 

func (obj *CommandArgumentError__InvalidUsageOfPureArg) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__InvalidUsageOfPureArg) Serialize 

func (obj *CommandArgumentError__InvalidUsageOfPureArg) Serialize(serializer serde.Serializer) error

type CommandArgumentError__InvalidValueUsage 

type CommandArgumentError__InvalidValueUsage struct {
}

func (*CommandArgumentError__InvalidValueUsage) BcsSerialize 

func (obj *CommandArgumentError__InvalidValueUsage) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__InvalidValueUsage) Serialize 

func (obj *CommandArgumentError__InvalidValueUsage) Serialize(serializer serde.Serializer) error

type CommandArgumentError__SecondaryIndexOutOfBounds 

type CommandArgumentError__SecondaryIndexOutOfBounds struct {
	ResultIdx    uint16
	SecondaryIdx uint16
}

func (*CommandArgumentError__SecondaryIndexOutOfBounds) BcsSerialize 

func (obj *CommandArgumentError__SecondaryIndexOutOfBounds) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__SecondaryIndexOutOfBounds) Serialize 

func (obj *CommandArgumentError__SecondaryIndexOutOfBounds) Serialize(serializer serde.Serializer) error

type CommandArgumentError__TypeMismatch 

type CommandArgumentError__TypeMismatch struct {
}

func (*CommandArgumentError__TypeMismatch) BcsSerialize 

func (obj *CommandArgumentError__TypeMismatch) BcsSerialize() ([]byte, error)

func (*CommandArgumentError__TypeMismatch) Serialize 

func (obj *CommandArgumentError__TypeMismatch) Serialize(serializer serde.Serializer) error

type Command__MakeMoveVec 

type Command__MakeMoveVec struct {
	Field0 *TypeTag
	Field1 []Argument
}

func (*Command__MakeMoveVec) BcsSerialize 

func (obj *Command__MakeMoveVec) BcsSerialize() ([]byte, error)

func (*Command__MakeMoveVec) Serialize 

func (obj *Command__MakeMoveVec) Serialize(serializer serde.Serializer) error

type Command__MergeCoins 

type Command__MergeCoins struct {
	Field0 Argument
	Field1 []Argument
}

func (*Command__MergeCoins) BcsSerialize 

func (obj *Command__MergeCoins) BcsSerialize() ([]byte, error)

func (*Command__MergeCoins) Serialize 

func (obj *Command__MergeCoins) Serialize(serializer serde.Serializer) error

type Command__MoveCall 

type Command__MoveCall struct {
	Value ProgrammableMoveCall
}

func (*Command__MoveCall) BcsSerialize 

func (obj *Command__MoveCall) BcsSerialize() ([]byte, error)

func (*Command__MoveCall) Serialize 

func (obj *Command__MoveCall) Serialize(serializer serde.Serializer) error

type Command__Publish 

type Command__Publish struct {
	Field0 [][]uint8
	Field1 []ObjectID
}

func (*Command__Publish) BcsSerialize 

func (obj *Command__Publish) BcsSerialize() ([]byte, error)

func (*Command__Publish) Serialize 

func (obj *Command__Publish) Serialize(serializer serde.Serializer) error

type Command__SplitCoins 

type Command__SplitCoins struct {
	Field0 Argument
	Field1 []Argument
}

func (*Command__SplitCoins) BcsSerialize 

func (obj *Command__SplitCoins) BcsSerialize() ([]byte, error)

func (*Command__SplitCoins) Serialize 

func (obj *Command__SplitCoins) Serialize(serializer serde.Serializer) error

type Command__TransferObjects 

type Command__TransferObjects struct {
	Field0 []Argument
	Field1 Argument
}

func (*Command__TransferObjects) BcsSerialize 

func (obj *Command__TransferObjects) BcsSerialize() ([]byte, error)

func (*Command__TransferObjects) Serialize 

func (obj *Command__TransferObjects) Serialize(serializer serde.Serializer) error

type Command__Upgrade 

type Command__Upgrade struct {
	Field0 [][]uint8
	Field1 []ObjectID
	Field2 ObjectID
	Field3 Argument
}

func (*Command__Upgrade) BcsSerialize 

func (obj *Command__Upgrade) BcsSerialize() ([]byte, error)

func (*Command__Upgrade) Serialize 

func (obj *Command__Upgrade) Serialize(serializer serde.Serializer) error

type CompressedSignature 

type CompressedSignature interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeCompressedSignature 

func BcsDeserializeCompressedSignature(input []byte) (CompressedSignature, error)

func DeserializeCompressedSignature 

func DeserializeCompressedSignature(deserializer serde.Deserializer) (CompressedSignature, error)

type CompressedSignature__Ed25519 

type CompressedSignature__Ed25519 [64]uint8

func (*CompressedSignature__Ed25519) BcsSerialize 

func (obj *CompressedSignature__Ed25519) BcsSerialize() ([]byte, error)

func (*CompressedSignature__Ed25519) Serialize 

func (obj *CompressedSignature__Ed25519) Serialize(serializer serde.Serializer) error

type CompressedSignature__Secp256k1 

type CompressedSignature__Secp256k1 [64]uint8

func (*CompressedSignature__Secp256k1) BcsSerialize 

func (obj *CompressedSignature__Secp256k1) BcsSerialize() ([]byte, error)

func (*CompressedSignature__Secp256k1) Serialize 

func (obj *CompressedSignature__Secp256k1) Serialize(serializer serde.Serializer) error

type ConsensusCommitPrologue 

type ConsensusCommitPrologue struct {
	Epoch             uint64
	Round             uint64
	CommitTimestampMs uint64
}

func BcsDeserializeConsensusCommitPrologue 

func BcsDeserializeConsensusCommitPrologue(input []byte) (ConsensusCommitPrologue, error)

func DeserializeConsensusCommitPrologue 

func DeserializeConsensusCommitPrologue(deserializer serde.Deserializer) (ConsensusCommitPrologue, error)

func (*ConsensusCommitPrologue) BcsSerialize 

func (obj *ConsensusCommitPrologue) BcsSerialize() ([]byte, error)

func (*ConsensusCommitPrologue) Serialize 

func (obj *ConsensusCommitPrologue) Serialize(serializer serde.Serializer) error

type Data 

type Data interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeData 

func BcsDeserializeData(input []byte) (Data, error)

func DeserializeData 

func DeserializeData(deserializer serde.Deserializer) (Data, error)

type Data__Move 

type Data__Move struct {
	Value MoveObject
}

func (*Data__Move) BcsSerialize 

func (obj *Data__Move) BcsSerialize() ([]byte, error)

func (*Data__Move) Serialize 

func (obj *Data__Move) Serialize(serializer serde.Serializer) error

type Data__Package 

type Data__Package struct {
	Value MovePackage
}

func (*Data__Package) BcsSerialize 

func (obj *Data__Package) BcsSerialize() ([]byte, error)

func (*Data__Package) Serialize 

func (obj *Data__Package) Serialize(serializer serde.Serializer) error

type DeleteKind 

type DeleteKind interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeDeleteKind 

func BcsDeserializeDeleteKind(input []byte) (DeleteKind, error)

func DeserializeDeleteKind 

func DeserializeDeleteKind(deserializer serde.Deserializer) (DeleteKind, error)

type DeleteKind__Normal 

type DeleteKind__Normal struct {
}

func (*DeleteKind__Normal) BcsSerialize 

func (obj *DeleteKind__Normal) BcsSerialize() ([]byte, error)

func (*DeleteKind__Normal) Serialize 

func (obj *DeleteKind__Normal) Serialize(serializer serde.Serializer) error

type DeleteKind__UnwrapThenDelete 

type DeleteKind__UnwrapThenDelete struct {
}

func (*DeleteKind__UnwrapThenDelete) BcsSerialize 

func (obj *DeleteKind__UnwrapThenDelete) BcsSerialize() ([]byte, error)

func (*DeleteKind__UnwrapThenDelete) Serialize 

func (obj *DeleteKind__UnwrapThenDelete) Serialize(serializer serde.Serializer) error

type DeleteKind__Wrap 

type DeleteKind__Wrap struct {
}

func (*DeleteKind__Wrap) BcsSerialize 

func (obj *DeleteKind__Wrap) BcsSerialize() ([]byte, error)

func (*DeleteKind__Wrap) Serialize 

func (obj *DeleteKind__Wrap) Serialize(serializer serde.Serializer) error

type Digest 

type Digest []byte

func BcsDeserializeDigest 

func BcsDeserializeDigest(input []byte) (Digest, error)

func DeserializeDigest 

func DeserializeDigest(deserializer serde.Deserializer) (Digest, error)

func (*Digest) BcsSerialize 

func (obj *Digest) BcsSerialize() ([]byte, error)

func (*Digest) Serialize 

func (obj *Digest) Serialize(serializer serde.Serializer) error

type ECMHLiveObjectSetDigest 

type ECMHLiveObjectSetDigest struct {
	Digest Digest
}

func BcsDeserializeECMHLiveObjectSetDigest 

func BcsDeserializeECMHLiveObjectSetDigest(input []byte) (ECMHLiveObjectSetDigest, error)

func DeserializeECMHLiveObjectSetDigest 

func DeserializeECMHLiveObjectSetDigest(deserializer serde.Deserializer) (ECMHLiveObjectSetDigest, error)

func (*ECMHLiveObjectSetDigest) BcsSerialize 

func (obj *ECMHLiveObjectSetDigest) BcsSerialize() ([]byte, error)

func (*ECMHLiveObjectSetDigest) Serialize 

func (obj *ECMHLiveObjectSetDigest) Serialize(serializer serde.Serializer) error

type EmptySignInfo 

type EmptySignInfo struct {
}

func BcsDeserializeEmptySignInfo 

func BcsDeserializeEmptySignInfo(input []byte) (EmptySignInfo, error)

func DeserializeEmptySignInfo 

func DeserializeEmptySignInfo(deserializer serde.Deserializer) (EmptySignInfo, error)

func (*EmptySignInfo) BcsSerialize 

func (obj *EmptySignInfo) BcsSerialize() ([]byte, error)

func (*EmptySignInfo) Serialize 

func (obj *EmptySignInfo) Serialize(serializer serde.Serializer) error

type EndOfEpochData 

type EndOfEpochData struct {
	NextEpochCommittee []struct {
		Field0 AuthorityPublicKeyBytes
		Field1 uint64
	}
	NextEpochProtocolVersion ProtocolVersion
	EpochCommitments         []CheckpointCommitment
}

func BcsDeserializeEndOfEpochData 

func BcsDeserializeEndOfEpochData(input []byte) (EndOfEpochData, error)

func DeserializeEndOfEpochData 

func DeserializeEndOfEpochData(deserializer serde.Deserializer) (EndOfEpochData, error)

func (*EndOfEpochData) BcsSerialize 

func (obj *EndOfEpochData) BcsSerialize() ([]byte, error)

func (*EndOfEpochData) Serialize 

func (obj *EndOfEpochData) Serialize(serializer serde.Serializer) error

type Envelope 

type Envelope struct {
	Data          SenderSignedData
	AuthSignature EmptySignInfo
}

func BcsDeserializeEnvelope 

func BcsDeserializeEnvelope(input []byte) (Envelope, error)

func DeserializeEnvelope 

func DeserializeEnvelope(deserializer serde.Deserializer) (Envelope, error)

func (*Envelope) BcsSerialize 

func (obj *Envelope) BcsSerialize() ([]byte, error)

func (*Envelope) Serialize 

func (obj *Envelope) Serialize(serializer serde.Serializer) error

type ExecutionData 

type ExecutionData struct {
	Transaction Envelope
	Effects     TransactionEffects
}

func BcsDeserializeExecutionData 

func BcsDeserializeExecutionData(input []byte) (ExecutionData, error)

func DeserializeExecutionData 

func DeserializeExecutionData(deserializer serde.Deserializer) (ExecutionData, error)

func (*ExecutionData) BcsSerialize 

func (obj *ExecutionData) BcsSerialize() ([]byte, error)

func (*ExecutionData) Serialize 

func (obj *ExecutionData) Serialize(serializer serde.Serializer) error

type ExecutionDigests 

type ExecutionDigests struct {
	Transaction TransactionDigest
	Effects     TransactionEffectsDigest
}

func BcsDeserializeExecutionDigests 

func BcsDeserializeExecutionDigests(input []byte) (ExecutionDigests, error)

func DeserializeExecutionDigests 

func DeserializeExecutionDigests(deserializer serde.Deserializer) (ExecutionDigests, error)

func (*ExecutionDigests) BcsSerialize 

func (obj *ExecutionDigests) BcsSerialize() ([]byte, error)

func (*ExecutionDigests) Serialize 

func (obj *ExecutionDigests) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus 

type ExecutionFailureStatus interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeExecutionFailureStatus 

func BcsDeserializeExecutionFailureStatus(input []byte) (ExecutionFailureStatus, error)

func DeserializeExecutionFailureStatus 

func DeserializeExecutionFailureStatus(deserializer serde.Deserializer) (ExecutionFailureStatus, error)

type ExecutionFailureStatus__ArityMismatch 

type ExecutionFailureStatus__ArityMismatch struct {
}

func (*ExecutionFailureStatus__ArityMismatch) BcsSerialize 

func (obj *ExecutionFailureStatus__ArityMismatch) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__ArityMismatch) Serialize 

func (obj *ExecutionFailureStatus__ArityMismatch) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__CertificateDenied 

type ExecutionFailureStatus__CertificateDenied struct {
}

func (*ExecutionFailureStatus__CertificateDenied) BcsSerialize 

func (obj *ExecutionFailureStatus__CertificateDenied) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__CertificateDenied) Serialize 

func (obj *ExecutionFailureStatus__CertificateDenied) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__CircularObjectOwnership 

type ExecutionFailureStatus__CircularObjectOwnership struct {
	Object ObjectID
}

func (*ExecutionFailureStatus__CircularObjectOwnership) BcsSerialize 

func (obj *ExecutionFailureStatus__CircularObjectOwnership) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__CircularObjectOwnership) Serialize 

func (obj *ExecutionFailureStatus__CircularObjectOwnership) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__CoinBalanceOverflow 

type ExecutionFailureStatus__CoinBalanceOverflow struct {
}

func (*ExecutionFailureStatus__CoinBalanceOverflow) BcsSerialize 

func (obj *ExecutionFailureStatus__CoinBalanceOverflow) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__CoinBalanceOverflow) Serialize 

func (obj *ExecutionFailureStatus__CoinBalanceOverflow) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__CommandArgumentError 

type ExecutionFailureStatus__CommandArgumentError struct {
	ArgIdx uint16
	Kind   CommandArgumentError
}

func (*ExecutionFailureStatus__CommandArgumentError) BcsSerialize 

func (obj *ExecutionFailureStatus__CommandArgumentError) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__CommandArgumentError) Serialize 

func (obj *ExecutionFailureStatus__CommandArgumentError) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__EffectsTooLarge 

type ExecutionFailureStatus__EffectsTooLarge struct {
	CurrentSize uint64
	MaxSize     uint64
}

func (*ExecutionFailureStatus__EffectsTooLarge) BcsSerialize 

func (obj *ExecutionFailureStatus__EffectsTooLarge) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__EffectsTooLarge) Serialize 

func (obj *ExecutionFailureStatus__EffectsTooLarge) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__FeatureNotYetSupported 

type ExecutionFailureStatus__FeatureNotYetSupported struct {
}

func (*ExecutionFailureStatus__FeatureNotYetSupported) BcsSerialize 

func (obj *ExecutionFailureStatus__FeatureNotYetSupported) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__FeatureNotYetSupported) Serialize 

func (obj *ExecutionFailureStatus__FeatureNotYetSupported) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__FunctionNotFound 

type ExecutionFailureStatus__FunctionNotFound struct {
}

func (*ExecutionFailureStatus__FunctionNotFound) BcsSerialize 

func (obj *ExecutionFailureStatus__FunctionNotFound) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__FunctionNotFound) Serialize 

func (obj *ExecutionFailureStatus__FunctionNotFound) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__InsufficientCoinBalance 

type ExecutionFailureStatus__InsufficientCoinBalance struct {
}

func (*ExecutionFailureStatus__InsufficientCoinBalance) BcsSerialize 

func (obj *ExecutionFailureStatus__InsufficientCoinBalance) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__InsufficientCoinBalance) Serialize 

func (obj *ExecutionFailureStatus__InsufficientCoinBalance) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__InsufficientGas 

type ExecutionFailureStatus__InsufficientGas struct {
}

func (*ExecutionFailureStatus__InsufficientGas) BcsSerialize 

func (obj *ExecutionFailureStatus__InsufficientGas) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__InsufficientGas) Serialize 

func (obj *ExecutionFailureStatus__InsufficientGas) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__InvalidGasObject 

type ExecutionFailureStatus__InvalidGasObject struct {
}

func (*ExecutionFailureStatus__InvalidGasObject) BcsSerialize 

func (obj *ExecutionFailureStatus__InvalidGasObject) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__InvalidGasObject) Serialize 

func (obj *ExecutionFailureStatus__InvalidGasObject) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__InvalidPublicFunctionReturnType 

type ExecutionFailureStatus__InvalidPublicFunctionReturnType struct {
	Idx uint16
}

func (*ExecutionFailureStatus__InvalidPublicFunctionReturnType) BcsSerialize 

func (obj *ExecutionFailureStatus__InvalidPublicFunctionReturnType) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__InvalidPublicFunctionReturnType) Serialize 

func (obj *ExecutionFailureStatus__InvalidPublicFunctionReturnType) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__InvalidTransferObject 

type ExecutionFailureStatus__InvalidTransferObject struct {
}

func (*ExecutionFailureStatus__InvalidTransferObject) BcsSerialize 

func (obj *ExecutionFailureStatus__InvalidTransferObject) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__InvalidTransferObject) Serialize 

func (obj *ExecutionFailureStatus__InvalidTransferObject) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__InvariantViolation 

type ExecutionFailureStatus__InvariantViolation struct {
}

func (*ExecutionFailureStatus__InvariantViolation) BcsSerialize 

func (obj *ExecutionFailureStatus__InvariantViolation) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__InvariantViolation) Serialize 

func (obj *ExecutionFailureStatus__InvariantViolation) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__MoveAbort 

type ExecutionFailureStatus__MoveAbort struct {
	Field0 MoveLocation
	Field1 uint64
}

func (*ExecutionFailureStatus__MoveAbort) BcsSerialize 

func (obj *ExecutionFailureStatus__MoveAbort) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__MoveAbort) Serialize 

func (obj *ExecutionFailureStatus__MoveAbort) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__MoveObjectTooBig 

type ExecutionFailureStatus__MoveObjectTooBig struct {
	ObjectSize    uint64
	MaxObjectSize uint64
}

func (*ExecutionFailureStatus__MoveObjectTooBig) BcsSerialize 

func (obj *ExecutionFailureStatus__MoveObjectTooBig) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__MoveObjectTooBig) Serialize 

func (obj *ExecutionFailureStatus__MoveObjectTooBig) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__MovePackageTooBig 

type ExecutionFailureStatus__MovePackageTooBig struct {
	ObjectSize    uint64
	MaxObjectSize uint64
}

func (*ExecutionFailureStatus__MovePackageTooBig) BcsSerialize 

func (obj *ExecutionFailureStatus__MovePackageTooBig) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__MovePackageTooBig) Serialize 

func (obj *ExecutionFailureStatus__MovePackageTooBig) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__MovePrimitiveRuntimeError 

type ExecutionFailureStatus__MovePrimitiveRuntimeError struct {
	Value MoveLocationOpt
}

func (*ExecutionFailureStatus__MovePrimitiveRuntimeError) BcsSerialize 

func (obj *ExecutionFailureStatus__MovePrimitiveRuntimeError) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__MovePrimitiveRuntimeError) Serialize 

func (obj *ExecutionFailureStatus__MovePrimitiveRuntimeError) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__NonEntryFunctionInvoked 

type ExecutionFailureStatus__NonEntryFunctionInvoked struct {
}

func (*ExecutionFailureStatus__NonEntryFunctionInvoked) BcsSerialize 

func (obj *ExecutionFailureStatus__NonEntryFunctionInvoked) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__NonEntryFunctionInvoked) Serialize 

func (obj *ExecutionFailureStatus__NonEntryFunctionInvoked) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__PackageUpgradeError 

type ExecutionFailureStatus__PackageUpgradeError struct {
	UpgradeError PackageUpgradeError
}

func (*ExecutionFailureStatus__PackageUpgradeError) BcsSerialize 

func (obj *ExecutionFailureStatus__PackageUpgradeError) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__PackageUpgradeError) Serialize 

func (obj *ExecutionFailureStatus__PackageUpgradeError) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__PublishErrorNonZeroAddress 

type ExecutionFailureStatus__PublishErrorNonZeroAddress struct {
}

func (*ExecutionFailureStatus__PublishErrorNonZeroAddress) BcsSerialize 

func (obj *ExecutionFailureStatus__PublishErrorNonZeroAddress) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__PublishErrorNonZeroAddress) Serialize 

func (obj *ExecutionFailureStatus__PublishErrorNonZeroAddress) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__PublishUpgradeDependencyDowngrade 

type ExecutionFailureStatus__PublishUpgradeDependencyDowngrade struct {
}

func (*ExecutionFailureStatus__PublishUpgradeDependencyDowngrade) BcsSerialize 

func (obj *ExecutionFailureStatus__PublishUpgradeDependencyDowngrade) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__PublishUpgradeDependencyDowngrade) Serialize 

func (obj *ExecutionFailureStatus__PublishUpgradeDependencyDowngrade) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__PublishUpgradeMissingDependency 

type ExecutionFailureStatus__PublishUpgradeMissingDependency struct {
}

func (*ExecutionFailureStatus__PublishUpgradeMissingDependency) BcsSerialize 

func (obj *ExecutionFailureStatus__PublishUpgradeMissingDependency) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__PublishUpgradeMissingDependency) Serialize 

func (obj *ExecutionFailureStatus__PublishUpgradeMissingDependency) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__SuiMoveVerificationError 

type ExecutionFailureStatus__SuiMoveVerificationError struct {
}

func (*ExecutionFailureStatus__SuiMoveVerificationError) BcsSerialize 

func (obj *ExecutionFailureStatus__SuiMoveVerificationError) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__SuiMoveVerificationError) Serialize 

func (obj *ExecutionFailureStatus__SuiMoveVerificationError) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__TypeArgumentError 

type ExecutionFailureStatus__TypeArgumentError struct {
	ArgumentIdx uint16
	Kind        TypeArgumentError
}

func (*ExecutionFailureStatus__TypeArgumentError) BcsSerialize 

func (obj *ExecutionFailureStatus__TypeArgumentError) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__TypeArgumentError) Serialize 

func (obj *ExecutionFailureStatus__TypeArgumentError) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__TypeArityMismatch 

type ExecutionFailureStatus__TypeArityMismatch struct {
}

func (*ExecutionFailureStatus__TypeArityMismatch) BcsSerialize 

func (obj *ExecutionFailureStatus__TypeArityMismatch) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__TypeArityMismatch) Serialize 

func (obj *ExecutionFailureStatus__TypeArityMismatch) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__UnusedValueWithoutDrop 

type ExecutionFailureStatus__UnusedValueWithoutDrop struct {
	ResultIdx    uint16
	SecondaryIdx uint16
}

func (*ExecutionFailureStatus__UnusedValueWithoutDrop) BcsSerialize 

func (obj *ExecutionFailureStatus__UnusedValueWithoutDrop) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__UnusedValueWithoutDrop) Serialize 

func (obj *ExecutionFailureStatus__UnusedValueWithoutDrop) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__VmInvariantViolation 

type ExecutionFailureStatus__VmInvariantViolation struct {
}

func (*ExecutionFailureStatus__VmInvariantViolation) BcsSerialize 

func (obj *ExecutionFailureStatus__VmInvariantViolation) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__VmInvariantViolation) Serialize 

func (obj *ExecutionFailureStatus__VmInvariantViolation) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__VmVerificationOrDeserializationError 

type ExecutionFailureStatus__VmVerificationOrDeserializationError struct {
}

func (*ExecutionFailureStatus__VmVerificationOrDeserializationError) BcsSerialize 

func (obj *ExecutionFailureStatus__VmVerificationOrDeserializationError) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__VmVerificationOrDeserializationError) Serialize 

func (obj *ExecutionFailureStatus__VmVerificationOrDeserializationError) Serialize(serializer serde.Serializer) error

type ExecutionFailureStatus__WrittenObjectsTooLarge 

type ExecutionFailureStatus__WrittenObjectsTooLarge struct {
	CurrentSize uint64
	MaxSize     uint64
}

func (*ExecutionFailureStatus__WrittenObjectsTooLarge) BcsSerialize 

func (obj *ExecutionFailureStatus__WrittenObjectsTooLarge) BcsSerialize() ([]byte, error)

func (*ExecutionFailureStatus__WrittenObjectsTooLarge) Serialize 

func (obj *ExecutionFailureStatus__WrittenObjectsTooLarge) Serialize(serializer serde.Serializer) error

type ExecutionStatus 

type ExecutionStatus interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeExecutionStatus 

func BcsDeserializeExecutionStatus(input []byte) (ExecutionStatus, error)

func DeserializeExecutionStatus 

func DeserializeExecutionStatus(deserializer serde.Deserializer) (ExecutionStatus, error)

type ExecutionStatus__Failure 

type ExecutionStatus__Failure struct {
	Error   ExecutionFailureStatus
	Command *uint64
}

func (*ExecutionStatus__Failure) BcsSerialize 

func (obj *ExecutionStatus__Failure) BcsSerialize() ([]byte, error)

func (*ExecutionStatus__Failure) Serialize 

func (obj *ExecutionStatus__Failure) Serialize(serializer serde.Serializer) error

type ExecutionStatus__Success 

type ExecutionStatus__Success struct {
}

func (*ExecutionStatus__Success) BcsSerialize 

func (obj *ExecutionStatus__Success) BcsSerialize() ([]byte, error)

func (*ExecutionStatus__Success) Serialize 

func (obj *ExecutionStatus__Success) Serialize(serializer serde.Serializer) error

type FullCheckpointContents 

type FullCheckpointContents struct {
	Transactions   []ExecutionData
	UserSignatures [][]GenericSignature
}

func BcsDeserializeFullCheckpointContents 

func BcsDeserializeFullCheckpointContents(input []byte) (FullCheckpointContents, error)

func DeserializeFullCheckpointContents 

func DeserializeFullCheckpointContents(deserializer serde.Deserializer) (FullCheckpointContents, error)

func (*FullCheckpointContents) BcsSerialize 

func (obj *FullCheckpointContents) BcsSerialize() ([]byte, error)

func (*FullCheckpointContents) Serialize 

func (obj *FullCheckpointContents) Serialize(serializer serde.Serializer) error

type GasCostSummary 

type GasCostSummary struct {
	ComputationCost         uint64
	StorageCost             uint64
	StorageRebate           uint64
	NonRefundableStorageFee uint64
}

func BcsDeserializeGasCostSummary 

func BcsDeserializeGasCostSummary(input []byte) (GasCostSummary, error)

func DeserializeGasCostSummary 

func DeserializeGasCostSummary(deserializer serde.Deserializer) (GasCostSummary, error)

func (*GasCostSummary) BcsSerialize 

func (obj *GasCostSummary) BcsSerialize() ([]byte, error)

func (*GasCostSummary) Serialize 

func (obj *GasCostSummary) Serialize(serializer serde.Serializer) error

type GasData 

type GasData struct {
	Payment []struct {
		Field0 ObjectID
		Field1 SequenceNumber
		Field2 ObjectDigest
	}
	Owner  SuiAddress
	Price  uint64
	Budget uint64
}

func BcsDeserializeGasData 

func BcsDeserializeGasData(input []byte) (GasData, error)

func DeserializeGasData 

func DeserializeGasData(deserializer serde.Deserializer) (GasData, error)

func (*GasData) BcsSerialize 

func (obj *GasData) BcsSerialize() ([]byte, error)

func (*GasData) Serialize 

func (obj *GasData) Serialize(serializer serde.Serializer) error

type GenericSignature 

type GenericSignature []uint8

func BcsDeserializeGenericSignature 

func BcsDeserializeGenericSignature(input []byte) (GenericSignature, error)

func DeserializeGenericSignature 

func DeserializeGenericSignature(deserializer serde.Deserializer) (GenericSignature, error)

func (*GenericSignature) BcsSerialize 

func (obj *GenericSignature) BcsSerialize() ([]byte, error)

func (*GenericSignature) Serialize 

func (obj *GenericSignature) Serialize(serializer serde.Serializer) error

type GenesisObject 

type GenesisObject interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeGenesisObject 

func BcsDeserializeGenesisObject(input []byte) (GenesisObject, error)

func DeserializeGenesisObject 

func DeserializeGenesisObject(deserializer serde.Deserializer) (GenesisObject, error)

type GenesisObject__RawObject 

type GenesisObject__RawObject struct {
	Data  Data
	Owner Owner
}

func (*GenesisObject__RawObject) BcsSerialize 

func (obj *GenesisObject__RawObject) BcsSerialize() ([]byte, error)

func (*GenesisObject__RawObject) Serialize 

func (obj *GenesisObject__RawObject) Serialize(serializer serde.Serializer) error

type GenesisTransaction 

type GenesisTransaction struct {
	Objects []GenesisObject
}

func BcsDeserializeGenesisTransaction 

func BcsDeserializeGenesisTransaction(input []byte) (GenesisTransaction, error)

func DeserializeGenesisTransaction 

func DeserializeGenesisTransaction(deserializer serde.Deserializer) (GenesisTransaction, error)

func (*GenesisTransaction) BcsSerialize 

func (obj *GenesisTransaction) BcsSerialize() ([]byte, error)

func (*GenesisTransaction) Serialize 

func (obj *GenesisTransaction) Serialize(serializer serde.Serializer) error

type Identifier 

type Identifier string

func BcsDeserializeIdentifier 

func BcsDeserializeIdentifier(input []byte) (Identifier, error)

func DeserializeIdentifier 

func DeserializeIdentifier(deserializer serde.Deserializer) (Identifier, error)

func (*Identifier) BcsSerialize 

func (obj *Identifier) BcsSerialize() ([]byte, error)

func (*Identifier) Serialize 

func (obj *Identifier) Serialize(serializer serde.Serializer) error

type Intent 

type Intent struct {
	Scope   uint8
	Version uint8
	AppId   uint8
}

func BcsDeserializeIntent 

func BcsDeserializeIntent(input []byte) (Intent, error)

func DeserializeIntent 

func DeserializeIntent(deserializer serde.Deserializer) (Intent, error)

func (*Intent) BcsSerialize 

func (obj *Intent) BcsSerialize() ([]byte, error)

func (*Intent) Serialize 

func (obj *Intent) Serialize(serializer serde.Serializer) error

type IntentMessage 

type IntentMessage struct {
	Intent Intent
	Value  TransactionData
}

func BcsDeserializeIntentMessage 

func BcsDeserializeIntentMessage(input []byte) (IntentMessage, error)

func DeserializeIntentMessage 

func DeserializeIntentMessage(deserializer serde.Deserializer) (IntentMessage, error)

func (*IntentMessage) BcsSerialize 

func (obj *IntentMessage) BcsSerialize() ([]byte, error)

func (*IntentMessage) Serialize 

func (obj *IntentMessage) Serialize(serializer serde.Serializer) error

type ModuleId 

type ModuleId struct {
	Address AccountAddress
	Name    Identifier
}

func BcsDeserializeModuleId 

func BcsDeserializeModuleId(input []byte) (ModuleId, error)

func DeserializeModuleId 

func DeserializeModuleId(deserializer serde.Deserializer) (ModuleId, error)

func (*ModuleId) BcsSerialize 

func (obj *ModuleId) BcsSerialize() ([]byte, error)

func (*ModuleId) Serialize 

func (obj *ModuleId) Serialize(serializer serde.Serializer) error

type MoveFieldLayout 

type MoveFieldLayout struct {
	Name   Identifier
	Layout MoveTypeLayout
}

func BcsDeserializeMoveFieldLayout 

func BcsDeserializeMoveFieldLayout(input []byte) (MoveFieldLayout, error)

func DeserializeMoveFieldLayout 

func DeserializeMoveFieldLayout(deserializer serde.Deserializer) (MoveFieldLayout, error)

func (*MoveFieldLayout) BcsSerialize 

func (obj *MoveFieldLayout) BcsSerialize() ([]byte, error)

func (*MoveFieldLayout) Serialize 

func (obj *MoveFieldLayout) Serialize(serializer serde.Serializer) error

type MoveLocation 

type MoveLocation struct {
	Module       ModuleId
	Function     uint16
	Instruction  uint16
	FunctionName *string
}

func BcsDeserializeMoveLocation 

func BcsDeserializeMoveLocation(input []byte) (MoveLocation, error)

func DeserializeMoveLocation 

func DeserializeMoveLocation(deserializer serde.Deserializer) (MoveLocation, error)

func (*MoveLocation) BcsSerialize 

func (obj *MoveLocation) BcsSerialize() ([]byte, error)

func (*MoveLocation) Serialize 

func (obj *MoveLocation) Serialize(serializer serde.Serializer) error

type MoveLocationOpt 

type MoveLocationOpt struct {
	Value *MoveLocation
}

func BcsDeserializeMoveLocationOpt 

func BcsDeserializeMoveLocationOpt(input []byte) (MoveLocationOpt, error)

func DeserializeMoveLocationOpt 

func DeserializeMoveLocationOpt(deserializer serde.Deserializer) (MoveLocationOpt, error)

func (*MoveLocationOpt) BcsSerialize 

func (obj *MoveLocationOpt) BcsSerialize() ([]byte, error)

func (*MoveLocationOpt) Serialize 

func (obj *MoveLocationOpt) Serialize(serializer serde.Serializer) error

type MoveObject 

type MoveObject struct {
	Type              MoveObjectType
	HasPublicTransfer bool
	Version           SequenceNumber
	Contents          []byte
}

func BcsDeserializeMoveObject 

func BcsDeserializeMoveObject(input []byte) (MoveObject, error)

func DeserializeMoveObject 

func DeserializeMoveObject(deserializer serde.Deserializer) (MoveObject, error)

func (*MoveObject) BcsSerialize 

func (obj *MoveObject) BcsSerialize() ([]byte, error)

func (*MoveObject) Serialize 

func (obj *MoveObject) Serialize(serializer serde.Serializer) error

type MoveObjectType 

type MoveObjectType struct {
	Value MoveObjectType_
}

func BcsDeserializeMoveObjectType 

func BcsDeserializeMoveObjectType(input []byte) (MoveObjectType, error)

func DeserializeMoveObjectType 

func DeserializeMoveObjectType(deserializer serde.Deserializer) (MoveObjectType, error)

func (*MoveObjectType) BcsSerialize 

func (obj *MoveObjectType) BcsSerialize() ([]byte, error)

func (*MoveObjectType) Serialize 

func (obj *MoveObjectType) Serialize(serializer serde.Serializer) error

type MoveObjectType_ 

type MoveObjectType_ interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeMoveObjectType_ 

func BcsDeserializeMoveObjectType_(input []byte) (MoveObjectType_, error)

func DeserializeMoveObjectType_ 

func DeserializeMoveObjectType_(deserializer serde.Deserializer) (MoveObjectType_, error)

type MoveObjectType___Coin 

type MoveObjectType___Coin struct {
	Value TypeTag
}

func (*MoveObjectType___Coin) BcsSerialize 

func (obj *MoveObjectType___Coin) BcsSerialize() ([]byte, error)

func (*MoveObjectType___Coin) Serialize 

func (obj *MoveObjectType___Coin) Serialize(serializer serde.Serializer) error

type MoveObjectType___GasCoin 

type MoveObjectType___GasCoin struct {
}

func (*MoveObjectType___GasCoin) BcsSerialize 

func (obj *MoveObjectType___GasCoin) BcsSerialize() ([]byte, error)

func (*MoveObjectType___GasCoin) Serialize 

func (obj *MoveObjectType___GasCoin) Serialize(serializer serde.Serializer) error

type MoveObjectType___Other 

type MoveObjectType___Other struct {
	Value StructTag
}

func (*MoveObjectType___Other) BcsSerialize 

func (obj *MoveObjectType___Other) BcsSerialize() ([]byte, error)

func (*MoveObjectType___Other) Serialize 

func (obj *MoveObjectType___Other) Serialize(serializer serde.Serializer) error

type MoveObjectType___StakedSui 

type MoveObjectType___StakedSui struct {
}

func (*MoveObjectType___StakedSui) BcsSerialize 

func (obj *MoveObjectType___StakedSui) BcsSerialize() ([]byte, error)

func (*MoveObjectType___StakedSui) Serialize 

func (obj *MoveObjectType___StakedSui) Serialize(serializer serde.Serializer) error

type MovePackage 

type MovePackage struct {
	Id              ObjectID
	Version         SequenceNumber
	ModuleMap       map[string][]byte
	TypeOriginTable []TypeOrigin
	LinkageTable    map[ObjectID]UpgradeInfo
}

func BcsDeserializeMovePackage 

func BcsDeserializeMovePackage(input []byte) (MovePackage, error)

func DeserializeMovePackage 

func DeserializeMovePackage(deserializer serde.Deserializer) (MovePackage, error)

func (*MovePackage) BcsSerialize 

func (obj *MovePackage) BcsSerialize() ([]byte, error)

func (*MovePackage) Serialize 

func (obj *MovePackage) Serialize(serializer serde.Serializer) error

type MoveStructLayout 

type MoveStructLayout interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeMoveStructLayout 

func BcsDeserializeMoveStructLayout(input []byte) (MoveStructLayout, error)

func DeserializeMoveStructLayout 

func DeserializeMoveStructLayout(deserializer serde.Deserializer) (MoveStructLayout, error)

type MoveStructLayout__Runtime 

type MoveStructLayout__Runtime []MoveTypeLayout

func (*MoveStructLayout__Runtime) BcsSerialize 

func (obj *MoveStructLayout__Runtime) BcsSerialize() ([]byte, error)

func (*MoveStructLayout__Runtime) Serialize 

func (obj *MoveStructLayout__Runtime) Serialize(serializer serde.Serializer) error

type MoveStructLayout__WithFields 

type MoveStructLayout__WithFields []MoveFieldLayout

func (*MoveStructLayout__WithFields) BcsSerialize 

func (obj *MoveStructLayout__WithFields) BcsSerialize() ([]byte, error)

func (*MoveStructLayout__WithFields) Serialize 

func (obj *MoveStructLayout__WithFields) Serialize(serializer serde.Serializer) error

type MoveStructLayout__WithTypes 

type MoveStructLayout__WithTypes struct {
	Type   StructTag
	Fields []MoveFieldLayout
}

func (*MoveStructLayout__WithTypes) BcsSerialize 

func (obj *MoveStructLayout__WithTypes) BcsSerialize() ([]byte, error)

func (*MoveStructLayout__WithTypes) Serialize 

func (obj *MoveStructLayout__WithTypes) Serialize(serializer serde.Serializer) error

type MoveTypeLayout 

type MoveTypeLayout interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeMoveTypeLayout 

func BcsDeserializeMoveTypeLayout(input []byte) (MoveTypeLayout, error)

func DeserializeMoveTypeLayout 

func DeserializeMoveTypeLayout(deserializer serde.Deserializer) (MoveTypeLayout, error)

type MoveTypeLayout__Address 

type MoveTypeLayout__Address struct {
}

func (*MoveTypeLayout__Address) BcsSerialize 

func (obj *MoveTypeLayout__Address) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__Address) Serialize 

func (obj *MoveTypeLayout__Address) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__Bool 

type MoveTypeLayout__Bool struct {
}

func (*MoveTypeLayout__Bool) BcsSerialize 

func (obj *MoveTypeLayout__Bool) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__Bool) Serialize 

func (obj *MoveTypeLayout__Bool) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__Signer 

type MoveTypeLayout__Signer struct {
}

func (*MoveTypeLayout__Signer) BcsSerialize 

func (obj *MoveTypeLayout__Signer) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__Signer) Serialize 

func (obj *MoveTypeLayout__Signer) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__Struct 

type MoveTypeLayout__Struct struct {
	Value MoveStructLayout
}

func (*MoveTypeLayout__Struct) BcsSerialize 

func (obj *MoveTypeLayout__Struct) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__Struct) Serialize 

func (obj *MoveTypeLayout__Struct) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__U128 

type MoveTypeLayout__U128 struct {
}

func (*MoveTypeLayout__U128) BcsSerialize 

func (obj *MoveTypeLayout__U128) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__U128) Serialize 

func (obj *MoveTypeLayout__U128) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__U16 

type MoveTypeLayout__U16 struct {
}

func (*MoveTypeLayout__U16) BcsSerialize 

func (obj *MoveTypeLayout__U16) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__U16) Serialize 

func (obj *MoveTypeLayout__U16) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__U256 

type MoveTypeLayout__U256 struct {
}

func (*MoveTypeLayout__U256) BcsSerialize 

func (obj *MoveTypeLayout__U256) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__U256) Serialize 

func (obj *MoveTypeLayout__U256) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__U32 

type MoveTypeLayout__U32 struct {
}

func (*MoveTypeLayout__U32) BcsSerialize 

func (obj *MoveTypeLayout__U32) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__U32) Serialize 

func (obj *MoveTypeLayout__U32) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__U64 

type MoveTypeLayout__U64 struct {
}

func (*MoveTypeLayout__U64) BcsSerialize 

func (obj *MoveTypeLayout__U64) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__U64) Serialize 

func (obj *MoveTypeLayout__U64) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__U8 

type MoveTypeLayout__U8 struct {
}

func (*MoveTypeLayout__U8) BcsSerialize 

func (obj *MoveTypeLayout__U8) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__U8) Serialize 

func (obj *MoveTypeLayout__U8) Serialize(serializer serde.Serializer) error

type MoveTypeLayout__Vector 

type MoveTypeLayout__Vector struct {
	Value MoveTypeLayout
}

func (*MoveTypeLayout__Vector) BcsSerialize 

func (obj *MoveTypeLayout__Vector) BcsSerialize() ([]byte, error)

func (*MoveTypeLayout__Vector) Serialize 

func (obj *MoveTypeLayout__Vector) Serialize(serializer serde.Serializer) error

type MultiSig 

type MultiSig struct {
	Sigs       []CompressedSignature
	Bitmap     []byte
	MultisigPk MultiSigPublicKey
}

func BcsDeserializeMultiSig 

func BcsDeserializeMultiSig(input []byte) (MultiSig, error)

func DeserializeMultiSig 

func DeserializeMultiSig(deserializer serde.Deserializer) (MultiSig, error)

func (*MultiSig) BcsSerialize 

func (obj *MultiSig) BcsSerialize() ([]byte, error)

func (*MultiSig) Serialize 

func (obj *MultiSig) Serialize(serializer serde.Serializer) error

type MultiSigPublicKey 

type MultiSigPublicKey struct {
	PkMap []struct {
		Field0 string
		Field1 uint8
	}
	Threshold uint16
}

func BcsDeserializeMultiSigPublicKey 

func BcsDeserializeMultiSigPublicKey(input []byte) (MultiSigPublicKey, error)

func DeserializeMultiSigPublicKey 

func DeserializeMultiSigPublicKey(deserializer serde.Deserializer) (MultiSigPublicKey, error)

func (*MultiSigPublicKey) BcsSerialize 

func (obj *MultiSigPublicKey) BcsSerialize() ([]byte, error)

func (*MultiSigPublicKey) Serialize 

func (obj *MultiSigPublicKey) Serialize(serializer serde.Serializer) error

type ObjectArg 

type ObjectArg interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeObjectArg 

func BcsDeserializeObjectArg(input []byte) (ObjectArg, error)

func DeserializeObjectArg 

func DeserializeObjectArg(deserializer serde.Deserializer) (ObjectArg, error)

type ObjectArg__ImmOrOwnedObject 

type ObjectArg__ImmOrOwnedObject struct {
	Field0 ObjectID
	Field1 SequenceNumber
	Field2 ObjectDigest
}

func (*ObjectArg__ImmOrOwnedObject) BcsSerialize 

func (obj *ObjectArg__ImmOrOwnedObject) BcsSerialize() ([]byte, error)

func (*ObjectArg__ImmOrOwnedObject) Serialize 

func (obj *ObjectArg__ImmOrOwnedObject) Serialize(serializer serde.Serializer) error

type ObjectArg__SharedObject 

type ObjectArg__SharedObject struct {
	Id                   ObjectID
	InitialSharedVersion SequenceNumber
	Mutable              bool
}

func (*ObjectArg__SharedObject) BcsSerialize 

func (obj *ObjectArg__SharedObject) BcsSerialize() ([]byte, error)

func (*ObjectArg__SharedObject) Serialize 

func (obj *ObjectArg__SharedObject) Serialize(serializer serde.Serializer) error

type ObjectDigest 

type ObjectDigest struct {
	Value Digest
}

func BcsDeserializeObjectDigest 

func BcsDeserializeObjectDigest(input []byte) (ObjectDigest, error)

func DeserializeObjectDigest 

func DeserializeObjectDigest(deserializer serde.Deserializer) (ObjectDigest, error)

func (*ObjectDigest) BcsSerialize 

func (obj *ObjectDigest) BcsSerialize() ([]byte, error)

func (*ObjectDigest) Serialize 

func (obj *ObjectDigest) Serialize(serializer serde.Serializer) error

type ObjectID 

type ObjectID struct {
	Value AccountAddress
}

func BcsDeserializeObjectID 

func BcsDeserializeObjectID(input []byte) (ObjectID, error)

func DeserializeObjectID 

func DeserializeObjectID(deserializer serde.Deserializer) (ObjectID, error)

func (*ObjectID) BcsSerialize 

func (obj *ObjectID) BcsSerialize() ([]byte, error)

func (*ObjectID) Serialize 

func (obj *ObjectID) Serialize(serializer serde.Serializer) error

type ObjectInfoRequestKind 

type ObjectInfoRequestKind interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeObjectInfoRequestKind 

func BcsDeserializeObjectInfoRequestKind(input []byte) (ObjectInfoRequestKind, error)

func DeserializeObjectInfoRequestKind 

func DeserializeObjectInfoRequestKind(deserializer serde.Deserializer) (ObjectInfoRequestKind, error)

type ObjectInfoRequestKind__LatestObjectInfo 

type ObjectInfoRequestKind__LatestObjectInfo struct {
}

func (*ObjectInfoRequestKind__LatestObjectInfo) BcsSerialize 

func (obj *ObjectInfoRequestKind__LatestObjectInfo) BcsSerialize() ([]byte, error)

func (*ObjectInfoRequestKind__LatestObjectInfo) Serialize 

func (obj *ObjectInfoRequestKind__LatestObjectInfo) Serialize(serializer serde.Serializer) error

type ObjectInfoRequestKind__PastObjectInfoDebug 

type ObjectInfoRequestKind__PastObjectInfoDebug struct {
	Value SequenceNumber
}

func (*ObjectInfoRequestKind__PastObjectInfoDebug) BcsSerialize 

func (obj *ObjectInfoRequestKind__PastObjectInfoDebug) BcsSerialize() ([]byte, error)

func (*ObjectInfoRequestKind__PastObjectInfoDebug) Serialize 

func (obj *ObjectInfoRequestKind__PastObjectInfoDebug) Serialize(serializer serde.Serializer) error

type Owner 

type Owner interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeOwner 

func BcsDeserializeOwner(input []byte) (Owner, error)

func DeserializeOwner 

func DeserializeOwner(deserializer serde.Deserializer) (Owner, error)

type Owner__AddressOwner 

type Owner__AddressOwner struct {
	Value SuiAddress
}

func (*Owner__AddressOwner) BcsSerialize 

func (obj *Owner__AddressOwner) BcsSerialize() ([]byte, error)

func (*Owner__AddressOwner) Serialize 

func (obj *Owner__AddressOwner) Serialize(serializer serde.Serializer) error

type Owner__Immutable 

type Owner__Immutable struct {
}

func (*Owner__Immutable) BcsSerialize 

func (obj *Owner__Immutable) BcsSerialize() ([]byte, error)

func (*Owner__Immutable) Serialize 

func (obj *Owner__Immutable) Serialize(serializer serde.Serializer) error

type Owner__ObjectOwner 

type Owner__ObjectOwner struct {
	Value SuiAddress
}

func (*Owner__ObjectOwner) BcsSerialize 

func (obj *Owner__ObjectOwner) BcsSerialize() ([]byte, error)

func (*Owner__ObjectOwner) Serialize 

func (obj *Owner__ObjectOwner) Serialize(serializer serde.Serializer) error

type Owner__Shared 

type Owner__Shared struct {
	InitialSharedVersion SequenceNumber
}

func (*Owner__Shared) BcsSerialize 

func (obj *Owner__Shared) BcsSerialize() ([]byte, error)

func (*Owner__Shared) Serialize 

func (obj *Owner__Shared) Serialize(serializer serde.Serializer) error

type PackageUpgradeError 

type PackageUpgradeError interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializePackageUpgradeError 

func BcsDeserializePackageUpgradeError(input []byte) (PackageUpgradeError, error)

func DeserializePackageUpgradeError 

func DeserializePackageUpgradeError(deserializer serde.Deserializer) (PackageUpgradeError, error)

type PackageUpgradeError__DigestDoesNotMatch 

type PackageUpgradeError__DigestDoesNotMatch struct {
	Digest []uint8
}

func (*PackageUpgradeError__DigestDoesNotMatch) BcsSerialize 

func (obj *PackageUpgradeError__DigestDoesNotMatch) BcsSerialize() ([]byte, error)

func (*PackageUpgradeError__DigestDoesNotMatch) Serialize 

func (obj *PackageUpgradeError__DigestDoesNotMatch) Serialize(serializer serde.Serializer) error

type PackageUpgradeError__IncompatibleUpgrade 

type PackageUpgradeError__IncompatibleUpgrade struct {
}

func (*PackageUpgradeError__IncompatibleUpgrade) BcsSerialize 

func (obj *PackageUpgradeError__IncompatibleUpgrade) BcsSerialize() ([]byte, error)

func (*PackageUpgradeError__IncompatibleUpgrade) Serialize 

func (obj *PackageUpgradeError__IncompatibleUpgrade) Serialize(serializer serde.Serializer) error

type PackageUpgradeError__NotAPackage 

type PackageUpgradeError__NotAPackage struct {
	ObjectId ObjectID
}

func (*PackageUpgradeError__NotAPackage) BcsSerialize 

func (obj *PackageUpgradeError__NotAPackage) BcsSerialize() ([]byte, error)

func (*PackageUpgradeError__NotAPackage) Serialize 

func (obj *PackageUpgradeError__NotAPackage) Serialize(serializer serde.Serializer) error

type PackageUpgradeError__PackageIdDoesNotMatch 

type PackageUpgradeError__PackageIdDoesNotMatch struct {
	PackageId ObjectID
	TicketId  ObjectID
}

func (*PackageUpgradeError__PackageIdDoesNotMatch) BcsSerialize 

func (obj *PackageUpgradeError__PackageIdDoesNotMatch) BcsSerialize() ([]byte, error)

func (*PackageUpgradeError__PackageIdDoesNotMatch) Serialize 

func (obj *PackageUpgradeError__PackageIdDoesNotMatch) Serialize(serializer serde.Serializer) error

type PackageUpgradeError__UnableToFetchPackage 

type PackageUpgradeError__UnableToFetchPackage struct {
	PackageId ObjectID
}

func (*PackageUpgradeError__UnableToFetchPackage) BcsSerialize 

func (obj *PackageUpgradeError__UnableToFetchPackage) BcsSerialize() ([]byte, error)

func (*PackageUpgradeError__UnableToFetchPackage) Serialize 

func (obj *PackageUpgradeError__UnableToFetchPackage) Serialize(serializer serde.Serializer) error

type PackageUpgradeError__UnknownUpgradePolicy 

type PackageUpgradeError__UnknownUpgradePolicy struct {
	Policy uint8
}

func (*PackageUpgradeError__UnknownUpgradePolicy) BcsSerialize 

func (obj *PackageUpgradeError__UnknownUpgradePolicy) BcsSerialize() ([]byte, error)

func (*PackageUpgradeError__UnknownUpgradePolicy) Serialize 

func (obj *PackageUpgradeError__UnknownUpgradePolicy) Serialize(serializer serde.Serializer) error

type ProgrammableMoveCall 

type ProgrammableMoveCall struct {
	Package       ObjectID
	Module        Identifier
	Function      Identifier
	TypeArguments []TypeTag
	Arguments     []Argument
}

func BcsDeserializeProgrammableMoveCall 

func BcsDeserializeProgrammableMoveCall(input []byte) (ProgrammableMoveCall, error)

func DeserializeProgrammableMoveCall 

func DeserializeProgrammableMoveCall(deserializer serde.Deserializer) (ProgrammableMoveCall, error)

func (*ProgrammableMoveCall) BcsSerialize 

func (obj *ProgrammableMoveCall) BcsSerialize() ([]byte, error)

func (*ProgrammableMoveCall) Serialize 

func (obj *ProgrammableMoveCall) Serialize(serializer serde.Serializer) error

type ProgrammableTransaction 

type ProgrammableTransaction struct {
	Inputs   []CallArg
	Commands []Command
}

func BcsDeserializeProgrammableTransaction 

func BcsDeserializeProgrammableTransaction(input []byte) (ProgrammableTransaction, error)

func DeserializeProgrammableTransaction 

func DeserializeProgrammableTransaction(deserializer serde.Deserializer) (ProgrammableTransaction, error)

func (*ProgrammableTransaction) BcsSerialize 

func (obj *ProgrammableTransaction) BcsSerialize() ([]byte, error)

func (*ProgrammableTransaction) Serialize 

func (obj *ProgrammableTransaction) Serialize(serializer serde.Serializer) error

type ProtocolVersion 

type ProtocolVersion uint64

func BcsDeserializeProtocolVersion 

func BcsDeserializeProtocolVersion(input []byte) (ProtocolVersion, error)

func DeserializeProtocolVersion 

func DeserializeProtocolVersion(deserializer serde.Deserializer) (ProtocolVersion, error)

func (*ProtocolVersion) BcsSerialize 

func (obj *ProtocolVersion) BcsSerialize() ([]byte, error)

func (*ProtocolVersion) Serialize 

func (obj *ProtocolVersion) Serialize(serializer serde.Serializer) error

type SenderSignedData 

type SenderSignedData []SenderSignedTransaction

func BcsDeserializeSenderSignedData 

func BcsDeserializeSenderSignedData(input []byte) (SenderSignedData, error)

func DeserializeSenderSignedData 

func DeserializeSenderSignedData(deserializer serde.Deserializer) (SenderSignedData, error)

func (*SenderSignedData) BcsSerialize 

func (obj *SenderSignedData) BcsSerialize() ([]byte, error)

func (*SenderSignedData) Serialize 

func (obj *SenderSignedData) Serialize(serializer serde.Serializer) error

type SenderSignedTransaction 

type SenderSignedTransaction struct {
	IntentMessage IntentMessage
	TxSignatures  []GenericSignature
}

func BcsDeserializeSenderSignedTransaction 

func BcsDeserializeSenderSignedTransaction(input []byte) (SenderSignedTransaction, error)

func DeserializeSenderSignedTransaction 

func DeserializeSenderSignedTransaction(deserializer serde.Deserializer) (SenderSignedTransaction, error)

func (*SenderSignedTransaction) BcsSerialize 

func (obj *SenderSignedTransaction) BcsSerialize() ([]byte, error)

func (*SenderSignedTransaction) Serialize 

func (obj *SenderSignedTransaction) Serialize(serializer serde.Serializer) error

type SequenceNumber 

type SequenceNumber uint64

func BcsDeserializeSequenceNumber 

func BcsDeserializeSequenceNumber(input []byte) (SequenceNumber, error)

func DeserializeSequenceNumber 

func DeserializeSequenceNumber(deserializer serde.Deserializer) (SequenceNumber, error)

func (*SequenceNumber) BcsSerialize 

func (obj *SequenceNumber) BcsSerialize() ([]byte, error)

func (*SequenceNumber) Serialize 

func (obj *SequenceNumber) Serialize(serializer serde.Serializer) error

type StructTag 

type StructTag struct {
	Address  AccountAddress
	Module   Identifier
	Name     Identifier
	TypeArgs []TypeTag
}

func BcsDeserializeStructTag 

func BcsDeserializeStructTag(input []byte) (StructTag, error)

func DeserializeStructTag 

func DeserializeStructTag(deserializer serde.Deserializer) (StructTag, error)

func (*StructTag) BcsSerialize 

func (obj *StructTag) BcsSerialize() ([]byte, error)

func (*StructTag) Serialize 

func (obj *StructTag) Serialize(serializer serde.Serializer) error

type SuiAddress 

type SuiAddress [32]uint8

func BcsDeserializeSuiAddress 

func BcsDeserializeSuiAddress(input []byte) (SuiAddress, error)

func DeserializeSuiAddress 

func DeserializeSuiAddress(deserializer serde.Deserializer) (SuiAddress, error)

func (*SuiAddress) BcsSerialize 

func (obj *SuiAddress) BcsSerialize() ([]byte, error)

func (*SuiAddress) Serialize 

func (obj *SuiAddress) Serialize(serializer serde.Serializer) error

type TransactionData 

type TransactionData interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeTransactionData 

func BcsDeserializeTransactionData(input []byte) (TransactionData, error)

func DeserializeTransactionData 

func DeserializeTransactionData(deserializer serde.Deserializer) (TransactionData, error)

type TransactionDataV1 

type TransactionDataV1 struct {
	Kind       TransactionKind
	Sender     SuiAddress
	GasData    GasData
	Expiration TransactionExpiration
}

func BcsDeserializeTransactionDataV1 

func BcsDeserializeTransactionDataV1(input []byte) (TransactionDataV1, error)

func DeserializeTransactionDataV1 

func DeserializeTransactionDataV1(deserializer serde.Deserializer) (TransactionDataV1, error)

func (*TransactionDataV1) BcsSerialize 

func (obj *TransactionDataV1) BcsSerialize() ([]byte, error)

func (*TransactionDataV1) Serialize 

func (obj *TransactionDataV1) Serialize(serializer serde.Serializer) error

type TransactionData__V1 

type TransactionData__V1 struct {
	Value TransactionDataV1
}

func (*TransactionData__V1) BcsSerialize 

func (obj *TransactionData__V1) BcsSerialize() ([]byte, error)

func (*TransactionData__V1) Serialize 

func (obj *TransactionData__V1) Serialize(serializer serde.Serializer) error

type TransactionDigest 

type TransactionDigest struct {
	Value Digest
}

func BcsDeserializeTransactionDigest 

func BcsDeserializeTransactionDigest(input []byte) (TransactionDigest, error)

func DeserializeTransactionDigest 

func DeserializeTransactionDigest(deserializer serde.Deserializer) (TransactionDigest, error)

func (*TransactionDigest) BcsSerialize 

func (obj *TransactionDigest) BcsSerialize() ([]byte, error)

func (*TransactionDigest) Serialize 

func (obj *TransactionDigest) Serialize(serializer serde.Serializer) error

type TransactionEffects 

type TransactionEffects interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeTransactionEffects 

func BcsDeserializeTransactionEffects(input []byte) (TransactionEffects, error)

func DeserializeTransactionEffects 

func DeserializeTransactionEffects(deserializer serde.Deserializer) (TransactionEffects, error)

type TransactionEffectsDigest 

type TransactionEffectsDigest struct {
	Value Digest
}

func BcsDeserializeTransactionEffectsDigest 

func BcsDeserializeTransactionEffectsDigest(input []byte) (TransactionEffectsDigest, error)

func DeserializeTransactionEffectsDigest 

func DeserializeTransactionEffectsDigest(deserializer serde.Deserializer) (TransactionEffectsDigest, error)

func (*TransactionEffectsDigest) BcsSerialize 

func (obj *TransactionEffectsDigest) BcsSerialize() ([]byte, error)

func (*TransactionEffectsDigest) Serialize 

func (obj *TransactionEffectsDigest) Serialize(serializer serde.Serializer) error

type TransactionEffectsV1 

type TransactionEffectsV1 struct {
	Status             ExecutionStatus
	ExecutedEpoch      uint64
	GasUsed            GasCostSummary
	ModifiedAtVersions []struct {
		Field0 ObjectID
		Field1 SequenceNumber
	}
	SharedObjects []struct {
		Field0 ObjectID
		Field1 SequenceNumber
		Field2 ObjectDigest
	}
	TransactionDigest TransactionDigest
	Created           []struct {
		Field0 struct {
			Field0 ObjectID
			Field1 SequenceNumber
			Field2 ObjectDigest
		}
		Field1 Owner
	}
	Mutated []struct {
		Field0 struct {
			Field0 ObjectID
			Field1 SequenceNumber
			Field2 ObjectDigest
		}
		Field1 Owner
	}
	Unwrapped []struct {
		Field0 struct {
			Field0 ObjectID
			Field1 SequenceNumber
			Field2 ObjectDigest
		}
		Field1 Owner
	}
	Deleted []struct {
		Field0 ObjectID
		Field1 SequenceNumber
		Field2 ObjectDigest
	}
	UnwrappedThenDeleted []struct {
		Field0 ObjectID
		Field1 SequenceNumber
		Field2 ObjectDigest
	}
	Wrapped []struct {
		Field0 ObjectID
		Field1 SequenceNumber
		Field2 ObjectDigest
	}
	GasObject struct {
		Field0 struct {
			Field0 ObjectID
			Field1 SequenceNumber
			Field2 ObjectDigest
		}
		Field1 Owner
	}
	EventsDigest *TransactionEventsDigest
	Dependencies []TransactionDigest
}

func BcsDeserializeTransactionEffectsV1 

func BcsDeserializeTransactionEffectsV1(input []byte) (TransactionEffectsV1, error)

func DeserializeTransactionEffectsV1 

func DeserializeTransactionEffectsV1(deserializer serde.Deserializer) (TransactionEffectsV1, error)

func (*TransactionEffectsV1) BcsSerialize 

func (obj *TransactionEffectsV1) BcsSerialize() ([]byte, error)

func (*TransactionEffectsV1) Serialize 

func (obj *TransactionEffectsV1) Serialize(serializer serde.Serializer) error

type TransactionEffects__V1 

type TransactionEffects__V1 struct {
	Value TransactionEffectsV1
}

func (*TransactionEffects__V1) BcsSerialize 

func (obj *TransactionEffects__V1) BcsSerialize() ([]byte, error)

func (*TransactionEffects__V1) Serialize 

func (obj *TransactionEffects__V1) Serialize(serializer serde.Serializer) error

type TransactionEventsDigest 

type TransactionEventsDigest struct {
	Value Digest
}

func BcsDeserializeTransactionEventsDigest 

func BcsDeserializeTransactionEventsDigest(input []byte) (TransactionEventsDigest, error)

func DeserializeTransactionEventsDigest 

func DeserializeTransactionEventsDigest(deserializer serde.Deserializer) (TransactionEventsDigest, error)

func (*TransactionEventsDigest) BcsSerialize 

func (obj *TransactionEventsDigest) BcsSerialize() ([]byte, error)

func (*TransactionEventsDigest) Serialize 

func (obj *TransactionEventsDigest) Serialize(serializer serde.Serializer) error

type TransactionExpiration 

type TransactionExpiration interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeTransactionExpiration 

func BcsDeserializeTransactionExpiration(input []byte) (TransactionExpiration, error)

func DeserializeTransactionExpiration 

func DeserializeTransactionExpiration(deserializer serde.Deserializer) (TransactionExpiration, error)

type TransactionExpiration__Epoch 

type TransactionExpiration__Epoch uint64

func (*TransactionExpiration__Epoch) BcsSerialize 

func (obj *TransactionExpiration__Epoch) BcsSerialize() ([]byte, error)

func (*TransactionExpiration__Epoch) Serialize 

func (obj *TransactionExpiration__Epoch) Serialize(serializer serde.Serializer) error

type TransactionExpiration__None 

type TransactionExpiration__None struct {
}

func (*TransactionExpiration__None) BcsSerialize 

func (obj *TransactionExpiration__None) BcsSerialize() ([]byte, error)

func (*TransactionExpiration__None) Serialize 

func (obj *TransactionExpiration__None) Serialize(serializer serde.Serializer) error

type TransactionKind 

type TransactionKind interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeTransactionKind 

func BcsDeserializeTransactionKind(input []byte) (TransactionKind, error)

func DeserializeTransactionKind 

func DeserializeTransactionKind(deserializer serde.Deserializer) (TransactionKind, error)

type TransactionKind__ChangeEpoch 

type TransactionKind__ChangeEpoch struct {
	Value ChangeEpoch
}

func (*TransactionKind__ChangeEpoch) BcsSerialize 

func (obj *TransactionKind__ChangeEpoch) BcsSerialize() ([]byte, error)

func (*TransactionKind__ChangeEpoch) Serialize 

func (obj *TransactionKind__ChangeEpoch) Serialize(serializer serde.Serializer) error

type TransactionKind__ConsensusCommitPrologue 

type TransactionKind__ConsensusCommitPrologue struct {
	Value ConsensusCommitPrologue
}

func (*TransactionKind__ConsensusCommitPrologue) BcsSerialize 

func (obj *TransactionKind__ConsensusCommitPrologue) BcsSerialize() ([]byte, error)

func (*TransactionKind__ConsensusCommitPrologue) Serialize 

func (obj *TransactionKind__ConsensusCommitPrologue) Serialize(serializer serde.Serializer) error

type TransactionKind__Genesis 

type TransactionKind__Genesis struct {
	Value GenesisTransaction
}

func (*TransactionKind__Genesis) BcsSerialize 

func (obj *TransactionKind__Genesis) BcsSerialize() ([]byte, error)

func (*TransactionKind__Genesis) Serialize 

func (obj *TransactionKind__Genesis) Serialize(serializer serde.Serializer) error

type TransactionKind__ProgrammableTransaction 

type TransactionKind__ProgrammableTransaction struct {
	Value ProgrammableTransaction
}

func (*TransactionKind__ProgrammableTransaction) BcsSerialize 

func (obj *TransactionKind__ProgrammableTransaction) BcsSerialize() ([]byte, error)

func (*TransactionKind__ProgrammableTransaction) Serialize 

func (obj *TransactionKind__ProgrammableTransaction) Serialize(serializer serde.Serializer) error

type TypeArgumentError 

type TypeArgumentError interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeTypeArgumentError 

func BcsDeserializeTypeArgumentError(input []byte) (TypeArgumentError, error)

func DeserializeTypeArgumentError 

func DeserializeTypeArgumentError(deserializer serde.Deserializer) (TypeArgumentError, error)

type TypeArgumentError__ConstraintNotSatisfied 

type TypeArgumentError__ConstraintNotSatisfied struct {
}

func (*TypeArgumentError__ConstraintNotSatisfied) BcsSerialize 

func (obj *TypeArgumentError__ConstraintNotSatisfied) BcsSerialize() ([]byte, error)

func (*TypeArgumentError__ConstraintNotSatisfied) Serialize 

func (obj *TypeArgumentError__ConstraintNotSatisfied) Serialize(serializer serde.Serializer) error

type TypeArgumentError__TypeNotFound 

type TypeArgumentError__TypeNotFound struct {
}

func (*TypeArgumentError__TypeNotFound) BcsSerialize 

func (obj *TypeArgumentError__TypeNotFound) BcsSerialize() ([]byte, error)

func (*TypeArgumentError__TypeNotFound) Serialize 

func (obj *TypeArgumentError__TypeNotFound) Serialize(serializer serde.Serializer) error

type TypeOrigin 

type TypeOrigin struct {
	ModuleName string
	StructName string
	Package    ObjectID
}

func BcsDeserializeTypeOrigin 

func BcsDeserializeTypeOrigin(input []byte) (TypeOrigin, error)

func DeserializeTypeOrigin 

func DeserializeTypeOrigin(deserializer serde.Deserializer) (TypeOrigin, error)

func (*TypeOrigin) BcsSerialize 

func (obj *TypeOrigin) BcsSerialize() ([]byte, error)

func (*TypeOrigin) Serialize 

func (obj *TypeOrigin) Serialize(serializer serde.Serializer) error

type TypeTag 

type TypeTag interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeTypeTag 

func BcsDeserializeTypeTag(input []byte) (TypeTag, error)

func DeserializeTypeTag 

func DeserializeTypeTag(deserializer serde.Deserializer) (TypeTag, error)

type TypeTag__Address 

type TypeTag__Address struct {
}

func (*TypeTag__Address) BcsSerialize 

func (obj *TypeTag__Address) BcsSerialize() ([]byte, error)

func (*TypeTag__Address) Serialize 

func (obj *TypeTag__Address) Serialize(serializer serde.Serializer) error

type TypeTag__Bool 

type TypeTag__Bool struct {
}

func (*TypeTag__Bool) BcsSerialize 

func (obj *TypeTag__Bool) BcsSerialize() ([]byte, error)

func (*TypeTag__Bool) Serialize 

func (obj *TypeTag__Bool) Serialize(serializer serde.Serializer) error

type TypeTag__Signer 

type TypeTag__Signer struct {
}

func (*TypeTag__Signer) BcsSerialize 

func (obj *TypeTag__Signer) BcsSerialize() ([]byte, error)

func (*TypeTag__Signer) Serialize 

func (obj *TypeTag__Signer) Serialize(serializer serde.Serializer) error

type TypeTag__Struct 

type TypeTag__Struct struct {
	Value StructTag
}

func (*TypeTag__Struct) BcsSerialize 

func (obj *TypeTag__Struct) BcsSerialize() ([]byte, error)

func (*TypeTag__Struct) Serialize 

func (obj *TypeTag__Struct) Serialize(serializer serde.Serializer) error

type TypeTag__U128 

type TypeTag__U128 struct {
}

func (*TypeTag__U128) BcsSerialize 

func (obj *TypeTag__U128) BcsSerialize() ([]byte, error)

func (*TypeTag__U128) Serialize 

func (obj *TypeTag__U128) Serialize(serializer serde.Serializer) error

type TypeTag__U16 

type TypeTag__U16 struct {
}

func (*TypeTag__U16) BcsSerialize 

func (obj *TypeTag__U16) BcsSerialize() ([]byte, error)

func (*TypeTag__U16) Serialize 

func (obj *TypeTag__U16) Serialize(serializer serde.Serializer) error

type TypeTag__U256 

type TypeTag__U256 struct {
}

func (*TypeTag__U256) BcsSerialize 

func (obj *TypeTag__U256) BcsSerialize() ([]byte, error)

func (*TypeTag__U256) Serialize 

func (obj *TypeTag__U256) Serialize(serializer serde.Serializer) error

type TypeTag__U32 

type TypeTag__U32 struct {
}

func (*TypeTag__U32) BcsSerialize 

func (obj *TypeTag__U32) BcsSerialize() ([]byte, error)

func (*TypeTag__U32) Serialize 

func (obj *TypeTag__U32) Serialize(serializer serde.Serializer) error

type TypeTag__U64 

type TypeTag__U64 struct {
}

func (*TypeTag__U64) BcsSerialize 

func (obj *TypeTag__U64) BcsSerialize() ([]byte, error)

func (*TypeTag__U64) Serialize 

func (obj *TypeTag__U64) Serialize(serializer serde.Serializer) error

type TypeTag__U8 

type TypeTag__U8 struct {
}

func (*TypeTag__U8) BcsSerialize 

func (obj *TypeTag__U8) BcsSerialize() ([]byte, error)

func (*TypeTag__U8) Serialize 

func (obj *TypeTag__U8) Serialize(serializer serde.Serializer) error

type TypeTag__Vector 

type TypeTag__Vector struct {
	Value TypeTag
}

func (*TypeTag__Vector) BcsSerialize 

func (obj *TypeTag__Vector) BcsSerialize() ([]byte, error)

func (*TypeTag__Vector) Serialize 

func (obj *TypeTag__Vector) Serialize(serializer serde.Serializer) error

type TypedStoreError 

type TypedStoreError interface {
	Serialize(serializer serde.Serializer) error
	BcsSerialize() ([]byte, error)
	// contains filtered or unexported methods
}

func BcsDeserializeTypedStoreError 

func BcsDeserializeTypedStoreError(input []byte) (TypedStoreError, error)

func DeserializeTypedStoreError 

func DeserializeTypedStoreError(deserializer serde.Deserializer) (TypedStoreError, error)

type TypedStoreError__CrossDbBatch 

type TypedStoreError__CrossDbBatch struct {
}

func (*TypedStoreError__CrossDbBatch) BcsSerialize 

func (obj *TypedStoreError__CrossDbBatch) BcsSerialize() ([]byte, error)

func (*TypedStoreError__CrossDbBatch) Serialize 

func (obj *TypedStoreError__CrossDbBatch) Serialize(serializer serde.Serializer) error

type TypedStoreError__MetricsReporting 

type TypedStoreError__MetricsReporting struct {
}

func (*TypedStoreError__MetricsReporting) BcsSerialize 

func (obj *TypedStoreError__MetricsReporting) BcsSerialize() ([]byte, error)

func (*TypedStoreError__MetricsReporting) Serialize 

func (obj *TypedStoreError__MetricsReporting) Serialize(serializer serde.Serializer) error

type TypedStoreError__RetryableTransactionError 

type TypedStoreError__RetryableTransactionError struct {
}

func (*TypedStoreError__RetryableTransactionError) BcsSerialize 

func (obj *TypedStoreError__RetryableTransactionError) BcsSerialize() ([]byte, error)

func (*TypedStoreError__RetryableTransactionError) Serialize 

func (obj *TypedStoreError__RetryableTransactionError) Serialize(serializer serde.Serializer) error

type TypedStoreError__RocksDbError 

type TypedStoreError__RocksDbError string

func (*TypedStoreError__RocksDbError) BcsSerialize 

func (obj *TypedStoreError__RocksDbError) BcsSerialize() ([]byte, error)

func (*TypedStoreError__RocksDbError) Serialize 

func (obj *TypedStoreError__RocksDbError) Serialize(serializer serde.Serializer) error

type TypedStoreError__SerializationError 

type TypedStoreError__SerializationError string

func (*TypedStoreError__SerializationError) BcsSerialize 

func (obj *TypedStoreError__SerializationError) BcsSerialize() ([]byte, error)

func (*TypedStoreError__SerializationError) Serialize 

func (obj *TypedStoreError__SerializationError) Serialize(serializer serde.Serializer) error

type TypedStoreError__UnregisteredColumn 

type TypedStoreError__UnregisteredColumn string

func (*TypedStoreError__UnregisteredColumn) BcsSerialize 

func (obj *TypedStoreError__UnregisteredColumn) BcsSerialize() ([]byte, error)

func (*TypedStoreError__UnregisteredColumn) Serialize 

func (obj *TypedStoreError__UnregisteredColumn) Serialize(serializer serde.Serializer) error

type UpgradeInfo 

type UpgradeInfo struct {
	UpgradedId      ObjectID
	UpgradedVersion SequenceNumber
}

func BcsDeserializeUpgradeInfo 

func BcsDeserializeUpgradeInfo(input []byte) (UpgradeInfo, error)

func DeserializeUpgradeInfo 

func DeserializeUpgradeInfo(deserializer serde.Deserializer) (UpgradeInfo, error)

func (*UpgradeInfo) BcsSerialize 

func (obj *UpgradeInfo) BcsSerialize() ([]byte, error)

func (*UpgradeInfo) Serialize 

func (obj *UpgradeInfo) Serialize(serializer serde.Serializer) 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.