parse_legacy_transaction_status_meta_b7b4aa5d4d34ebf3fd338a64f4f2a5257b047bb4

package
v0.5.0 Latest Latest
Warning

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

Go to latest
Published: Nov 14, 2024 License: AGPL-3.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type InstructionError

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

func BincodeDeserializeInstructionError

func BincodeDeserializeInstructionError(input []byte) (InstructionError, error)

func DeserializeInstructionError

func DeserializeInstructionError(deserializer serde.Deserializer) (InstructionError, error)

type InstructionError__AccountAlreadyInitialized

type InstructionError__AccountAlreadyInitialized struct{}

func (*InstructionError__AccountAlreadyInitialized) BincodeSerialize

func (obj *InstructionError__AccountAlreadyInitialized) BincodeSerialize() ([]byte, error)

func (*InstructionError__AccountAlreadyInitialized) Serialize

type InstructionError__AccountBorrowFailed

type InstructionError__AccountBorrowFailed struct{}

func (*InstructionError__AccountBorrowFailed) BincodeSerialize

func (obj *InstructionError__AccountBorrowFailed) BincodeSerialize() ([]byte, error)

func (*InstructionError__AccountBorrowFailed) Serialize

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

type InstructionError__AccountBorrowOutstanding

type InstructionError__AccountBorrowOutstanding struct{}

func (*InstructionError__AccountBorrowOutstanding) BincodeSerialize

func (obj *InstructionError__AccountBorrowOutstanding) BincodeSerialize() ([]byte, error)

func (*InstructionError__AccountBorrowOutstanding) Serialize

type InstructionError__AccountDataSizeChanged

type InstructionError__AccountDataSizeChanged struct{}

func (*InstructionError__AccountDataSizeChanged) BincodeSerialize

func (obj *InstructionError__AccountDataSizeChanged) BincodeSerialize() ([]byte, error)

func (*InstructionError__AccountDataSizeChanged) Serialize

type InstructionError__AccountDataTooSmall

type InstructionError__AccountDataTooSmall struct{}

func (*InstructionError__AccountDataTooSmall) BincodeSerialize

func (obj *InstructionError__AccountDataTooSmall) BincodeSerialize() ([]byte, error)

func (*InstructionError__AccountDataTooSmall) Serialize

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

type InstructionError__AccountNotExecutable

type InstructionError__AccountNotExecutable struct{}

func (*InstructionError__AccountNotExecutable) BincodeSerialize

func (obj *InstructionError__AccountNotExecutable) BincodeSerialize() ([]byte, error)

func (*InstructionError__AccountNotExecutable) Serialize

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

type InstructionError__CustomError

type InstructionError__CustomError uint32

func (*InstructionError__CustomError) BincodeSerialize

func (obj *InstructionError__CustomError) BincodeSerialize() ([]byte, error)

func (*InstructionError__CustomError) Serialize

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

type InstructionError__DuplicateAccountIndex

type InstructionError__DuplicateAccountIndex struct{}

func (*InstructionError__DuplicateAccountIndex) BincodeSerialize

func (obj *InstructionError__DuplicateAccountIndex) BincodeSerialize() ([]byte, error)

func (*InstructionError__DuplicateAccountIndex) Serialize

type InstructionError__DuplicateAccountOutOfSync

type InstructionError__DuplicateAccountOutOfSync struct{}

func (*InstructionError__DuplicateAccountOutOfSync) BincodeSerialize

func (obj *InstructionError__DuplicateAccountOutOfSync) BincodeSerialize() ([]byte, error)

func (*InstructionError__DuplicateAccountOutOfSync) Serialize

type InstructionError__ExecutableModified

type InstructionError__ExecutableModified struct{}

func (*InstructionError__ExecutableModified) BincodeSerialize

func (obj *InstructionError__ExecutableModified) BincodeSerialize() ([]byte, error)

func (*InstructionError__ExecutableModified) Serialize

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

type InstructionError__ExternalAccountDataModified

type InstructionError__ExternalAccountDataModified struct{}

func (*InstructionError__ExternalAccountDataModified) BincodeSerialize

func (obj *InstructionError__ExternalAccountDataModified) BincodeSerialize() ([]byte, error)

func (*InstructionError__ExternalAccountDataModified) Serialize

type InstructionError__ExternalAccountLamportSpend

type InstructionError__ExternalAccountLamportSpend struct{}

func (*InstructionError__ExternalAccountLamportSpend) BincodeSerialize

func (obj *InstructionError__ExternalAccountLamportSpend) BincodeSerialize() ([]byte, error)

func (*InstructionError__ExternalAccountLamportSpend) Serialize

type InstructionError__GenericError

type InstructionError__GenericError struct{}

func (*InstructionError__GenericError) BincodeSerialize

func (obj *InstructionError__GenericError) BincodeSerialize() ([]byte, error)

func (*InstructionError__GenericError) Serialize

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

type InstructionError__IncorrectProgramId

type InstructionError__IncorrectProgramId struct{}

func (*InstructionError__IncorrectProgramId) BincodeSerialize

func (obj *InstructionError__IncorrectProgramId) BincodeSerialize() ([]byte, error)

func (*InstructionError__IncorrectProgramId) Serialize

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

type InstructionError__InsufficientFunds

type InstructionError__InsufficientFunds struct{}

func (*InstructionError__InsufficientFunds) BincodeSerialize

func (obj *InstructionError__InsufficientFunds) BincodeSerialize() ([]byte, error)

func (*InstructionError__InsufficientFunds) Serialize

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

type InstructionError__InvalidAccountData

type InstructionError__InvalidAccountData struct{}

func (*InstructionError__InvalidAccountData) BincodeSerialize

func (obj *InstructionError__InvalidAccountData) BincodeSerialize() ([]byte, error)

func (*InstructionError__InvalidAccountData) Serialize

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

type InstructionError__InvalidArgument

type InstructionError__InvalidArgument struct{}

func (*InstructionError__InvalidArgument) BincodeSerialize

func (obj *InstructionError__InvalidArgument) BincodeSerialize() ([]byte, error)

func (*InstructionError__InvalidArgument) Serialize

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

type InstructionError__InvalidError

type InstructionError__InvalidError struct{}

func (*InstructionError__InvalidError) BincodeSerialize

func (obj *InstructionError__InvalidError) BincodeSerialize() ([]byte, error)

func (*InstructionError__InvalidError) Serialize

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

type InstructionError__InvalidInstructionData

type InstructionError__InvalidInstructionData struct{}

func (*InstructionError__InvalidInstructionData) BincodeSerialize

func (obj *InstructionError__InvalidInstructionData) BincodeSerialize() ([]byte, error)

func (*InstructionError__InvalidInstructionData) Serialize

type InstructionError__MissingRequiredSignature

type InstructionError__MissingRequiredSignature struct{}

func (*InstructionError__MissingRequiredSignature) BincodeSerialize

func (obj *InstructionError__MissingRequiredSignature) BincodeSerialize() ([]byte, error)

func (*InstructionError__MissingRequiredSignature) Serialize

type InstructionError__ModifiedProgramId

type InstructionError__ModifiedProgramId struct{}

func (*InstructionError__ModifiedProgramId) BincodeSerialize

func (obj *InstructionError__ModifiedProgramId) BincodeSerialize() ([]byte, error)

func (*InstructionError__ModifiedProgramId) Serialize

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

type InstructionError__NotEnoughAccountKeys

type InstructionError__NotEnoughAccountKeys struct{}

func (*InstructionError__NotEnoughAccountKeys) BincodeSerialize

func (obj *InstructionError__NotEnoughAccountKeys) BincodeSerialize() ([]byte, error)

func (*InstructionError__NotEnoughAccountKeys) Serialize

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

type InstructionError__ReadonlyDataModified

type InstructionError__ReadonlyDataModified struct{}

func (*InstructionError__ReadonlyDataModified) BincodeSerialize

func (obj *InstructionError__ReadonlyDataModified) BincodeSerialize() ([]byte, error)

func (*InstructionError__ReadonlyDataModified) Serialize

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

type InstructionError__ReadonlyLamportChange

type InstructionError__ReadonlyLamportChange struct{}

func (*InstructionError__ReadonlyLamportChange) BincodeSerialize

func (obj *InstructionError__ReadonlyLamportChange) BincodeSerialize() ([]byte, error)

func (*InstructionError__ReadonlyLamportChange) Serialize

type InstructionError__RentEpochModified

type InstructionError__RentEpochModified struct{}

func (*InstructionError__RentEpochModified) BincodeSerialize

func (obj *InstructionError__RentEpochModified) BincodeSerialize() ([]byte, error)

func (*InstructionError__RentEpochModified) Serialize

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

type InstructionError__UnbalancedInstruction

type InstructionError__UnbalancedInstruction struct{}

func (*InstructionError__UnbalancedInstruction) BincodeSerialize

func (obj *InstructionError__UnbalancedInstruction) BincodeSerialize() ([]byte, error)

func (*InstructionError__UnbalancedInstruction) Serialize

type InstructionError__UninitializedAccount

type InstructionError__UninitializedAccount struct{}

func (*InstructionError__UninitializedAccount) BincodeSerialize

func (obj *InstructionError__UninitializedAccount) BincodeSerialize() ([]byte, error)

func (*InstructionError__UninitializedAccount) Serialize

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

type Result

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

func BincodeDeserializeResult

func BincodeDeserializeResult(input []byte) (Result, error)

func DeserializeResult

func DeserializeResult(deserializer serde.Deserializer) (Result, error)

type Result__Err

type Result__Err struct {
	Value TransactionError
}

func (*Result__Err) BincodeSerialize

func (obj *Result__Err) BincodeSerialize() ([]byte, error)

func (*Result__Err) Serialize

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

type Result__Ok

type Result__Ok struct{}

func (*Result__Ok) BincodeSerialize

func (obj *Result__Ok) BincodeSerialize() ([]byte, error)

func (*Result__Ok) Serialize

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

type TransactionError

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

func BincodeDeserializeTransactionError

func BincodeDeserializeTransactionError(input []byte) (TransactionError, error)

func DeserializeTransactionError

func DeserializeTransactionError(deserializer serde.Deserializer) (TransactionError, error)

type TransactionError__AccountInUse

type TransactionError__AccountInUse struct{}

func (*TransactionError__AccountInUse) BincodeSerialize

func (obj *TransactionError__AccountInUse) BincodeSerialize() ([]byte, error)

func (*TransactionError__AccountInUse) Serialize

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

type TransactionError__AccountLoadedTwice

type TransactionError__AccountLoadedTwice struct{}

func (*TransactionError__AccountLoadedTwice) BincodeSerialize

func (obj *TransactionError__AccountLoadedTwice) BincodeSerialize() ([]byte, error)

func (*TransactionError__AccountLoadedTwice) Serialize

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

type TransactionError__AccountNotFound

type TransactionError__AccountNotFound struct{}

func (*TransactionError__AccountNotFound) BincodeSerialize

func (obj *TransactionError__AccountNotFound) BincodeSerialize() ([]byte, error)

func (*TransactionError__AccountNotFound) Serialize

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

type TransactionError__BlockhashNotFound

type TransactionError__BlockhashNotFound struct{}

func (*TransactionError__BlockhashNotFound) BincodeSerialize

func (obj *TransactionError__BlockhashNotFound) BincodeSerialize() ([]byte, error)

func (*TransactionError__BlockhashNotFound) Serialize

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

type TransactionError__CallChainTooDeep

type TransactionError__CallChainTooDeep struct{}

func (*TransactionError__CallChainTooDeep) BincodeSerialize

func (obj *TransactionError__CallChainTooDeep) BincodeSerialize() ([]byte, error)

func (*TransactionError__CallChainTooDeep) Serialize

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

type TransactionError__DuplicateSignature

type TransactionError__DuplicateSignature struct{}

func (*TransactionError__DuplicateSignature) BincodeSerialize

func (obj *TransactionError__DuplicateSignature) BincodeSerialize() ([]byte, error)

func (*TransactionError__DuplicateSignature) Serialize

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

type TransactionError__InstructionError

type TransactionError__InstructionError struct {
	Field0 uint8
	Field1 InstructionError
}

func (*TransactionError__InstructionError) BincodeSerialize

func (obj *TransactionError__InstructionError) BincodeSerialize() ([]byte, error)

func (*TransactionError__InstructionError) Serialize

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

type TransactionError__InsufficientFundsForFee

type TransactionError__InsufficientFundsForFee struct{}

func (*TransactionError__InsufficientFundsForFee) BincodeSerialize

func (obj *TransactionError__InsufficientFundsForFee) BincodeSerialize() ([]byte, error)

func (*TransactionError__InsufficientFundsForFee) Serialize

type TransactionError__InvalidAccountForFee

type TransactionError__InvalidAccountForFee struct{}

func (*TransactionError__InvalidAccountForFee) BincodeSerialize

func (obj *TransactionError__InvalidAccountForFee) BincodeSerialize() ([]byte, error)

func (*TransactionError__InvalidAccountForFee) Serialize

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

type TransactionError__InvalidAccountIndex

type TransactionError__InvalidAccountIndex struct{}

func (*TransactionError__InvalidAccountIndex) BincodeSerialize

func (obj *TransactionError__InvalidAccountIndex) BincodeSerialize() ([]byte, error)

func (*TransactionError__InvalidAccountIndex) Serialize

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

type TransactionError__InvalidProgramForExecution

type TransactionError__InvalidProgramForExecution struct{}

func (*TransactionError__InvalidProgramForExecution) BincodeSerialize

func (obj *TransactionError__InvalidProgramForExecution) BincodeSerialize() ([]byte, error)

func (*TransactionError__InvalidProgramForExecution) Serialize

type TransactionError__MissingSignatureForFee

type TransactionError__MissingSignatureForFee struct{}

func (*TransactionError__MissingSignatureForFee) BincodeSerialize

func (obj *TransactionError__MissingSignatureForFee) BincodeSerialize() ([]byte, error)

func (*TransactionError__MissingSignatureForFee) Serialize

type TransactionError__ProgramAccountNotFound

type TransactionError__ProgramAccountNotFound struct{}

func (*TransactionError__ProgramAccountNotFound) BincodeSerialize

func (obj *TransactionError__ProgramAccountNotFound) BincodeSerialize() ([]byte, error)

func (*TransactionError__ProgramAccountNotFound) Serialize

type TransactionError__SignatureFailure

type TransactionError__SignatureFailure struct{}

func (*TransactionError__SignatureFailure) BincodeSerialize

func (obj *TransactionError__SignatureFailure) BincodeSerialize() ([]byte, error)

func (*TransactionError__SignatureFailure) Serialize

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

type TransactionStatusMeta

type TransactionStatusMeta struct {
	Status       Result
	Fee          uint64
	PreBalances  []uint64
	PostBalances []uint64
}

func BincodeDeserializeTransactionStatusMeta

func BincodeDeserializeTransactionStatusMeta(input []byte) (TransactionStatusMeta, error)

func DeserializeTransactionStatusMeta

func DeserializeTransactionStatusMeta(deserializer serde.Deserializer) (TransactionStatusMeta, error)

func (*TransactionStatusMeta) BincodeSerialize

func (obj *TransactionStatusMeta) BincodeSerialize() ([]byte, error)

func (*TransactionStatusMeta) Serialize

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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL