Events

func (provider *Provider) Events(ctx context.Context, input EventsInput) (*EventChunk, error)

type EventsInput struct {
	EventFilter
	ResultPageRequest
}

type EventFilter struct {
	// FromBlock from block
	FromBlock BlockID `json:"from_block,omitempty"`
	// ToBlock to block
	ToBlock BlockID `json:"to_block,omitempty"`
	// Address from contract
	Address *felt.Felt `json:"address,omitempty"`
	// Keys the values used to filter the events
	Keys [][]*felt.Felt `json:"keys,omitempty"`
}

type ResultPageRequest struct {
	// a pointer to the last element of the delivered page, use this token in a
	// subsequent query to obtain the next page
	ContinuationToken string `json:"continuation_token,omitempty"`
	ChunkSize         int    `json:"chunk_size"`
}

type EventChunk struct {
	Events            []EmittedEvent `json:"events"`
	ContinuationToken string         `json:"continuation_token,omitempty"`
}

type EmittedEvent struct {
	Event
	// BlockHash the hash of the block in which the event was emitted
	BlockHash *felt.Felt `json:"block_hash,omitempty"`
	// BlockNumber the number of the block in which the event was emitted
	BlockNumber uint64 `json:"block_number,omitempty"`
	// TransactionHash the transaction that emitted the event
	TransactionHash *felt.Felt `json:"transaction_hash"`
}

type Event struct {
	FromAddress *felt.Felt `json:"from_address"`
	EventContent
}

type EventContent struct {
	Keys []*felt.Felt `json:"keys"`
	Data []*felt.Felt `json:"data"`
}

type BlockID struct {
	Number *uint64    `json:"block_number,omitempty"`
	Hash   *felt.Felt `json:"block_hash,omitempty"`
	Tag    BlockTag   `json:"tag,omitempty"`
}

package main
 
import (
	"context"
	"fmt"
	"log"
	"os"
 
	"github.com/NethermindEth/starknet.go/rpc"
	"github.com/joho/godotenv"
)
 
func main() {
	// Load environment variables from .env file
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}
 
	// Get RPC URL from environment variable
	rpcURL := os.Getenv("STARKNET_RPC_URL")
	if rpcURL == "" {
		log.Fatal("STARKNET_RPC_URL not found in .env file")
	}
 
	// Initialize provider
	provider, err := rpc.NewProvider(context.Background(), rpcURL)
	if err != nil {
		log.Fatal(err)
	}
 
	ctx := context.Background()
 
	// Query events from a specific block range
	eventsInput := rpc.EventsInput{
		EventFilter: rpc.EventFilter{
			FromBlock: rpc.WithBlockNumber(1676500),
			ToBlock:   rpc.WithBlockNumber(1676510),
		},
		ResultPageRequest: rpc.ResultPageRequest{
			ChunkSize: 10,
		},
	}
 
	// Get first page of events
	eventChunk, err := provider.Events(ctx, eventsInput)
	if err != nil {
		log.Fatal(err)
	}
 
	fmt.Printf("Found %d events\n", len(eventChunk.Events))
 
	// Display event details
	for i, event := range eventChunk.Events {
		fmt.Printf("\nEvent %d:\n", i+1)
		fmt.Printf("  From Contract: %s\n", event.FromAddress)
		fmt.Printf("  Block Number: %d\n", event.BlockNumber)
		fmt.Printf("  Transaction Hash: %s\n", event.TransactionHash)
		fmt.Printf("  Number of Keys: %d\n", len(event.Keys))
		fmt.Printf("  Number of Data Fields: %d\n", len(event.Data))
	}
 
	// Fetch next page if available
	if eventChunk.ContinuationToken != "" {
		fmt.Printf("\nMore events available. Continuation token: %s\n", eventChunk.ContinuationToken)
 
		// Use continuation token for next page
		eventsInput.ContinuationToken = eventChunk.ContinuationToken
		nextPage, err := provider.Events(ctx, eventsInput)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("Next page has %d events\n", len(nextPage.Events))
	}
}

eventChunk, err := provider.Events(ctx, eventsInput)
if err != nil {
	if errors.Is(err, rpc.ErrPageSizeTooBig) {
		log.Printf("Chunk size too large, reduce ChunkSize")
		return
	}
	if errors.Is(err, rpc.ErrInvalidContinuationToken) {
		log.Printf("Invalid continuation token")
		return
	}
	if errors.Is(err, rpc.ErrBlockNotFound) {
		log.Printf("Block not found")
		return
	}
	if errors.Is(err, rpc.ErrTooManyKeysInFilter) {
		log.Printf("Too many keys in filter, reduce filter complexity")
		return
	}
	log.Printf("Error retrieving events: %v", err)
	return
}
 
fmt.Printf("Retrieved %d events\n", len(eventChunk.Events))