indexer

package
v0.0.0-...-557c218 Latest Latest
Warning

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

 Go to latest Published: May 7, 2025 License: MIT Imports: 23 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	MinimumSizeSelector  = 1
	MinimumSizeFelt252   = 1
	MinimumSizeUint64    = 1
	MinimumSizeUint256   = 2
	MinimumSizeByteArray = 3
)
View Source 
const (
	AgentRegisteredEventKeysMinimumSize = 0 +
		MinimumSizeSelector +
		MinimumSizeFelt252 +
		MinimumSizeFelt252

	AgentRegisteredEventDataMinimumSize = 0 +
		MinimumSizeUint256 +
		MinimumSizeFelt252 +
		MinimumSizeUint64 +
		MinimumSizeFelt252 +
		MinimumSizeByteArray +
		MinimumSizeByteArray
)
View Source 
const (
	PromptConsumedEventKeysMinimumSize = 0 +
		MinimumSizeSelector +
		MinimumSizeUint64

	PromptConsumedEventDataMinimumSize = 0 +
		MinimumSizeUint256 +
		MinimumSizeUint256 +
		MinimumSizeUint256 +
		MinimumSizeFelt252
)
View Source 
const (
	DrainedEventKeysMinimumSize = 0 +
		MinimumSizeSelector +
		MinimumSizeUint64 +
		MinimumSizeFelt252 +
		MinimumSizeFelt252

	DrainedEventDataMinimumSize = 0 +
		MinimumSizeUint256
)
View Source 
const (
	WithdrawnEventKeysMinimumSize = 0 +
		MinimumSizeSelector +
		MinimumSizeFelt252

	WithdrawnEventDataMinimumSize = 0 +
		MinimumSizeUint256
)
View Source 
const (
	TokenAddedEventKeysMinimumSize = 0 +
		MinimumSizeSelector +
		MinimumSizeFelt252

	TokenAddedEventDataMinimumSize = 0 +
		MinimumSizeUint256 +
		MinimumSizeUint256
)
View Source 
const (
	PromptPaidEventKeysMinimumSize = 0 +
		MinimumSizeSelector +
		MinimumSizeFelt252 +
		MinimumSizeFelt252 +
		MinimumSizeFelt252
)
View Source 
const (
	TeeUnencumberedEventKeysMinimumSize = 0 +
		MinimumSizeSelector +
		MinimumSizeFelt252
)
View Source 
const (
	TokenRemovedEventKeysMinimumSize = 0 +
		MinimumSizeSelector +
		MinimumSizeFelt252
)

Variables

View Source 
var (
	EventItems = []struct {
		SelectorBytes [32]byte
		Type          EventType
	}{
		{agentRegisteredSelectorBytes, EventAgentRegistered},
		{promptPaidSelectorBytes, EventPromptPaid},
		{promptConsumedSelectorBytes, EventPromptConsumed},
		{drainedSelectorBytes, EventDrained},
		{withdrawnSelectorBytes, EventWithdrawn},
		{transferSelectorBytes, EventTransfer},
		{tokenAddedSelectorBytes, EventTokenAdded},
		{tokenRemovedSelectorBytes, EventTokenRemoved},
		{teeUnencumberedSelectorBytes, EventTeeUnencumbered},
	}

	EventSelectors = []*felt.Felt{
		agentRegisteredSelector,
		promptPaidSelector,
		promptConsumedSelector,
		drainedSelector,
		withdrawnSelector,
		transferSelector,
		tokenAddedSelector,
		tokenRemovedSelector,
		teeUnencumberedSelector,
	}
)

Functions

This section is empty.

Types

type AgentBalance 

type AgentBalance struct {
	Id              int
	Pending         bool
	Token           *felt.Felt
	PromptPrice     *big.Int
	Amount          *big.Int
	PendingAmount   *big.Int
	AmountUpdatedAt uint64
	EndTime         uint64
	IsDrained       bool
	DrainAmount     *big.Int
}

type AgentBalanceIndexer 

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

AgentBalanceIndexer responds to Transfer events for addresses known to be Agents, and updates their balances.

func NewAgentBalanceIndexer 

func NewAgentBalanceIndexer(config *AgentBalanceIndexerConfig) *AgentBalanceIndexer

NewAgentBalanceIndexer creates a new AgentBalanceIndexer.

func (*AgentBalanceIndexer) GetAgentLeaderboard 

func (i *AgentBalanceIndexer) GetAgentLeaderboard(start, end uint64, isActive *bool) (*AgentLeaderboardResponse, error)

GetAgentLeaderboard returns start:end agents from the agent balance leaderboard provided a callback to get a token's rate.

func (*AgentBalanceIndexer) GetAgentLeaderboardCount 

func (i *AgentBalanceIndexer) GetAgentLeaderboardCount() uint64

GetAgentLeaderboardCount returns the number of agents in the leaderboard.

func (*AgentBalanceIndexer) GetBalance 

func (i *AgentBalanceIndexer) GetBalance(agent *felt.Felt) (*AgentBalance, bool)

GetBalance returns the last known agent balance if present.

func (*AgentBalanceIndexer) GetLastIndexedBlock 

func (i *AgentBalanceIndexer) GetLastIndexedBlock() uint64

GetLastIndexedBlock returns the last indexed block.

func (*AgentBalanceIndexer) GetTotalAgentBalances 

func (i *AgentBalanceIndexer) GetTotalAgentBalances() map[*felt.Felt]*big.Int

func (*AgentBalanceIndexer) ReadState 

func (i *AgentBalanceIndexer) ReadState(f func(AgentBalanceIndexerDatabaseReader))

ReadState reads the current state of the indexer.

func (*AgentBalanceIndexer) Run 

func (i *AgentBalanceIndexer) Run(ctx context.Context) error

Run starts the main indexing loop in a goroutine. It returns after spawning so that you can manage it externally via context cancellation or wait-group.

type AgentBalanceIndexerConfig 

type AgentBalanceIndexerConfig struct {
	Client          starknet.ProviderWrapper
	AgentIdx        *AgentIndexer
	TickRate        time.Duration
	SafeBlockDelta  uint64
	RegistryAddress *felt.Felt
	PriceCache      AgentBalanceIndexerPriceCache
	InitialState    *AgentBalanceIndexerInitialState
	EventWatcher    *EventWatcher
}

AgentBalanceIndexerConfig is the configuration for an AgentBalanceIndexer.

type AgentBalanceIndexerDatabase 

type AgentBalanceIndexerDatabase interface {
	AgentBalanceIndexerDatabaseReader
	AgentBalanceIndexerDatabaseWriter
}

AgentBalanceIndexerDatabase is the database for an AgentBalanceIndexer.

type AgentBalanceIndexerDatabaseInMemory 

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

AgentBalanceIndexerDatabaseInMemory is an in-memory implementation of the AgentBalanceIndexerDatabase interface.

func NewAgentBalanceIndexerDatabaseInMemory 

func NewAgentBalanceIndexerDatabaseInMemory(initialBlock uint64) *AgentBalanceIndexerDatabaseInMemory

NewAgentBalanceIndexerDatabaseInMemory creates a new in-memory AgentBalanceIndexerDatabase.

func (*AgentBalanceIndexerDatabaseInMemory) GetAgentBalance 

func (db *AgentBalanceIndexerDatabaseInMemory) GetAgentBalance(addr [32]byte) (*AgentBalance, bool)

GetAgentBalance returns the agent balance, if it exists.

func (*AgentBalanceIndexerDatabaseInMemory) GetAgentCount 

func (db *AgentBalanceIndexerDatabaseInMemory) GetAgentCount() int

GetAgentCount returns the number of agents in the database.

func (*AgentBalanceIndexerDatabaseInMemory) GetAgentExists 

func (db *AgentBalanceIndexerDatabaseInMemory) GetAgentExists(addr [32]byte) bool

GetAgentExists returns true if the agent exists in the database.

func (*AgentBalanceIndexerDatabaseInMemory) GetLastIndexedBlock 

func (db *AgentBalanceIndexerDatabaseInMemory) GetLastIndexedBlock() uint64

GetLastIndexedBlock returns the last indexed block.

func (*AgentBalanceIndexerDatabaseInMemory) GetLeaderboard 

func (db *AgentBalanceIndexerDatabaseInMemory) GetLeaderboard(start, end uint64, isActive *bool, _ AgentBalanceIndexerPriceCache) (*AgentLeaderboardResponse, error)

GetLeaderboard returns the leaderboard for the given range.

func (*AgentBalanceIndexerDatabaseInMemory) GetLeaderboardCount 

func (db *AgentBalanceIndexerDatabaseInMemory) GetLeaderboardCount() uint64

GetLeaderboardCount returns the number of agents in the leaderboard.

func (*AgentBalanceIndexerDatabaseInMemory) GetTotalAgentBalances 

func (db *AgentBalanceIndexerDatabaseInMemory) GetTotalAgentBalances() map[[32]byte]*big.Int

GetTotalAgentBalances returns the total balances of all agents in the database per token.

func (*AgentBalanceIndexerDatabaseInMemory) SetAgentBalance 

func (db *AgentBalanceIndexerDatabaseInMemory) SetAgentBalance(addr [32]byte, balance *AgentBalance)

SetAgentBalance sets the agent balance.

func (*AgentBalanceIndexerDatabaseInMemory) SetLastIndexedBlock 

func (db *AgentBalanceIndexerDatabaseInMemory) SetLastIndexedBlock(block uint64)

SetLastIndexedBlock sets the last indexed block.

func (*AgentBalanceIndexerDatabaseInMemory) SortAgents 

func (db *AgentBalanceIndexerDatabaseInMemory) SortAgents(priceCache AgentBalanceIndexerPriceCache)

SortAgents sorts the agents by balance in descending order, using USD value

type AgentBalanceIndexerDatabaseReader 

type AgentBalanceIndexerDatabaseReader interface {
	GetLeaderboard(start, end uint64, isActive *bool, priceCache AgentBalanceIndexerPriceCache) (*AgentLeaderboardResponse, error)
	GetLeaderboardCount() uint64
	GetAgentExists(addr [32]byte) bool
	GetAgentBalance(addr [32]byte) (*AgentBalance, bool)
	GetTotalAgentBalances() map[[32]byte]*big.Int
	GetLastIndexedBlock() uint64
	GetAgentCount() int
}

AgentBalanceIndexerDatabaseReader is the reader for an AgentBalanceIndexerDatabase.

type AgentBalanceIndexerDatabaseWriter 

type AgentBalanceIndexerDatabaseWriter interface {
	SortAgents(priceCache AgentBalanceIndexerPriceCache)

	SetAgentBalance(addr [32]byte, balance *AgentBalance)
	SetLastIndexedBlock(block uint64)
}

AgentBalanceIndexerDatabaseWriter is the writer for an AgentBalanceIndexerDatabase.

type AgentBalanceIndexerInitialState 

type AgentBalanceIndexerInitialState struct {
	Db AgentBalanceIndexerDatabase
}

AgentBalanceIndexerInitialState is the initial state for an AgentBalanceIndexer.

type AgentBalanceIndexerPriceCache 

type AgentBalanceIndexerPriceCache interface {
	GetTokenRate(token *felt.Felt) (*big.Int, bool)
}

type AgentIndexer 

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

AgentIndexer processes AgentRegistered events and tracks known agents.

func NewAgentIndexer 

func NewAgentIndexer(cfg *AgentIndexerConfig) *AgentIndexer

NewAgentIndexer instantiates an AgentIndexer.

func (*AgentIndexer) GetAgentInfo 

func (i *AgentIndexer) GetAgentInfo(addr *felt.Felt) (AgentInfo, bool)

GetAgentInfo returns an agent's info, if it exists.

func (*AgentIndexer) GetAgentInfosByNamePrefix 

func (i *AgentIndexer) GetAgentInfosByNamePrefix(namePrefix string, offset uint64, limit uint64) (*AgentInfosByNamePrefixResult, bool)

GetAgentInfosByNamePrefix returns a list of agent infos by name prefix.

func (*AgentIndexer) GetAgentsByCreator 

func (i *AgentIndexer) GetAgentsByCreator(ctx context.Context, creator *felt.Felt, start uint64, limit uint64) (*AgentsByCreatorResult, bool)

GetAgentsByCreator returns a list of agent addresses created by the given creator address within the specified range. start and limit define the pagination window.

func (*AgentIndexer) GetLastIndexedBlock 

func (i *AgentIndexer) GetLastIndexedBlock() uint64

GetLastIndexedBlock returns the last indexed block.

func (*AgentIndexer) GetOrFetchAgentInfo 

func (i *AgentIndexer) GetOrFetchAgentInfo(ctx context.Context, addr *felt.Felt, block uint64) (AgentInfo, error)

GetOrFetchAgentInfoAtBlock returns an agent's info if it exists.

func (*AgentIndexer) ReadState 

func (i *AgentIndexer) ReadState(f func(AgentIndexerDatabaseReader))

ReadState reads the current state of the indexer.

func (*AgentIndexer) Run 

func (i *AgentIndexer) Run(ctx context.Context) error

Run starts the main indexing loop in a goroutine. It returns after spawning so that you can manage it externally via context cancellation or wait-group.

type AgentIndexerConfig 

type AgentIndexerConfig struct {
	RegistryAddress *felt.Felt
	Client          starknet.ProviderWrapper
	InitialState    *AgentIndexerInitialState
	EventWatcher    *EventWatcher
}

AgentIndexerConfig is the configuration for an AgentIndexer.

type AgentIndexerDatabase 

type AgentIndexerDatabase interface {
	AgentIndexerDatabaseReader
	AgentIndexerDatabaseWriter
}

AgentIndexerDatabase is the database for an AgentIndexer.

type AgentIndexerDatabaseInMemory 

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

AgentIndexerDatabaseInMemory is an in-memory implementation of the AgentIndexerDatabase interface.

func NewAgentIndexerDatabaseInMemory 

func NewAgentIndexerDatabaseInMemory(initialBlock uint64) *AgentIndexerDatabaseInMemory

NewAgentIndexerDatabaseInMemory creates a new in-memory AgentIndexerDatabase.

func (*AgentIndexerDatabaseInMemory) GetAddresses 

func (db *AgentIndexerDatabaseInMemory) GetAddresses() [][32]byte

GetAddresses returns all addresses.

func (*AgentIndexerDatabaseInMemory) GetAddressesByCreator 

func (db *AgentIndexerDatabaseInMemory) GetAddressesByCreator(creator [32]byte) [][32]byte

GetAddressesByCreator returns the addresses created by a given creator.

func (*AgentIndexerDatabaseInMemory) GetAgentInfo 

func (db *AgentIndexerDatabaseInMemory) GetAgentInfo(addr [32]byte) (AgentInfo, bool)

GetAgentInfo returns an agent's info, if it exists.

func (*AgentIndexerDatabaseInMemory) GetAgentInfosByName 

func (db *AgentIndexerDatabaseInMemory) GetAgentInfosByName(namePrefix string, offset uint64, limit uint64) ([]*AgentInfo, uint64, bool)

GetAgentInfosByName returns all agent infos with a given name prefix.

func (*AgentIndexerDatabaseInMemory) GetLastIndexedBlock 

func (db *AgentIndexerDatabaseInMemory) GetLastIndexedBlock() uint64

GetLastIndexedBlock returns the last indexed block.

func (*AgentIndexerDatabaseInMemory) SetAgentInfo 

func (db *AgentIndexerDatabaseInMemory) SetAgentInfo(addr [32]byte, info AgentInfo) error

SetAgentInfo sets an agent's info.

func (*AgentIndexerDatabaseInMemory) SetLastIndexedBlock 

func (db *AgentIndexerDatabaseInMemory) SetLastIndexedBlock(block uint64) error

SetLastIndexedBlock sets the last indexed block.

type AgentIndexerDatabaseReader 

type AgentIndexerDatabaseReader interface {
	GetAgentInfo(addr [32]byte) (AgentInfo, bool)
	GetAddressesByCreator(creator [32]byte) [][32]byte
	GetAddresses() [][32]byte
	GetLastIndexedBlock() uint64
	GetAgentInfosByName(name string, offset uint64, limit uint64) ([]*AgentInfo, uint64, bool)
}

AgentIndexerDatabaseReader is the database reader for an AgentIndexer.

type AgentIndexerDatabaseWriter 

type AgentIndexerDatabaseWriter interface {
	SetAgentInfo(addr [32]byte, info AgentInfo) error
	SetLastIndexedBlock(block uint64) error
}

AgentIndexerDatabaseWriter is the database writer for an AgentIndexer.

type AgentIndexerInitialState 

type AgentIndexerInitialState struct {
	Db AgentIndexerDatabase
}

AgentIndexerInitialState is the initial state for an AgentIndexer.

type AgentInfo 

type AgentInfo struct {
	Address      *felt.Felt
	Creator      *felt.Felt
	Name         string
	SystemPrompt string
	PromptPrice  *big.Int
	TokenAddress *felt.Felt
	EndTime      uint64
	Model        *felt.Felt
}

type AgentInfosByNamePrefixResult 

type AgentInfosByNamePrefixResult struct {
	AgentInfos []*AgentInfo
	Total      uint64
	LastBlock  uint64
}

type AgentLeaderboardResponse 

type AgentLeaderboardResponse struct {
	Agents     [][32]byte
	AgentCount uint64
	LastBlock  uint64
}

type AgentRegisteredEvent 

type AgentRegisteredEvent struct {
	Agent        *felt.Felt
	Creator      *felt.Felt
	PromptPrice  *big.Int
	TokenAddress *felt.Felt
	EndTime      uint64
	Model        *felt.Felt
	Name         string
	SystemPrompt string
}

type AgentUsage 

type AgentUsage struct {
	BreakAttempts uint64
	LatestPrompts []*AgentUsagePrompt
	DrainPrompt   *AgentUsagePrompt
	IsDrained     bool
	IsWithdrawn   bool
}

type AgentUsageIndexer 

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

func NewAgentUsageIndexer 

func NewAgentUsageIndexer(config *AgentUsageIndexerConfig) *AgentUsageIndexer

func (*AgentUsageIndexer) GetAgentUsage 

func (i *AgentUsageIndexer) GetAgentUsage(addr *felt.Felt) (*AgentUsage, bool)

func (*AgentUsageIndexer) GetLastIndexedBlock 

func (i *AgentUsageIndexer) GetLastIndexedBlock() uint64

func (*AgentUsageIndexer) GetTotalUsage 

func (i *AgentUsageIndexer) GetTotalUsage() *AgentUsageIndexerTotalUsage

func (*AgentUsageIndexer) ReadState 

func (i *AgentUsageIndexer) ReadState(f func(AgentUsageIndexerDatabaseReader))

func (*AgentUsageIndexer) Run 

func (i *AgentUsageIndexer) Run(ctx context.Context) error

type AgentUsageIndexerConfig 

type AgentUsageIndexerConfig struct {
	Client          starknet.ProviderWrapper
	RegistryAddress *felt.Felt
	MaxPrompts      uint64
	InitialState    *AgentUsageIndexerInitialState
	EventWatcher    *EventWatcher
}

type AgentUsageIndexerDatabase 

type AgentUsageIndexerDatabase interface {
	AgentUsageIndexerDatabaseReader
	AgentUsageIndexerDatabaseWriter
}

type AgentUsageIndexerDatabaseInMemory 

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

func NewAgentUsageIndexerDatabaseInMemory 

func NewAgentUsageIndexerDatabaseInMemory(initialBlock, maxPrompts uint64) *AgentUsageIndexerDatabaseInMemory

func (*AgentUsageIndexerDatabaseInMemory) GetAgentExists 

func (db *AgentUsageIndexerDatabaseInMemory) GetAgentExists(addr [32]byte) bool

func (*AgentUsageIndexerDatabaseInMemory) GetAgentUsage 

func (db *AgentUsageIndexerDatabaseInMemory) GetAgentUsage(addr [32]byte) (*AgentUsage, bool)

func (*AgentUsageIndexerDatabaseInMemory) GetLastIndexedBlock 

func (db *AgentUsageIndexerDatabaseInMemory) GetLastIndexedBlock() uint64

func (*AgentUsageIndexerDatabaseInMemory) GetTotalUsage 

func (db *AgentUsageIndexerDatabaseInMemory) GetTotalUsage() *AgentUsageIndexerTotalUsage

func (*AgentUsageIndexerDatabaseInMemory) SetLastIndexedBlock 

func (db *AgentUsageIndexerDatabaseInMemory) SetLastIndexedBlock(block uint64)

func (*AgentUsageIndexerDatabaseInMemory) StoreAgent 

func (db *AgentUsageIndexerDatabaseInMemory) StoreAgent(addr [32]byte)

func (*AgentUsageIndexerDatabaseInMemory) StorePromptConsumedData 

func (db *AgentUsageIndexerDatabaseInMemory) StorePromptConsumedData(addr [32]byte, promptConsumedEvent *PromptConsumedEvent)

func (*AgentUsageIndexerDatabaseInMemory) StorePromptPaidData 

func (db *AgentUsageIndexerDatabaseInMemory) StorePromptPaidData(addr [32]byte, promptPaidEvent *PromptPaidEvent)

func (*AgentUsageIndexerDatabaseInMemory) StoreWithdrawnData 

func (db *AgentUsageIndexerDatabaseInMemory) StoreWithdrawnData(addr [32]byte, withdrawnEvent *WithdrawnEvent)

type AgentUsageIndexerDatabaseInMemoryPromptCacheData 

type AgentUsageIndexerDatabaseInMemoryPromptCacheData struct {
	TweetID uint64
	Prompt  string
	User    *felt.Felt
}

type AgentUsageIndexerDatabaseInMemoryPromptCacheKey 

type AgentUsageIndexerDatabaseInMemoryPromptCacheKey [32]byte

type AgentUsageIndexerDatabaseReader 

type AgentUsageIndexerDatabaseReader interface {
	GetAgentUsage(addr [32]byte) (*AgentUsage, bool)
	GetAgentExists(addr [32]byte) bool
	GetLastIndexedBlock() uint64
	GetTotalUsage() *AgentUsageIndexerTotalUsage
}

type AgentUsageIndexerDatabaseWriter 

type AgentUsageIndexerDatabaseWriter interface {
	StoreAgent(addr [32]byte)
	StorePromptPaidData(addr [32]byte, ev *PromptPaidEvent)
	StorePromptConsumedData(addr [32]byte, ev *PromptConsumedEvent)
	StoreWithdrawnData(addr [32]byte, ev *WithdrawnEvent)
	SetLastIndexedBlock(block uint64)
}

type AgentUsageIndexerInitialState 

type AgentUsageIndexerInitialState struct {
	Db AgentUsageIndexerDatabase
}

type AgentUsageIndexerPendingUsage 

type AgentUsageIndexerPendingUsage struct {
	Usage *AgentUsage
	Block uint64
}

type AgentUsageIndexerTotalUsage 

type AgentUsageIndexerTotalUsage struct {
	TotalRegisteredAgents uint64
	TotalAttempts         uint64
	TotalSuccesses        uint64
}

type AgentUsagePrompt 

type AgentUsagePrompt struct {
	PromptID  uint64
	TweetID   uint64
	Prompt    string
	User      *felt.Felt
	IsSuccess bool
	DrainedTo *felt.Felt
}

type AgentsByCreatorResult 

type AgentsByCreatorResult struct {
	Agents     []AgentInfo
	AgentCount uint64
	LastBlock  uint64
}

AgentsByCreatorResult is the result of a GetAgentsByCreator call.

type DrainedEvent 

type DrainedEvent struct {
	PromptID uint64
	User     *felt.Felt
	To       *felt.Felt
	Amount   *big.Int
}

type Event 

type Event struct {
	Type EventType
	Raw  rpc.EmittedEvent
}

func (*Event) ToAgentRegisteredEvent 

func (e *Event) ToAgentRegisteredEvent() (*AgentRegisteredEvent, bool)

func (*Event) ToDrainedEvent 

func (e *Event) ToDrainedEvent() (*DrainedEvent, bool)

func (*Event) ToPromptConsumedEvent 

func (e *Event) ToPromptConsumedEvent() (*PromptConsumedEvent, bool)

func (*Event) ToPromptPaidEvent 

func (e *Event) ToPromptPaidEvent() (*PromptPaidEvent, bool)

func (*Event) ToTeeUnencumberedEvent 

func (e *Event) ToTeeUnencumberedEvent() (*TeeUnencumberedEvent, bool)

func (*Event) ToTokenAddedEvent 

func (e *Event) ToTokenAddedEvent() (*TokenAddedEvent, bool)

func (*Event) ToTokenRemovedEvent 

func (e *Event) ToTokenRemovedEvent() (*TokenRemovedEvent, bool)

func (*Event) ToTransferEvent 

func (e *Event) ToTransferEvent() (*TransferEvent, bool)

func (*Event) ToWithdrawnEvent 

func (e *Event) ToWithdrawnEvent() (*WithdrawnEvent, bool)

type EventSubscriber 

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

EventSubscriber is a write-only channel to receive parsed Events.

type EventSubscriberConfig 

type EventSubscriberConfig struct {
	Type EventType
}

EventSubscriberConfig holds the necessary settings for constructing an EventSubscriber.

type EventSubscriptionData 

type EventSubscriptionData struct {
	Events    []*Event
	FromBlock uint64
	ToBlock   uint64
}

type EventType 

type EventType int
const (
	EventAgentRegistered EventType = 1 << iota
	EventPromptPaid
	EventPromptConsumed
	EventDrained
	EventWithdrawn
	EventTransfer
	EventTokenAdded
	EventTokenRemoved
	EventTeeUnencumbered
)

type EventWatcher 

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

EventWatcher fetches events from Starknet in block ranges, parses them, and distributes them to subscribers (AgentRegistered, Transfer, PromptPaid, etc.).

func NewEventWatcher 

func NewEventWatcher(cfg *EventWatcherConfig) (*EventWatcher, error)

NewEventWatcher initializes a new EventWatcher.

func (*EventWatcher) ReadState 

func (w *EventWatcher) ReadState(f func(uint64))

ReadState reads the current state of the watcher.

func (*EventWatcher) Run 

func (w *EventWatcher) Run(ctx context.Context) error

Run starts the main indexing loop in a goroutine. It returns after spawning so that you can manage it externally via context cancellation or wait-group.

func (*EventWatcher) Subscribe 

func (w *EventWatcher) Subscribe(typ EventType, ch chan<- *EventSubscriptionData) int64

Subscribe registers a subscriber for events and returns a subscription ID that can be used to unsubscribe.

func (*EventWatcher) Unsubscribe 

func (w *EventWatcher) Unsubscribe(id int64) bool

Unsubscribe removes a subscriber by its subscription ID.

type EventWatcherConfig 

type EventWatcherConfig struct {
	Client          starknet.ProviderWrapper
	SafeBlockDelta  uint64
	TickRate        time.Duration
	StartupTickRate time.Duration
	IndexChunkSize  uint
	RegistryAddress *felt.Felt
	InitialState    *EventWatcherInitialState
}

EventWatcherConfig holds the necessary settings for constructing an EventWatcher.

type EventWatcherInitialState 

type EventWatcherInitialState struct {
	LastIndexedBlock uint64
}

EventWatcherInitialState holds the initial state of the EventWatcher.

type EventsListEntry 

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

EventsListEntry holds a list of events and the number of subscribers watching them.

type PromptConsumedEvent 

type PromptConsumedEvent struct {
	PromptID    uint64
	Amount      *big.Int
	CreatorFee  *big.Int
	ProtocolFee *big.Int
	DrainedTo   *felt.Felt
}

type PromptData 

type PromptData struct {
	Pending     bool
	PromptID    uint64
	AgentAddr   *felt.Felt
	IsDrain     bool
	Prompt      string
	Response    *string
	Error       *string
	BlockNumber uint64
	UserAddr    *felt.Felt
}

PromptData represents a prompt and its response

type PromptIndexer 

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

PromptIndexer processes prompts and stores them in a database

func NewPromptIndexer 

func NewPromptIndexer(cfg *PromptIndexerConfig) (*PromptIndexer, error)

NewPromptIndexer creates a new PromptIndexer

func (*PromptIndexer) GetLastIndexedBlock 

func (i *PromptIndexer) GetLastIndexedBlock() uint64

GetLastIndexedBlock returns the last indexed block

func (*PromptIndexer) GetPrompt 

func (i *PromptIndexer) GetPrompt(promptID uint64, agentAddr *felt.Felt) (*PromptData, bool)

GetPrompt returns a prompt by its ID and agent address

func (*PromptIndexer) GetPromptsByAgent 

func (i *PromptIndexer) GetPromptsByAgent(agentAddr *felt.Felt, from, to int) ([]*PromptData, error)

GetPromptsByAgent returns all prompts for a given agent

func (*PromptIndexer) GetPromptsByUser 

func (i *PromptIndexer) GetPromptsByUser(userAddr *felt.Felt, from, to int) ([]*PromptData, error)

GetPromptsByUser returns all prompts for a given user

func (*PromptIndexer) GetPromptsByUserAndAgent 

func (i *PromptIndexer) GetPromptsByUserAndAgent(userAddr *felt.Felt, agentAddr *felt.Felt, from, to int) ([]*PromptData, error)

GetPromptsByUserAndAgent returns all prompts for a given user and agent

func (*PromptIndexer) RegisterPromptResponse 

func (i *PromptIndexer) RegisterPromptResponse(data *PromptData, isUpsert bool) error

RegisterPromptResponse registers a prompt response manually

func (*PromptIndexer) Run 

func (i *PromptIndexer) Run(ctx context.Context) error

Run starts the main indexing loop

type PromptIndexerConfig 

type PromptIndexerConfig struct {
	Client          starknet.ProviderWrapper
	RegistryAddress *felt.Felt
	EventWatcher    *EventWatcher
	InitialState    *PromptIndexerInitialState
}

PromptIndexerConfig is the configuration for a PromptIndexer

type PromptIndexerDatabase 

type PromptIndexerDatabase interface {
	PromptIndexerDatabaseReader
	PromptIndexerDatabaseWriter
}

PromptIndexerDatabase is the database for a PromptIndexer

type PromptIndexerDatabaseReader 

type PromptIndexerDatabaseReader interface {
	GetPrompt(promptID uint64, agentAddr *felt.Felt) (*PromptData, bool)
	GetPromptsByAgent(agentAddr *felt.Felt, from, to int) ([]*PromptData, error)
	GetPromptsByUser(userAddr *felt.Felt, from, to int) ([]*PromptData, error)
	GetPromptsByUserAndAgent(userAddr *felt.Felt, agentAddr *felt.Felt, from, to int) ([]*PromptData, error)
	GetLastIndexedBlock() uint64
	GetAgentExists(addr [32]byte) bool
}

PromptIndexerDatabaseReader is the database reader for a PromptIndexer

type PromptIndexerDatabaseSQLite 

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

PromptIndexerDatabaseSQLite is a SQLite implementation of the PromptIndexerDatabase interface

func NewPromptIndexerDatabaseSQLite 

func NewPromptIndexerDatabaseSQLite(dbPath string) (*PromptIndexerDatabaseSQLite, error)

NewPromptIndexerDatabaseSQLite creates a new SQLite-based PromptIndexerDatabase

func (*PromptIndexerDatabaseSQLite) GetAgentExists 

func (db *PromptIndexerDatabaseSQLite) GetAgentExists(addr [32]byte) bool

func (*PromptIndexerDatabaseSQLite) GetLastIndexedBlock 

func (db *PromptIndexerDatabaseSQLite) GetLastIndexedBlock() uint64

GetLastIndexedBlock returns the last indexed block

func (*PromptIndexerDatabaseSQLite) GetPrompt 

func (db *PromptIndexerDatabaseSQLite) GetPrompt(promptID uint64, agentAddr *felt.Felt) (*PromptData, bool)

GetPrompt returns a prompt by its ID and agent address

func (*PromptIndexerDatabaseSQLite) GetPromptsByAgent 

func (db *PromptIndexerDatabaseSQLite) GetPromptsByAgent(agentAddr *felt.Felt, from, to int) ([]*PromptData, error)

GetPromptsByAgent returns all prompts for a given agent

func (*PromptIndexerDatabaseSQLite) GetPromptsByUser 

func (db *PromptIndexerDatabaseSQLite) GetPromptsByUser(userAddr *felt.Felt, from, to int) ([]*PromptData, error)

GetPromptsByUser returns all prompts for a given user

func (*PromptIndexerDatabaseSQLite) GetPromptsByUserAndAgent 

func (db *PromptIndexerDatabaseSQLite) GetPromptsByUserAndAgent(userAddr *felt.Felt, agentAddr *felt.Felt, from, to int) ([]*PromptData, error)

GetPromptsByUserAndAgent returns all prompts for a given user and agent

func (*PromptIndexerDatabaseSQLite) SetAgentExists 

func (db *PromptIndexerDatabaseSQLite) SetAgentExists(addr [32]byte, exists bool) error

func (*PromptIndexerDatabaseSQLite) SetLastIndexedBlock 

func (db *PromptIndexerDatabaseSQLite) SetLastIndexedBlock(block uint64) error

SetLastIndexedBlock sets the last indexed block

func (*PromptIndexerDatabaseSQLite) SetPrompt 

func (db *PromptIndexerDatabaseSQLite) SetPrompt(data *PromptData) error

SetPrompt stores a prompt in the database

type PromptIndexerDatabaseWriter 

type PromptIndexerDatabaseWriter interface {
	SetPrompt(data *PromptData) error
	SetLastIndexedBlock(block uint64) error
	SetAgentExists(addr [32]byte, exists bool) error
}

PromptIndexerDatabaseWriter is the database writer for a PromptIndexer

type PromptIndexerInitialState 

type PromptIndexerInitialState struct {
	Db PromptIndexerDatabase
}

PromptIndexerInitialState is the initial state for a PromptIndexer

type PromptPaidEvent 

type PromptPaidEvent struct {
	User     *felt.Felt
	PromptID uint64
	TweetID  uint64
	Prompt   string
}

type TeeUnencumberedEvent 

type TeeUnencumberedEvent struct {
	Tee *felt.Felt
}

type TokenAddedEvent 

type TokenAddedEvent struct {
	Token             *felt.Felt
	MinPromptPrice    *big.Int
	MinInitialBalance *big.Int
}

type TokenIndexer 

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

TokenIndexer processes token events and tracks token prices.

func NewTokenIndexer 

func NewTokenIndexer(cfg *TokenIndexerConfig) *TokenIndexer

NewTokenIndexer instantiates a TokenIndexer.

func (*TokenIndexer) GetLastIndexedBlock 

func (i *TokenIndexer) GetLastIndexedBlock() uint64

GetLastIndexedBlock returns the last indexed block.

func (*TokenIndexer) GetTokenMinInitialBalance 

func (i *TokenIndexer) GetTokenMinInitialBalance(token *felt.Felt) (*big.Int, bool)

GetTokenMinInitialBalance returns a token's minimum initial balance, if it exists.

func (*TokenIndexer) GetTokenMinPromptPrice 

func (i *TokenIndexer) GetTokenMinPromptPrice(token *felt.Felt) (*big.Int, bool)

GetTokenMinPromptPrice returns a token's minimum prompt price, if it exists.

func (*TokenIndexer) GetTokenRate 

func (i *TokenIndexer) GetTokenRate(token *felt.Felt) (*big.Int, bool)

GetTokenRate returns a token's rate, if it exists.

func (*TokenIndexer) ReadState 

func (i *TokenIndexer) ReadState(f func(TokenIndexerDatabaseReader))

ReadState reads the current state of the indexer.

func (*TokenIndexer) Run 

func (i *TokenIndexer) Run(ctx context.Context) error

Run starts the main indexing loop in a goroutine. It returns after spawning so that you can manage it externally via context cancellation or wait-group.

type TokenIndexerConfig 

type TokenIndexerConfig struct {
	PriceFeed       price.PriceFeed
	PriceTickRate   time.Duration
	RegistryAddress *felt.Felt
	InitialState    *TokenIndexerInitialState
	EventWatcher    *EventWatcher
}

TokenIndexerConfig is the configuration for a TokenIndexer.

type TokenIndexerDatabase 

type TokenIndexerDatabase interface {
	TokenIndexerDatabaseReader
	TokenIndexerDatabaseWriter
}

TokenIndexerDatabase is the database for a TokenIndexer.

type TokenIndexerDatabaseInMemory 

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

TokenIndexerDatabaseInMemory is an in-memory implementation of the TokenIndexerDatabase interface.

func NewTokenIndexerDatabaseInMemory 

func NewTokenIndexerDatabaseInMemory(initialBlock uint64) *TokenIndexerDatabaseInMemory

NewTokenIndexerDatabaseInMemory creates a new in-memory TokenIndexerDatabase.

func (*TokenIndexerDatabaseInMemory) GetLastIndexedBlock 

func (db *TokenIndexerDatabaseInMemory) GetLastIndexedBlock() uint64

GetLastIndexedBlock returns the last indexed block.

func (*TokenIndexerDatabaseInMemory) GetTokenInfo 

func (db *TokenIndexerDatabaseInMemory) GetTokenInfo(token [32]byte) (*TokenInfo, bool)

GetTokenInfo returns the TokenInfo for a given token address.

func (*TokenIndexerDatabaseInMemory) GetTokens 

func (db *TokenIndexerDatabaseInMemory) GetTokens() map[[32]byte]*TokenInfo

GetTokens returns all the tokens in the database.

func (*TokenIndexerDatabaseInMemory) SetLastIndexedBlock 

func (db *TokenIndexerDatabaseInMemory) SetLastIndexedBlock(block uint64) error

SetLastIndexedBlock sets the last indexed block.

func (*TokenIndexerDatabaseInMemory) SetTokenInfo 

func (db *TokenIndexerDatabaseInMemory) SetTokenInfo(token [32]byte, info *TokenInfo) error

SetTokenInfo sets the TokenInfo for a given token address.

type TokenIndexerDatabaseReader 

type TokenIndexerDatabaseReader interface {
	GetTokenInfo(token [32]byte) (*TokenInfo, bool)
	GetLastIndexedBlock() uint64
	GetTokens() map[[32]byte]*TokenInfo
}

TokenIndexerDatabaseReader is the database reader for a TokenIndexer.

type TokenIndexerDatabaseWriter 

type TokenIndexerDatabaseWriter interface {
	SetTokenInfo(token [32]byte, info *TokenInfo) error
	SetLastIndexedBlock(block uint64) error
}

TokenIndexerDatabaseWriter is the database writer for a TokenIndexer.

type TokenIndexerInitialState 

type TokenIndexerInitialState struct {
	Db TokenIndexerDatabase
}

TokenIndexerInitialState is the initial state for a TokenIndexer.

type TokenInfo 

type TokenInfo struct {
	MinPromptPrice    *big.Int
	MinInitialBalance *big.Int

	Rate     *big.Int
	RateTime time.Time
}

TokenPriceUpdate is a struct that contains the token price and its update block

type TokenRemovedEvent 

type TokenRemovedEvent struct {
	Token *felt.Felt
}

type TransferEvent 

type TransferEvent struct {
	From   *felt.Felt
	To     *felt.Felt
	Amount *big.Int
}

type UserIndexer 

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

func NewUserIndexer 

func NewUserIndexer(config *UserIndexerConfig) *UserIndexer

func (*UserIndexer) GetLastIndexedBlock 

func (i *UserIndexer) GetLastIndexedBlock() uint64

func (*UserIndexer) GetUserInfo 

func (i *UserIndexer) GetUserInfo(addr *felt.Felt) (*UserInfo, bool)

func (*UserIndexer) GetUserLeaderboard 

func (i *UserIndexer) GetUserLeaderboard(start, end uint64) (*UserLeaderboardResponse, error)

GetUserLeaderboard returns start:end users from the user leaderboard. Users are sorted by total accrued balances (desc), break count (desc) and prompt count (desc).

func (*UserIndexer) GetUserLeaderboardCount 

func (i *UserIndexer) GetUserLeaderboardCount() uint64

GetUserLeaderboardCount returns the number of users in the leaderboard.

func (*UserIndexer) ReadState 

func (i *UserIndexer) ReadState(f func(UserIndexerDatabaseReader))

func (*UserIndexer) Run 

func (i *UserIndexer) Run(ctx context.Context) error

type UserIndexerConfig 

type UserIndexerConfig struct {
	Client          starknet.ProviderWrapper
	RegistryAddress *felt.Felt
	InitialState    *UserIndexerInitialState
	EventWatcher    *EventWatcher
	TickRate        time.Duration
	PriceCache      AgentBalanceIndexerPriceCache
}

type UserIndexerDatabase 

type UserIndexerDatabase interface {
	UserIndexerDatabaseReader
	UserIndexerDatabaseWriter
}

type UserIndexerDatabaseInMemory 

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

func NewUserIndexerDatabaseInMemory 

func NewUserIndexerDatabaseInMemory(initialBlock uint64) *UserIndexerDatabaseInMemory

func (*UserIndexerDatabaseInMemory) GetAgentExists 

func (db *UserIndexerDatabaseInMemory) GetAgentExists(addr [32]byte) bool

func (*UserIndexerDatabaseInMemory) GetLastIndexedBlock 

func (db *UserIndexerDatabaseInMemory) GetLastIndexedBlock() uint64

func (*UserIndexerDatabaseInMemory) GetLeaderboard 

func (db *UserIndexerDatabaseInMemory) GetLeaderboard(start, end uint64, priceCache AgentBalanceIndexerPriceCache) (*UserLeaderboardResponse, error)

func (*UserIndexerDatabaseInMemory) GetLeaderboardCount 

func (db *UserIndexerDatabaseInMemory) GetLeaderboardCount() uint64

func (*UserIndexerDatabaseInMemory) GetUserExists 

func (db *UserIndexerDatabaseInMemory) GetUserExists(addr [32]byte) bool

func (*UserIndexerDatabaseInMemory) GetUserInfo 

func (db *UserIndexerDatabaseInMemory) GetUserInfo(addr [32]byte) (*UserInfo, bool)

func (*UserIndexerDatabaseInMemory) SetLastIndexedBlock 

func (db *UserIndexerDatabaseInMemory) SetLastIndexedBlock(block uint64)

func (*UserIndexerDatabaseInMemory) SortUsers 

func (db *UserIndexerDatabaseInMemory) SortUsers(priceCache AgentBalanceIndexerPriceCache)

func (*UserIndexerDatabaseInMemory) StoreAgentRegisteredData 

func (db *UserIndexerDatabaseInMemory) StoreAgentRegisteredData(agentRegisteredEvent *AgentRegisteredEvent)

func (*UserIndexerDatabaseInMemory) StoreDrainedData 

func (db *UserIndexerDatabaseInMemory) StoreDrainedData(agentAddr *felt.Felt, drainedEvent *DrainedEvent)

func (*UserIndexerDatabaseInMemory) StorePromptPaidData 

func (db *UserIndexerDatabaseInMemory) StorePromptPaidData(agentAddr *felt.Felt, promptPaidEvent *PromptPaidEvent)

type UserIndexerDatabaseReader 

type UserIndexerDatabaseReader interface {
	GetUserInfo(addr [32]byte) (*UserInfo, bool)
	GetUserExists(addr [32]byte) bool
	GetAgentExists(addr [32]byte) bool
	GetLastIndexedBlock() uint64
	GetLeaderboard(start, end uint64, priceCache AgentBalanceIndexerPriceCache) (*UserLeaderboardResponse, error)
	GetLeaderboardCount() uint64
}

type UserIndexerDatabaseWriter 

type UserIndexerDatabaseWriter interface {
	StoreAgentRegisteredData(agentRegisteredEvent *AgentRegisteredEvent)
	StoreDrainedData(agentAddr *felt.Felt, drainedEvent *DrainedEvent)
	StorePromptPaidData(agentAddr *felt.Felt, promptPaidEvent *PromptPaidEvent)
	SetLastIndexedBlock(block uint64)
	SortUsers(priceCache AgentBalanceIndexerPriceCache)
}

type UserIndexerInitialState 

type UserIndexerInitialState struct {
	Db UserIndexerDatabase
}

type UserInfo 

type UserInfo struct {
	Address         [32]byte
	AccruedBalances map[[32]byte]*big.Int
	PromptCount     uint64
	BreakCount      uint64
}

type UserLeaderboardResponse 

type UserLeaderboardResponse struct {
	Users     [][32]byte
	UserCount uint64
	LastBlock uint64
}

type UserPromptCacheData 

type UserPromptCacheData struct {
	User [32]byte
}

type UserPromptCacheKey 

type UserPromptCacheKey [32]byte

type WithdrawnEvent 

type WithdrawnEvent struct {
	To     *felt.Felt
	Amount *big.Int
}

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.