watchEvent

Name: viem-go
Author: viem-go

Watches and returns emitted event logs

Watch actions return a channel of events. Cancel the context to stop watching.

Import

Import the public actions package so you can call this action.

import "github.com/ChefBingbong/viem-go/actions/public"

Usage

An example showing how to watch for events and handle each batch of logs from the channel.

import (
  "context"
  "fmt"
  "log"

  "github.com/ethereum/go-ethereum/common"
  "github.com/ChefBingbong/viem-go/actions/public"
  "github.com/ChefBingbong/viem-go/abi"
  "github.com/ChefBingbong/viem-go/client"
  "github.com/ChefBingbong/viem-go/client/transport"
  "github.com/ChefBingbong/viem-go/chain/definitions"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

publicClient, err := client.CreatePublicClient(client.PublicClientConfig{
  Chain:     definitions.Mainnet,
  Transport: transport.HTTP("https://eth.llamarpc.com"),
})
if err != nil {
  log.Fatal(err)
}
defer func() { _ = publicClient.Close() }()

contractAddr := common.HexToAddress("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")
transferEvent, _ := abi.ParseEvent("Transfer(address indexed, address indexed, uint256)")

events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address: contractAddr,
  Event:   transferEvent,
  Batch:   true,
})

for event := range events {
  if event.Error != nil {
      log.Printf("error: %v", event.Error)
      continue
  }
  fmt.Printf("Received %d logs
", len(event.Logs))
}

Returns

<-chan WatchEventEvent

A channel that emits WatchEventEvent structs containing:

Logs []formatters.Log - The event logs (may contain multiple when Batch is true)
Error error - Any error that occurred

Parameters

Configuration options accepted by this action.

Address

Type: any (accepts common.Address, *common.Address, []common.Address, string, or []string)
Optional

The contract address(es) to filter logs from.

import (
  "github.com/ethereum/go-ethereum/common"
  "github.com/ChefBingbong/viem-go/actions/public"
)

contractAddr := common.HexToAddress("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")
events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address: contractAddr,
  Event:   transferEvent,
})

Event

Type: *abi.Event
Optional

A single event definition to filter for. Mutually exclusive with Events.

import "github.com/ChefBingbong/viem-go/abi"

transferEvent, _ := abi.ParseEvent("Transfer(address indexed, address indexed, uint256)")
events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address: contractAddr,
  Event:   transferEvent,
})

Events

Type: []*abi.Event
Optional

A list of event definitions to filter for. Mutually exclusive with Event.

transferEvent, _ := abi.ParseEvent("Transfer(...)")
approvalEvent, _ := abi.ParseEvent("Approval(...)")
events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address: contractAddr,
  Events:  []*abi.Event{transferEvent, approvalEvent},
})

Args

Type: map[string]any
Optional

Indexed event arguments to filter by. Keys are parameter names, values are the expected values.

senderAddr := common.HexToAddress("0xd8da6bf26964af9d7eed9e03e53415d37aa96045")
events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address: contractAddr,
  Event:   transferEvent,
  Args:    map[string]any{"from": senderAddr},
})

Batch

Type: bool
Default: true
Optional

Whether to batch logs together. When true, multiple logs are collected and emitted together. When false, each log is emitted as a separate event.

events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address: contractAddr,
  Event:   transferEvent,
  Batch:   false,
})

FromBlock

Type: *uint64
Optional

The block number to start watching from. If set, forces polling mode.

fromBlock := uint64(16330000)
events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address:   contractAddr,
  Event:     transferEvent,
  FromBlock: &fromBlock,
})

Poll

Type: *bool
Default: false for WebSocket Transports, true for non-WebSocket Transports
Optional

Whether or not to use a polling mechanism instead of a WebSocket subscription.

poll := true
events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address: contractAddr,
  Event:   transferEvent,
  Poll:    &poll,
})

PollingInterval

Type: time.Duration
Default: Client's PollingInterval
Optional

The interval between polls when using polling mode.

import "time"

events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address:        contractAddr,
  Event:          transferEvent,
  PollingInterval: 5 * time.Second,
})

Strict

Type: bool
Default: false
Optional

Determines whether logs must match the event definition exactly. When true, logs with mismatched indexed/non-indexed arguments are skipped.

events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address: contractAddr,
  Event:   transferEvent,
  Strict:  true,
})

WorkerPoolSize

Type: int
Default: 4
Optional

The number of workers for parallel log processing. Only used when decoding event logs.

events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{
  Address:       contractAddr,
  Event:         transferEvent,
  WorkerPoolSize: 8,
})

JSON-RPC Method

Underlying JSON-RPC methods used by this action.

When polling with filter support:
- Calls eth_newFilter to create a filter
- Calls eth_getFilterChanges on a polling interval
When polling without filter support: calls eth_getLogs for each block range
When subscribing: uses eth_subscribe with "logs" event

import ( "context" "fmt" "log" "github.com/ethereum/go-ethereum/common" "github.com/ChefBingbong/viem-go/actions/public" "github.com/ChefBingbong/viem-go/abi" "github.com/ChefBingbong/viem-go/client" "github.com/ChefBingbong/viem-go/client/transport" "github.com/ChefBingbong/viem-go/chain/definitions" ) ctx, cancel := context.WithCancel(context.Background()) defer cancel() publicClient, err := client.CreatePublicClient(client.PublicClientConfig{ Chain: definitions.Mainnet, Transport: transport.HTTP("https://eth.llamarpc.com"), }) if err != nil { log.Fatal(err) } defer func() { _ = publicClient.Close() }() contractAddr := common.HexToAddress("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48") transferEvent, _ := abi.ParseEvent("Transfer(address indexed, address indexed, uint256)") events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{ Address: contractAddr, Event: transferEvent, Batch: true, }) for event := range events { if event.Error != nil { log.Printf("error: %v", event.Error) continue } fmt.Printf("Received %d logs ", len(event.Logs)) }

import ( "github.com/ethereum/go-ethereum/common" "github.com/ChefBingbong/viem-go/actions/public" ) contractAddr := common.HexToAddress("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48") events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{ Address: contractAddr, Event: transferEvent, })

import "github.com/ChefBingbong/viem-go/abi" transferEvent, _ := abi.ParseEvent("Transfer(address indexed, address indexed, uint256)") events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{ Address: contractAddr, Event: transferEvent, })

transferEvent, _ := abi.ParseEvent("Transfer(...)") approvalEvent, _ := abi.ParseEvent("Approval(...)") events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{ Address: contractAddr, Events: []*abi.Event{transferEvent, approvalEvent}, })

senderAddr := common.HexToAddress("0xd8da6bf26964af9d7eed9e03e53415d37aa96045") events := public.WatchEvent(ctx, publicClient, public.WatchEventParameters{ Address: contractAddr, Event: transferEvent, Args: map[string]any{"from": senderAddr}, })