go: working for actual env

Author: reecepbcups

components/golang-evm-price-oracle/src/main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -26,7 +25,7 @@ func init() {
 	wavs.Exports.Run = func(triggerAction wavs.TriggerAction) types.TriggerResult {
 		triggerID, requestInput, dest := decodeTriggerEvent(triggerAction.Data)
 
-		result, err := compute(requestInput.Slice(), dest)
+		result, err := compute(requestInput.Slice())
 		if err != nil {
 			return cm.Err[types.TriggerResult](err.Error())
 		}
@@ -37,7 +36,7 @@ func init() {
 }
 
 // compute is the main function that computes the price of the crypto currency
-func compute(input []uint8, dest types.Destination) ([]byte, error) {
+func compute(input []uint8) ([]byte, error) {
 	// Input is now properly decoded by decodeTriggerEvent, so we can parse it directly
 	inputStr := string(input)
 	// Clean any remaining control characters and whitespace
@@ -48,7 +47,7 @@ func compute(input []uint8, dest types.Destination) ([]byte, error) {
 		return -1 // Remove control characters
 	}, inputStr)
 	cleanStr = strings.TrimSpace(cleanStr)
-	
+
 	fmt.Printf("Compute input (cleaned): '%s'\n", cleanStr)
 
 	id, err := strconv.Atoi(cleanStr)
@@ -86,74 +85,56 @@ func routeResult(triggerID uint64, result []byte, dest types.Destination) types.
 
 // decodeABIInput decodes ABI-encoded input data using go-eth library
 func decodeABIInput(input []byte) (string, error) {
-	// First, convert the input bytes to a string to check if it's a hex string
-	inputStr := string(input)
+	fmt.Printf("Attempting ABI decode on %d bytes: %x\n", len(input), input)
 
-	var hexData []byte
-	var err error
+	// The data is just the parameters (string), not a full method call
+	// Try to decode as a tuple containing a single string parameter
+	inputTuple := abi.NewTupleType(abi.TupleTypeElem{
+		Name: "data",
+		Type: abi.NewStringType(),
+	})
 
-	// Check if it's a hex string (starts with "0x")
-	if strings.HasPrefix(inputStr, "0x") {
-		// Decode the hex string to bytes
-		hexData, err = hex.DecodeString(inputStr[2:])
-		if err != nil {
-			return "", fmt.Errorf("failed to decode hex string: %w", err)
-		}
-	} else {
-		// If it's not a hex string, assume the input is already binary data
-		hexData = input
+	// Decode into a struct
+	var result struct {
+		Data string `abi:"data"`
+	}
+	err := abi.DecodeValue(inputTuple, input, &result)
+	if err == nil {
+		fmt.Printf("Successfully decoded tuple as string: '%s'\n", result.Data)
+		return result.Data, nil
 	}
+	fmt.Printf("Tuple decode failed: %v\n", err)
 
-	// Use go-eth library for generalized ABI decoding
-	// Try to decode as string first (most common case)
+	// Fallback: try to decode as a simple string parameter directly
 	stringType := abi.NewStringType()
-	var result string
-	err = abi.DecodeValue(stringType, hexData, &result)
+	var data string
+	err = abi.DecodeValue(stringType, input, &data)
 	if err == nil {
-		return result, nil
+		fmt.Printf("Successfully decoded as string: '%s'\n", data)
+		return data, nil
 	}
+	fmt.Printf("String decode failed: %v\n", err)
 
-	// If string decoding fails, try other common types
-	// Try uint256 (common for numeric inputs)
+	// Try uint256 as fallback
 	uintType := abi.NewUintType(256)
 	var uintResult *big.Int
-	err = abi.DecodeValue(uintType, hexData, &uintResult)
-	if err == nil {
-		return uintResult.String(), nil
-	}
-
-	// Try bytes (fallback for arbitrary data)
-	bytesType := abi.NewBytesType()
-	var bytesResult []byte
-	err = abi.DecodeValue(bytesType, hexData, &bytesResult)
+	err = abi.DecodeValue(uintType, input, &uintResult)
 	if err == nil {
-		return string(bytesResult), nil
+		result := uintResult.String()
+		fmt.Printf("Successfully decoded as uint256: '%s'\n", result)
+		return result, nil
 	}
+	fmt.Printf("Uint256 decode failed: %v\n", err)
 
-	// If all ABI decoding attempts fail, return the raw input as string
-	return string(input), nil
+	return "", fmt.Errorf("all ABI decoding attempts failed")
 }
 
 // decodeTriggerEvent is the function that decodes the trigger event from the chain event to Go.
 func decodeTriggerEvent(triggerAction trigger.TriggerData) (trigger_id uint64, req cm.List[uint8], dest types.Destination) {
 	// Handle CLI input case
 	if triggerAction.Raw() != nil {
 		raw := *triggerAction.Raw()
-		fmt.Printf("Raw input: %s\n", string(raw.Slice()))
-
-		// For CLI input, just use the raw string directly (no ABI decoding needed)
-		// CLI inputs are simple strings like "1", "2", etc.
-		rawString := string(raw.Slice())
-		// Remove null bytes and trim whitespace
-		cleanString := strings.ReplaceAll(rawString, "\x00", "")
-		trimmedString := strings.TrimSpace(cleanString)
-		fmt.Printf("CLI input (cleaned): %s\n", trimmedString)
-
-		// Convert the trimmed string back to bytes for processing
-		inputBytes := []byte(trimmedString)
-		inputList := cm.NewList(&inputBytes[0], len(inputBytes))
-
-		return 0, inputList, types.CliOutput
+		return decodeHexInput(raw.Slice(), types.CliOutput)
 	}
 
 	// Handle Ethereum event case
@@ -162,26 +143,43 @@ func decodeTriggerEvent(triggerAction trigger.TriggerData) (trigger_id uint64, r
 		panic("triggerAction.EthContractEvent() is nil")
 	}
 
-	// Use generalized ABI decoding for Ethereum event data
-	decodedString, err := decodeABIInput(ethEvent.Log.Data.Slice())
-	if err != nil {
-		fmt.Printf("Failed to decode Ethereum event ABI input: %v, using raw data\n", err)
-		// Fallback to original method if generalized decoding fails
-		triggerInfo := types.DecodeTriggerInfo(ethEvent.Log.Data.Slice())
-		fmt.Printf("Trigger ID: %v\n", triggerInfo.TriggerID)
-		fmt.Printf("Creator: %s\n", triggerInfo.Creator.String())
-		fmt.Printf("Input Data: %v\n", string(triggerInfo.Data))
-		return triggerInfo.TriggerID, cm.NewList(&triggerInfo.Data[0], len(triggerInfo.Data)), types.Ethereum
+	// Always use generalized ABI decoding for hex data
+	return decodeHexInput(ethEvent.Log.Data.Slice(), types.Ethereum)
+}
+
+// decodeHexInput handles hex data decoding for both CLI and Ethereum inputs
+func decodeHexInput(input []byte, dest types.Destination) (uint64, cm.List[uint8], types.Destination) {
+	fmt.Printf("Raw input: %s\n", string(input))
+
+	var decodedString string
+
+	if dest == types.Ethereum {
+		// For Ethereum events, try ABI decoding first
+		decoded, err := decodeABIInput(input)
+		if err != nil {
+			fmt.Printf("ABI decode failed: %v, using raw input\n", err)
+			decodedString = string(input)
+		} else {
+			decodedString = decoded
+		}
+	} else {
+		// For CLI input, just clean the raw input
+		cleanString := strings.Map(func(r rune) rune {
+			if r >= 32 && r < 127 {
+				return r
+			}
+			return -1
+		}, string(input))
+		decodedString = strings.TrimSpace(cleanString)
 	}
 
-	fmt.Printf("Decoded Ethereum event input: %s\n", decodedString)
+	fmt.Printf("Decoded input: %s\n", decodedString)
 
-	// For now, use trigger ID 0 and convert decoded string to bytes
-	// In a real implementation, you might need to extract trigger ID from the event differently
+	// Convert decoded string to bytes for processing
 	decodedBytes := []byte(decodedString)
 	decodedList := cm.NewList(&decodedBytes[0], len(decodedBytes))
 
-	return 0, decodedList, types.Ethereum
+	return 0, decodedList, dest
 }
 
 // fetchCryptoPrice fetches the price of the crypto currency from the CoinMarketCap API by their ID.