registry

Documentation

Index

• Constants
• type ArrayDecoder
  • func (a *ArrayDecoder) Decode(decoder *scale.Decoder) (any, error)
• type BitSequenceDecoder
  • func (b *BitSequenceDecoder) Decode(decoder *scale.Decoder) (any, error)
• type CallRegistry
• type CompositeDecoder
  • func (e *CompositeDecoder) Decode(decoder *scale.Decoder) (any, error)
• type ErrorRegistry
• type EventRegistry
• type Factory
  • func NewFactory() Factory
• type FactoryMock
  • func NewFactoryMock(t NewFactoryMockT) *FactoryMock
  • func (_m *FactoryMock) CreateCallRegistry(meta *types.Metadata) (CallRegistry, error)
  • func (_m *FactoryMock) CreateErrorRegistry(meta *types.Metadata) (ErrorRegistry, error)
  • func (_m *FactoryMock) CreateEventRegistry(meta *types.Metadata) (EventRegistry, error)
• type Field
• type FieldDecoder
• type NewFactoryMockT
• type NoopDecoder
  • func (n *NoopDecoder) Decode(_ *scale.Decoder) (any, error)
• type RecursiveDecoder
  • func (r *RecursiveDecoder) Decode(decoder *scale.Decoder) (any, error)
• type SliceDecoder
  • func (s *SliceDecoder) Decode(decoder *scale.Decoder) (any, error)
• type Type
  • func (t *Type) Decode(decoder *scale.Decoder) (map[string]any, error)
• type ValueDecoder
  • func (v *ValueDecoder[T]) Decode(decoder *scale.Decoder) (any, error)
• type VariantDecoder
  • func (v *VariantDecoder) Decode(decoder *scale.Decoder) (any, error)

Constants

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")
)

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]*Type

CallRegistry maps a call name to its Type.

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 ErrorRegistry

type ErrorRegistry map[string]*Type

ErrorRegistry maps an error name to its Type.

type EventRegistry

type EventRegistry map[types.EventID]*Type

EventRegistry maps an event ID to its Type.

type Factory

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

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

func NewFactory

func NewFactory() Factory

NewFactory creates a new Factory.

type FactoryMock

type FactoryMock struct {
	mock.Mock
}

FactoryMock is an autogenerated mock type for the Factory type

func NewFactoryMock

func NewFactoryMock(t NewFactoryMockT) *FactoryMock

NewFactoryMock creates a new instance of FactoryMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*FactoryMock) CreateCallRegistry

func (_m *FactoryMock) CreateCallRegistry(meta *types.Metadata) (CallRegistry, error)

CreateCallRegistry provides a mock function with given fields: meta

func (*FactoryMock) CreateErrorRegistry

func (_m *FactoryMock) CreateErrorRegistry(meta *types.Metadata) (ErrorRegistry, error)

CreateErrorRegistry provides a mock function with given fields: meta

func (*FactoryMock) CreateEventRegistry

func (_m *FactoryMock) CreateEventRegistry(meta *types.Metadata) (EventRegistry, error)

CreateEventRegistry provides a mock function with given fields: meta

type Field

type Field struct {
	Name         string
	FieldDecoder FieldDecoder
	LookupIndex  int64
}

Field represents one field of a Type.

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 NewFactoryMockT

type NewFactoryMockT interface {
	mock.TestingT
	Cleanup(func())
}

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 Type

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

Type represents a parsed metadata type.

func (*Type) Decode

func (t *Type) Decode(decoder *scale.Decoder) (map[string]any, 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)