Event Payloads

The Events API returns a discriminated union: every record carries a type from the EventType enum, a created_at timestamp, and one of five Event_Payload shapes. This page lists each payload with its exact JSON schema and Go struct (from the generated OpenAPI types).

Discriminator: EventType

operation.status   // OperationStatusPayload
query.status       // QueryStatusPayload
watcher.status     // WatcherStatusPayload
watcher.event      // WatcherEventPayload  ← cryptographically verifiable
wallet.status      // WalletStatusPayload

The Go SDK exposes typed accessors on Event_Payload:

// returns (OperationStatusPayload, error)
ev.Payload.AsOperationStatusPayload()
ev.Payload.AsQueryStatusPayload()
ev.Payload.AsWatcherStatusPayload()
ev.Payload.AsWatcherEventPayload()
ev.Payload.AsWalletStatusPayload()

WatcherEventPayload (watcher.event)

The cryptographically verifiable on-chain event payload. Every other payload type is an operational notification produced by the CRE Connect backend.

type WatcherEventPayload struct {
    ChainSelector   string  `json:"chain_selector"`
    EventHash       string  `json:"event_hash"`
    Timestamp       int64   `json:"timestamp"`
    VerifiableEvent string  `json:"verifiable_event"` // base64
    WatcherId       string  `json:"watcher_id"`
}

VerifiableEvent itself is a models.VerifiableEvent carrying the raw EVM log, the Off-Chain Reporting (OCR) signatures, and the workflow context required for verification; see Event Verification.

OperationStatusPayload (operation.status)

Emitted on every operation transition.

type OperationStatusPayload struct {
    Address           string             `json:"address"`
    ChainSelector     string             `json:"chain_selector"`
    EventHash         *string            `json:"event_hash,omitempty"`
    OperationId       openapi_types.UUID `json:"operation_id"`
    Status            OperationStatus    `json:"status"`
    StatusReason      string             `json:"status_reason"`
    Timestamp         int64              `json:"timestamp"`
    VerifiableEvent   *string            `json:"verifiable_event,omitempty"`
    WalletOperationId string             `json:"wallet_operation_id"`
}

operation.status events at confirmed_latest, confirmed_safe, and confirmed are DON-verified and carry OCR proofs. Each confirmation status has a different chain-finality guarantee; see Multi-Event Finality. pending_signature, cancelled, expired, and non-terminal transitions (accepted, sending, sent, broadcasting) are operational notifications without OCR proofs. See Draft Operations.

QueryStatusPayload (query.status)

Emitted on every chain query transition.

type QueryStatusPayload struct {
    QueryId             openapi_types.UUID `json:"query_id"`
    Status              QueryStatus        `json:"status"`
    Target              string             `json:"target"`
    ChainSelector       string             `json:"chain_selector"`
    Timestamp           int64              `json:"timestamp"`
    EventHash           *string            `json:"event_hash,omitempty"`
    VerifiableResult    *string            `json:"verifiable_result,omitempty"`
    WorkflowId          *string            `json:"workflow_id,omitempty"`
    WorkflowExecutionId *string            `json:"workflow_execution_id,omitempty"`
}

Terminal query.status events (completed, failed) carry OCR proofs and can be verified with events.Client.VerifyQueryStatus. Non-terminal events (accepted, sending, sent) and expired events are operational notifications without OCR proofs. See Chain Queries.

WatcherStatusPayload (watcher.status)

Emitted on every watcher provisioning / archival transition.

type WatcherStatusPayload struct {
    ChainSelector string             `json:"chain_selector"`
    Service       *string            `json:"service,omitempty"`
    Status        WatcherEventStatus `json:"status"`
    StatusReason  string             `json:"status_reason"`
    Timestamp     int64              `json:"timestamp"`
    WatcherId     string             `json:"watcher_id"`
}

WatcherEventStatus extends WatcherStatus with archival states for filtering:

pending | active | failed | archiving | archive_failed | archived

WalletStatusPayload (wallet.status)

Emitted on every wallet (Smart Account) deploy / archival transition.

type WalletStatusPayload struct {
    Address       string             `json:"address"`
    ChainSelector string             `json:"chain_selector"`
    Status        WalletEventStatus  `json:"status"`
    StatusReason  string             `json:"status_reason"`
    Timestamp     int64              `json:"timestamp"`
    WalletId      openapi_types.UUID `json:"wallet_id"`
}

WalletEventStatus:

pending | deploying | deployed | failed | archived

Common envelope

Every Event returned by /channels/{id}/events and /channels/{id}/events/search carries:

type Event struct {
    ChannelId openapi_types.UUID `json:"channel_id"`
    CreatedAt int64              `json:"created_at"`
    EventId   openapi_types.UUID `json:"event_id"`
    Payload   Event_Payload      `json:"payload"`
    Type      EventType          `json:"type"`
}

Decoding watcher.event further

Once you have a WatcherEventPayload, the next step depends on what you want:

// Step 1: cryptographic verification (returns (bool, error))
ok, err := client.Events.Verify(&ev)
if err != nil || !ok { return err }

// Extract the typed payload
wp, err := ev.Payload.AsWatcherEventPayload()
if err != nil { return err }

// Step 2a: canonical decoded form
decoded, err := client.Events.DecodeVerifiableEvent(&wp)
if err != nil { return err }

// Step 2b: pull out the EVM-specific event and read its decoded params
evm, err := decoded.ChainEvent.AsEVMEvent()
if err != nil { return err }
params := *evm.Params
fmt.Println(params["from"], params["to"], params["value"])

// Step 2c: extension decoder (e.g. DTA v2): handles steps 2a and 2b
//          for you and returns a typed struct.
typed, err := dtav2.DecodeFromEvent(ctx, ev)

See Decode Event Data.

See also

• Lifecycles: what Status transitions trigger each *.status payload.
• Event Verification: how verifiable_event is signed and verified.
• Verifiable Events: the VerifiableEvent model itself.