registry

package
v1.4.552 Latest Latest
Warning

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

 Go to latest Published: Oct 31, 2024 License: GPL-2.0 Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ErrRecursiveDecodersResolving            = libErr.Error("recursive decoders resolving")
	ErrErrorsTypeNotFound                    = libErr.Error("errors type not found")
	ErrErrorsTypeNotVariant                  = libErr.Error("errors type not a variant")
	ErrErrorFieldsRetrieval                  = libErr.Error("error fields retrieval")
	ErrCallsTypeNotFound                     = libErr.Error("calls type not found")
	ErrCallsTypeNotVariant                   = libErr.Error("calls type not a variant")
	ErrCallFieldsRetrieval                   = libErr.Error("call fields retrieval")
	ErrEventsTypeNotFound                    = libErr.Error("events type not found")
	ErrEventsTypeNotVariant                  = libErr.Error("events type not a variant")
	ErrEventFieldsRetrieval                  = libErr.Error("event fields retrieval")
	ErrFieldDecoderForRecursiveFieldNotFound = libErr.Error("field decoder for recursive field not found")
	ErrRecursiveFieldResolving               = libErr.Error("recursive field resolving")
	ErrFieldTypeNotFound                     = libErr.Error("field type not found")
	ErrFieldDecoderRetrieval                 = libErr.Error("field decoder retrieval")
	ErrCompactFieldTypeNotFound              = libErr.Error("compact field type not found")
	ErrCompositeTypeFieldsRetrieval          = libErr.Error("composite type fields retrieval")
	ErrArrayFieldTypeNotFound                = libErr.Error("array field type not found")
	ErrVectorFieldTypeNotFound               = libErr.Error("vector field type not found")
	ErrFieldTypeDefinitionNotSupported       = libErr.Error("field type definition not supported")
	ErrVariantTypeFieldsRetrieval            = libErr.Error("variant type fields decoding")
	ErrCompactTupleItemTypeNotFound          = libErr.Error("compact tuple item type not found")
	ErrCompactTupleItemFieldDecoderRetrieval = libErr.Error("compact tuple item field decoder retrieval")
	ErrCompactCompositeFieldTypeNotFound     = libErr.Error("compact composite field type not found")
	ErrCompactCompositeFieldDecoderRetrieval = libErr.Error("compact composite field decoder retrieval")
	ErrArrayItemFieldDecoderRetrieval        = libErr.Error("array item field decoder retrieval")
	ErrSliceItemFieldDecoderRetrieval        = libErr.Error("slice item field decoder retrieval")
	ErrTupleItemTypeNotFound                 = libErr.Error("tuple item type not found")
	ErrTupleItemFieldDecoderRetrieval        = libErr.Error("tuple item field decoder retrieval")
	ErrBitStoreTypeNotFound                  = libErr.Error("bit store type not found")
	ErrBitStoreTypeNotSupported              = libErr.Error("bit store type not supported")
	ErrBitOrderTypeNotFound                  = libErr.Error("bit order type not found")
	ErrBitOrderCreation                      = libErr.Error("bit order creation")
	ErrPrimitiveTypeNotSupported             = libErr.Error("primitive type not supported")
	ErrTypeFieldDecoding                     = libErr.Error("type field decoding")
	ErrVariantByteDecoding                   = libErr.Error("variant byte decoding")
	ErrVariantFieldDecoderNotFound           = libErr.Error("variant field decoder not found")
	ErrArrayItemDecoderNotFound              = libErr.Error("array item decoder not found")
	ErrArrayItemDecoding                     = libErr.Error("array item decoding")
	ErrSliceItemDecoderNotFound              = libErr.Error("slice item decoder not found")
	ErrSliceLengthDecoding                   = libErr.Error("slice length decoding")
	ErrSliceItemDecoding                     = libErr.Error("slice item decoding")
	ErrCompositeFieldDecoding                = libErr.Error("composite field decoding")
	ErrValueDecoding                         = libErr.Error("value decoding")
	ErrRecursiveFieldDecoderNotFound         = libErr.Error("recursive field decoder not found")
	ErrBitVecDecoding                        = libErr.Error("bit vec decoding")
	ErrNilTypeDecoder                        = libErr.Error("nil type decoder")
	ErrNilField                              = libErr.Error("nil field")
	ErrNilFieldDecoder                       = libErr.Error("nil field decoder")
	ErrDecodedFieldNotFound                  = libErr.Error("decoded field not found")
	ErrDecodedFieldValueTypeMismatch         = libErr.Error("decoded field value type mismatch")
	ErrDecodedFieldValueProcessingError      = libErr.Error("decoded field value processing error")
	ErrDecodedFieldValueNotAGenericSlice     = libErr.Error("decoded field value is not a generic slice")
	ErrExtrinsicFieldRetrieval               = libErr.Error("extrinsic field retrieval")
	ErrInvalidExtrinsicParams                = libErr.Error("invalid extrinsic params")
	ErrInvalidExtrinsicType                  = libErr.Error("invalid extrinsic type")
	ErrInvalidGenericExtrinsicType           = libErr.Error("invalid generic extrinsic type")
	ErrNilExtrinsicDecoder                   = libErr.Error("nil type decoder")
	ErrExtrinsicFieldNotFound                = libErr.Error("extrinsic field not found")
	ErrExtrinsicCompactLengthDecoding        = libErr.Error("extrinsic compact length decoding")
	ErrExtrinsicVersionDecoding              = libErr.Error("extrinsic version decoding")
	ErrUnexpectedExtrinsicParam              = libErr.Error("unexpected extrinsic param")
	ErrExtrinsicFieldDecoding                = libErr.Error("extrinsic field decoding")
)
View Source 
const (
	ExtrinsicAddressName   = "Address"
	ExtrinsicSignatureName = "Signature"
	ExtrinsicExtraName     = "Extra"
	ExtrinsicCallName      = "Call"
)
View Source 
const (
	// ExpectedExtrinsicParamsCount is the count of generic params that we expect for a
	// generic Extrinsic type from the metadata.
	//
	// The parameters are expected to be in the following order:
	// 1. Address
	// 2. Call
	// 3. Signature
	// 4. Extra
	ExpectedExtrinsicParamsCount = 4
)

Variables

This section is empty.

Functions

func GetDecodedFieldAsSliceOfType 

func GetDecodedFieldAsSliceOfType[T any](
	decodedFields DecodedFields,
	fieldPredicateFn DecodedFieldPredicateFn,
) ([]T, error)

GetDecodedFieldAsSliceOfType returns the value of the field that matches the provided predicate func as a slice of the provided generic argument.

func GetDecodedFieldAsType 

func GetDecodedFieldAsType[T any](
	decodedFields DecodedFields,
	fieldPredicateFn DecodedFieldPredicateFn,
) (T, error)

GetDecodedFieldAsType returns the value of the field that matches the provided predicate func as the provided generic argument.

func ProcessDecodedFieldValue 

func ProcessDecodedFieldValue[T any](
	decodedFields DecodedFields,
	fieldPredicateFn DecodedFieldPredicateFn,
	valueProcessingFn DecodedValueProcessingFn[T],
) (T, error)

ProcessDecodedFieldValue applies the processing func to the value of the field that matches the provided predicate func.

Types

type ArrayDecoder 

type ArrayDecoder struct {
	Length      uint
	ItemDecoder FieldDecoder
}

ArrayDecoder holds information about the length of the array and the FieldDecoder used for its items.

func (*ArrayDecoder) Decode 

func (a *ArrayDecoder) Decode(decoder *scale.Decoder) (any, error)

type BitSequenceDecoder 

type BitSequenceDecoder struct {
	FieldName string
	BitOrder  types.BitOrder
}

BitSequenceDecoder holds decoding information for a bit sequence.

func (*BitSequenceDecoder) Decode 

func (b *BitSequenceDecoder) Decode(decoder *scale.Decoder) (any, error)

type CallRegistry 

type CallRegistry map[types.CallIndex]*TypeDecoder

CallRegistry maps a call name to its TypeDecoder.

type CompositeDecoder 

type CompositeDecoder struct {
	FieldName string
	Fields    []*Field
}

CompositeDecoder holds all the information required to decoder a struct/composite.

func (*CompositeDecoder) Decode 

func (e *CompositeDecoder) Decode(decoder *scale.Decoder) (any, error)

type DecodedExtrinsic 

type DecodedExtrinsic struct {
	Version       byte
	DecodedFields DecodedFields
}

DecodedExtrinsic is the type returned when an extrinsic is decoded.

func (DecodedExtrinsic) IsSigned 

func (d DecodedExtrinsic) IsSigned() bool

IsSigned returns true if the extrinsic is signed.

type DecodedField 

type DecodedField struct {
	Name        string
	Value       any
	LookupIndex int64
}

DecodedField holds the name, value and lookup index of a field that was decoded.

func (DecodedField) Encode 

func (d DecodedField) Encode(encoder scale.Encoder) error

type DecodedFieldPredicateFn 

type DecodedFieldPredicateFn func(fieldIndex int, field *DecodedField) bool

type DecodedFields 

type DecodedFields []*DecodedField

type DecodedValueProcessingFn 

type DecodedValueProcessingFn[T any] func(value any) (T, error)

type ErrorID 

type ErrorID struct {
	ModuleIndex types.U8
	ErrorIndex  [4]types.U8
}

ErrorID is the type using for identifying an error in the metadata.

type ErrorRegistry 

type ErrorRegistry map[ErrorID]*TypeDecoder

ErrorRegistry maps an error name to its TypeDecoder.

type EventRegistry 

type EventRegistry map[types.EventID]*TypeDecoder

EventRegistry maps an event ID to its TypeDecoder.

type ExtrinsicDecoder 

type ExtrinsicDecoder struct {
	Fields []*Field
}

ExtrinsicDecoder holds all the decoders for all the fields of an extrinsic.

func (*ExtrinsicDecoder) Decode 

func (d *ExtrinsicDecoder) Decode(decoder *scale.Decoder) (*DecodedExtrinsic, error)

Decode is used to decode the fields of an extrinsic in the following order:

1. Address 2. Signature 3. Extra 4. Call

NOTE - the decoding order is different from the order of the Extrinsic parameters provided in the metadata.

func (*ExtrinsicDecoder) DecodeHex 

func (d *ExtrinsicDecoder) DecodeHex(hexEncodedExtrinsic string) (*DecodedExtrinsic, error)

type Factory 

type Factory interface {
	CreateCallRegistry(meta *types.Metadata) (CallRegistry, error)
	CreateErrorRegistry(meta *types.Metadata) (ErrorRegistry, error)
	CreateEventRegistry(meta *types.Metadata) (EventRegistry, error)
	CreateExtrinsicDecoder(meta *types.Metadata) (*ExtrinsicDecoder, error)
}

Factory is the interface responsible for generating the according registries from the metadata.

func NewFactory 

func NewFactory(fieldOverrides ...FieldOverride) Factory

NewFactory creates a new Factory using the provided overrides, if any.

type Field 

type Field struct {
	Name         string
	FieldDecoder FieldDecoder
	LookupIndex  int64
}

Field represents one field of a TypeDecoder.

func (*Field) Decode 

func (f *Field) Decode(decoder *scale.Decoder) (*DecodedField, error)

type FieldDecoder 

type FieldDecoder interface {
	Decode(decoder *scale.Decoder) (any, error)
}

FieldDecoder is the interface implemented by all the different types that are available.

type FieldOverride 

type FieldOverride struct {
	FieldLookupIndex int64
	FieldDecoder     FieldDecoder
}

FieldOverride is used to override the default FieldDecoder for a particular type.

type NoopDecoder 

type NoopDecoder struct{}

NoopDecoder is a FieldDecoder that does not decode anything. It comes in handy for nil tuples or variants with no inner types.

func (*NoopDecoder) Decode 

func (n *NoopDecoder) Decode(_ *scale.Decoder) (any, error)

type RecursiveDecoder 

type RecursiveDecoder struct {
	FieldDecoder FieldDecoder
}

RecursiveDecoder is a wrapper for a FieldDecoder that is recursive.

func (*RecursiveDecoder) Decode 

func (r *RecursiveDecoder) Decode(decoder *scale.Decoder) (any, error)

type SliceDecoder 

type SliceDecoder struct {
	ItemDecoder FieldDecoder
}

SliceDecoder holds a FieldDecoder for the items of a vector/slice.

func (*SliceDecoder) Decode 

func (s *SliceDecoder) Decode(decoder *scale.Decoder) (any, error)

type TypeDecoder 

type TypeDecoder struct {
	Name   string
	Fields []*Field
}

TypeDecoder holds all information required to decode a particular type.

func (*TypeDecoder) Decode 

func (t *TypeDecoder) Decode(decoder *scale.Decoder) (DecodedFields, error)

type ValueDecoder 

type ValueDecoder[T any] struct{}

ValueDecoder decodes a primitive type.

func (*ValueDecoder[T]) Decode 

func (v *ValueDecoder[T]) Decode(decoder *scale.Decoder) (any, error)

type VariantDecoder 

type VariantDecoder struct {
	FieldDecoderMap map[byte]FieldDecoder
}

VariantDecoder holds a FieldDecoder for each variant/enum.

func (*VariantDecoder) Decode 

func (v *VariantDecoder) Decode(decoder *scale.Decoder) (any, error)

type VariantDecoderResult 

type VariantDecoderResult struct {
	FieldName string
	Value     any
}

Source Files

View all Source files

Directories

Path Synopsis

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.