transform

Documentation

Index

• Constants
• Variables
• func CombinedFilterTransformFactory(indexStore dstore.Store, possibleIndexSizes []uint64) *transform.Factory
• func MultiCallToFilterTransformFactory(indexStore dstore.Store, possibleIndexSizes []uint64) *transform.Factory
• func MultiLogFilterTransformFactory(indexStore dstore.Store, possibleIndexSizes []uint64) *transform.Factory
• type AddressSignatureFilter
• type CallToFilter
  • func NewCallToFilter(in *pbtransform.CallToFilter) (*CallToFilter, error)
  • func (f *CallToFilter) Addresses() []eth.Address
  • func (f *CallToFilter) Signatures() []eth.Hash
• type CombinedFilter
  • func (f *CombinedFilter) GetIndexProvider() bstream.BlockIndexProvider
  • func (f *CombinedFilter) String() string
  • func (f *CombinedFilter) Transform(readOnlyBlk *bstream.Block, in transform.Input) (transform.Output, error)
• type EthCombinedIndexer
  • func NewEthCombinedIndexer(indexStore dstore.Store, indexSize uint64) *EthCombinedIndexer
  • func (i *EthCombinedIndexer) ProcessBlock(blk *pbeth.Block)
• type HeaderOnlyFilter
  • func (p *HeaderOnlyFilter) String() string
  • func (p *HeaderOnlyFilter) Transform(readOnlyBlk *bstream.Block, in transform.Input) (transform.Output, error)
• type Indexer
• type LightBlockFilter
  • func (p *LightBlockFilter) String() string
  • func (p *LightBlockFilter) Transform(readOnlyBlk *bstream.Block, in transform.Input) (transform.Output, error)
• type LogFilter
  • func NewLogFilter(in *pbtransform.LogFilter) (*LogFilter, error)
  • func (f *LogFilter) Addresses() []eth.Address
  • func (f *LogFilter) Signatures() []eth.Hash

Constants

const CombinedIndexerShortName = "combined"

const IdxPrefixCall = "C" // call prefix for combined index

const IdxPrefixEmpty = "" //

const IdxPrefixLog = "L" // log prefix for combined index

Variables

var CombinedFilterMessageName = proto.MessageName(&pbtransform.CombinedFilter{})

var HeaderOnlyMessageName = proto.MessageName(&pbtransform.HeaderOnly{})

var HeaderOnlyTransformFactory = &transform.Factory{
	Obj: &pbtransform.HeaderOnly{},
	NewFunc: func(message *anypb.Any) (transform.Transform, error) {
		mname := message.MessageName()
		if mname != HeaderOnlyMessageName {
			return nil, fmt.Errorf("expected type url %q, recevied %q ", HeaderOnlyMessageName, message.TypeUrl)
		}

		filter := &pbtransform.HeaderOnly{}
		err := proto.Unmarshal(message.Value, filter)
		if err != nil {
			return nil, fmt.Errorf("unexpected unmarshall error: %w", err)
		}
		return &HeaderOnlyFilter{}, nil
	},
}

var LightBlockMessageName = proto.MessageName(&pbtransform.LightBlock{})

var LightBlockTransformFactory = &transform.Factory{
	Obj: &pbtransform.LightBlock{},
	NewFunc: func(message *anypb.Any) (transform.Transform, error) {
		mname := message.MessageName()
		if mname != LightBlockMessageName {
			return nil, fmt.Errorf("expected type url %q, recevied %q ", LightBlockMessageName, message.TypeUrl)
		}

		filter := &pbtransform.LightBlock{}
		err := proto.Unmarshal(message.Value, filter)
		if err != nil {
			return nil, fmt.Errorf("unexpected unmarshall error: %w", err)
		}
		return &LightBlockFilter{}, nil
	},
}

var MultiCallToFilterMessageName = proto.MessageName(&pbtransform.MultiCallToFilter{})

var MultiLogFilterMessageName = proto.MessageName(&pbtransform.MultiLogFilter{})

Functions

func CombinedFilterTransformFactory

func CombinedFilterTransformFactory(indexStore dstore.Store, possibleIndexSizes []uint64) *transform.Factory

func MultiCallToFilterTransformFactory

func MultiCallToFilterTransformFactory(indexStore dstore.Store, possibleIndexSizes []uint64) *transform.Factory

backwards compatibility, returns a combined filter now

func MultiLogFilterTransformFactory

func MultiLogFilterTransformFactory(indexStore dstore.Store, possibleIndexSizes []uint64) *transform.Factory

backwards compatibility, returns a combined filter now

Types

type AddressSignatureFilter

type AddressSignatureFilter interface {
	Addresses() []eth.Address
	Signatures() []eth.Hash
}

type CallToFilter

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

func NewCallToFilter

func NewCallToFilter(in *pbtransform.CallToFilter) (*CallToFilter, error)

func (*CallToFilter) Addresses

func (f *CallToFilter) Addresses() []eth.Address

func (*CallToFilter) Signatures

func (f *CallToFilter) Signatures() []eth.Hash

type CombinedFilter

type CombinedFilter struct {
	CallToFilters []*CallToFilter
	LogFilters    []*LogFilter
	// contains filtered or unexported fields
}

func (*CombinedFilter) GetIndexProvider

func (f *CombinedFilter) GetIndexProvider() bstream.BlockIndexProvider

GetIndexProvider will instantiate a new index conforming to the bstream.BlockIndexProvider interface

func (*CombinedFilter) String

func (f *CombinedFilter) String() string

func (*CombinedFilter) Transform

func (f *CombinedFilter) Transform(readOnlyBlk *bstream.Block, in transform.Input) (transform.Output, error)

type EthCombinedIndexer

type EthCombinedIndexer struct {
	BlockIndexer Indexer
}

func NewEthCombinedIndexer

func NewEthCombinedIndexer(indexStore dstore.Store, indexSize uint64) *EthCombinedIndexer

func (*EthCombinedIndexer) ProcessBlock

func (i *EthCombinedIndexer) ProcessBlock(blk *pbeth.Block)

ProcessBlock implements chain-specific logic for Ethereum bstream.Block's

type HeaderOnlyFilter

type HeaderOnlyFilter struct{}

func (*HeaderOnlyFilter) String

func (p *HeaderOnlyFilter) String() string

func (*HeaderOnlyFilter) Transform

func (p *HeaderOnlyFilter) Transform(readOnlyBlk *bstream.Block, in transform.Input) (transform.Output, error)

type Indexer

type Indexer interface {
	Add(keys []string, blockNum uint64)
}

type LightBlockFilter

type LightBlockFilter struct{}

func (*LightBlockFilter) String

func (p *LightBlockFilter) String() string

func (*LightBlockFilter) Transform

func (p *LightBlockFilter) Transform(readOnlyBlk *bstream.Block, in transform.Input) (transform.Output, error)

type LogFilter

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

func NewLogFilter

func NewLogFilter(in *pbtransform.LogFilter) (*LogFilter, error)

func (*LogFilter) Addresses

func (f *LogFilter) Addresses() []eth.Address

func (*LogFilter) Signatures

func (f *LogFilter) Signatures() []eth.Hash