update event structs and add off chain requests with payment request as first example

Author: dkneisly

currencies.go

@@ -182,7 +182,7 @@ var CurrencyCodes = map[uint8]string{
 	178: "ZWG",
 }
 
-func GetCurrencyCode(currencyId uint8) OffChainReferenceData {
+func GetCurrencyCodeAsOffChainReferenceData(currencyId uint8) OffChainReferenceData {
 	result := OffChainReferenceData{
 		Source: OffChainReferenceDataSource{
 			Type:       "ISO Standard",
@@ -200,3 +200,11 @@ func GetCurrencyCode(currencyId uint8) OffChainReferenceData {
 	result.Data["currency_code"] = currencyCode
 	return result
 }
+
+func GetCurrencyCode(currencyId uint8) string {
+	currencyCode, ok := CurrencyCodes[currencyId]
+	if !ok {
+		return "Unknown"
+	}
+	return currencyCode
+}

event_processing.go

@@ -23,10 +23,14 @@ import (
 	"github.com/smartcontractkit/cre-sdk-go/cre"
 )
 
-func BuildVerifiableEvent(workflow Workflow, trigger Trigger, event Event, referenceData ReferenceData) VerifiableEvent {
+func BuildAndHashVerifiableEvent(domain string, trigger Trigger, event Event, referenceData ReferenceData) PreConsensusEventResults {
+	verifiableEvent := BuildVerifiableEvent(domain, trigger, event, referenceData)
+	return HashVerifiableEvent(verifiableEvent)
+}
+
+func BuildVerifiableEvent(domain string, trigger Trigger, event Event, referenceData ReferenceData) VerifiableEvent {
 	return VerifiableEvent{
-		CreatedAt:     time.Now().UTC(),
-		Workflow:      workflow,
+		Domain:        domain,
 		Trigger:       trigger,
 		Event:         event,
 		ReferenceData: referenceData,
@@ -36,7 +40,7 @@ func BuildVerifiableEvent(workflow Workflow, trigger Trigger, event Event, refer
 func HashVerifiableEvent(verifiableEvent VerifiableEvent) PreConsensusEventResults {
 	marshalledVerifiableEvent, _ := json.Marshal(verifiableEvent)
 	base64VerifiableEvent := base64.StdEncoding.EncodeToString(marshalledVerifiableEvent)
-	typeName := verifiableEvent.Workflow.Domain + "." + verifiableEvent.Event.EventName
+	typeName := verifiableEvent.Domain + "." + verifiableEvent.Event.EventName
 	payloadToSign := typeName + "." + base64VerifiableEvent
 	eventHash := crypto.Keccak256Hash([]byte(payloadToSign))
 
@@ -60,20 +64,14 @@ func GenerateAndPostReport(cfg *Config, rt cre.Runtime, pre PreConsensusEventRes
 	}
 	rpb := report.X_GeneratedCodeOnly_Unwrap()
 
-	// Convert ChainSelector to uint64
-	chainSelector, err := strconv.ParseUint(cfg.ChainSelector, 10, 64)
-	if err != nil {
-		return "", fmt.Errorf("invalid chain selector: %w", err)
-	}
-
 	// Compose HTTP body
 	bodyMap := map[string]any{
 		"event_id":         uuid.New().String(),
 		"created_at":       int64(pre.BlockTimestamp) * 1000, // Convert seconds to milliseconds for server
 		"watcher_id":       cfg.WatcherID,
 		"domain":           cfg.Service,
 		"name":             cfg.DetectEventTriggerConfig.ContractEventName,
-		"chain_selector":   chainSelector,
+		"chain_selector":   cfg.ChainSelector,
 		"address":          cfg.DetectEventTriggerConfig.ContractAddress,
 		"ocr_report":       "0x" + hex.EncodeToString(rpb.RawReport),
 		"ocr_context":      "0x" + hex.EncodeToString(rpb.ReportContext),
@@ -115,15 +113,6 @@ func GenerateAndPostReport(cfg *Config, rt cre.Runtime, pre PreConsensusEventRes
 	return pre.Base64Event, nil
 }
 
-func BuildWorkflow(cfg *Config, donID, domain string) Workflow {
-	return Workflow{
-		WorkflowName: cfg.WorkflowName,
-		WatcherID:    cfg.WatcherID,
-		DonID:        donID,
-		Domain:       domain,
-	}
-}
-
 func BuildTrigger(chainID string, payload *evm.Log) Trigger {
 	return Trigger{
 		ChainID:  chainID,

types.go

@@ -1,11 +1,18 @@
 package workflows
 
 import (
+	"encoding/json"
+	"fmt"
+	"strconv"
 	"time"
 
 	gethCommon "github.com/ethereum/go-ethereum/common"
 )
 
+const (
+	PaymentRequestType = "payment_request"
+)
+
 // CursorInfo contains parsed info from a "block-logIndex-txHash" string.
 type CursorInfo struct {
 	BlockNumber uint64
@@ -14,39 +21,32 @@ type CursorInfo struct {
 }
 
 type VerifiableEvent struct {
-	CreatedAt     time.Time     `json:"created_at"`
-	Workflow      Workflow      `json:"workflow"`
-	Trigger       Trigger       `json:"trigger"`
+	Domain        string        `json:"domain"`
 	Event         Event         `json:"event"`
 	ReferenceData ReferenceData `json:"reference_data"`
-}
-
-type Workflow struct {
-	WorkflowName string `json:"workflow_name"`
-	WatcherID    string `json:"watcher_id"`
-	DonID        string `json:"don_id"`
-	Domain       string `json:"domain"`
+	Trigger       Trigger       `json:"trigger"`
 }
 
 type Trigger struct {
 	ChainID  string `json:"chain_id"`
-	TxHash   string `json:"tx_hash"`
 	LogIndex uint64 `json:"log_index"`
+	TxHash   string `json:"tx_hash"`
 }
 
 type Event struct {
+	BlockNumber     uint64         `json:"block_number"`
+	BlockTimestamp  time.Time      `json:"block_timestamp"`
+	ContractAddress string         `json:"contract_address"`
 	EventName       string         `json:"event_name"`
 	EventSignature  string         `json:"event_signature"`
-	ContractAddress string         `json:"contract_address"`
 	TopicHash       string         `json:"topic_hash"`
-	BlockNumber     uint64         `json:"block_number"`
-	BlockTimestamp  time.Time      `json:"block_timestamp"`
 	Args            map[string]any `json:"args"`
 }
 
 type ReferenceData struct {
-	OnChain  []OnChainReferenceData  `json:"on_chain"`
-	OffChain []OffChainReferenceData `json:"off_chain"`
+	OnChain  []OnChainReferenceData  `json:"on_chain,omitempty"`
+	OffChain []OffChainReferenceData `json:"off_chain,omitempty"`
+	Requests []OffChainRequest       `json:"requests,omitempty"`
 }
 
 type OnChainReferenceData struct {
@@ -71,6 +71,69 @@ type OffChainReferenceDataSource struct {
 	Identifier string `json:"identifier"`
 }
 
+// OffChainRequest represents a request to be forwarded to an off-chain application.
+// The Type field determines which request type is contained in the Request field.
+// Use json.RawMessage to allow consumers to unmarshal the Request based on Type.
+type OffChainRequest struct {
+	Type    string          `json:"type" example:"payment"`
+	Request json.RawMessage `json:"request"`
+}
+
+// Fixed2 represents a fixed-point decimal number with 2 decimal places, stored as a string.
+// Example: "100.00" represents 100.00
+type Fixed2 float64
+
+func (f Fixed2) MarshalJSON() ([]byte, error) {
+	return fmt.Appendf(nil, "%.2f", f), nil
+}
+
+func (f *Fixed2) UnmarshalJSON(data []byte) error {
+	// Try unmarshaling as a float64
+	var num float64
+	err := json.Unmarshal(data, &num)
+	if err == nil {
+		*f = Fixed2(num)
+		return nil
+	}
+
+	// Fallback: try as a quoted string
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return fmt.Errorf("Fixed2: invalid JSON input: %w", err)
+	}
+	parsed, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return fmt.Errorf("Fixed2: cannot parse string value: %w", err)
+	}
+	*f = Fixed2(parsed)
+	return nil
+}
+
+// PaymentRequest contains the details needed for an off-chain payment request.
+type PaymentRequest struct {
+	ApplicationType string `json:"applicationType" example:"DVP"`
+	ApplicationAddr string `json:"applicationAddr" example:"0xApplicationAddress"`
+	E2EID           string `json:"e2eId" example:"E2E1234"`
+	Sender          string `json:"sender" example:"0xSenderAddress"`
+	Receiver        string `json:"receiver" example:"0xReceiverAddress"`
+	Currency        string `json:"currency" example:"USD"`
+	ChainID         string `json:"chainId" example:"1337"`
+	Amount          Fixed2 `json:"amount" example:"100.00"`
+	Expiration      *int64 `json:"expiration,omitempty" example:"1257894000"`
+	// Callback specifies how the off-chain payment handler should call back to the application.
+	// This can be a function signature (e.g., "fulfillPayment(bytes32,uint256)") or
+	// a more detailed callback specification.
+	CustomCallback *PaymentCallback `json:"customCallback,omitempty"`
+}
+
+// PaymentCallback specifies how to call back to the application after payment processing.
+type PaymentCallback struct {
+	// FunctionSignature is the ABI function signature to call (e.g., "fulfillPayment(bytes32,uint256)")
+	FunctionSignature string `json:"functionSignature,omitempty" example:"fulfillPayment(bytes32,uint256)"`
+	// ContractAddress is the contract address to call. If empty, uses ApplicationAddr from PaymentRequest.
+	ContractAddress string `json:"contractAddress,omitempty" example:"0xContractAddress"`
+}
+
 // PreConsensusEventResults holds the encoded event and hash used for consensus.
 type PreConsensusEventResults struct {
 	Base64Event    string