Introducing log, tx decoder including fixes for constructor (#163)

Author: 0x19

bytecode/constructor.go

@@ -21,10 +21,10 @@ type Argument struct {
 // Constructor represents a contract constructor.
 // It includes the ABI of the constructor, the raw signature, and the arguments.
 type Constructor struct {
-	Abi               string        `json:"abi"`           // ABI of the constructor
-	Parsed            abi.ABI       `json:"-"`             // Parsed ABI of the constructor
-	SignatureRaw      string        `json:"signature_raw"` // Raw signature of the constructor
-	Arguments         []Argument    // List of arguments in the constructor
+	Abi               string        `json:"abi"`                // ABI of the constructor
+	Parsed            abi.ABI       `json:"-"`                  // Parsed ABI of the constructor
+	SignatureRaw      string        `json:"signature_raw"`      // Raw signature of the constructor
+	Arguments         []Argument    `json:"arguments"`          // List of arguments in the constructor
 	UnpackedArguments []interface{} `json:"unpacked_arguments"` // List of unpacked arguments in the constructor
 }
 
@@ -43,11 +43,6 @@ func (c *Constructor) Pack() ([]byte, error) {
 // If they match, it creates an Argument object for each input and adds it to the arguments slice.
 // Finally, it returns a Constructor object containing the ABI, raw signature, and arguments.
 func DecodeConstructorFromAbi(bytecode []byte, constructorAbi string) (*Constructor, error) {
-	/* 	var fh interface{}
-	   	json.Unmarshal([]byte(constructorAbi), &fh)
-	   	f, _ := utils.ToJSONPretty(fh)
-	   	fmt.Println(string(f)) */
-
 	parsed, err := abi.JSON(strings.NewReader(constructorAbi))
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse ABI: %w", err)

bytecode/doc.go

@@ -1,5 +1,5 @@
 /*
-Package bytecode provides tools for decoding and analyzing Ethereum contract, transaction, event and log bytecode.
+Package bytecode provides tools for decoding and analyzing Ethereum contract, transaction, events, and log bytecode.
 The package is designed to extract and interpret metadata from Ethereum contract creation bytecode. It provides a Metadata struct that represents the metadata contained in the bytecode, as defined by the Solidity compiler. This includes information such as the IPFS hash of the metadata, the Swarm hash of the metadata, experimental metadata, and the version of the Solidity compiler used.
 */
 package bytecode

bytecode/log.go

@@ -0,0 +1,146 @@
+package bytecode
+
+import (
+	"bytes"
+	"fmt"
+	"math/big"
+	"strings"
+
+	abi "github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/unpackdev/solgo/utils"
+)
+
+// Topic represents a single decoded topic from an Ethereum event log. Topics are attributes
+// of an event, such as the method signature and indexed parameters.
+type Topic struct {
+	Name  string `json:"name"`  // The name of the topic.
+	Value any    `json:"value"` // The value of the topic, decoded into the appropriate Go data type.
+}
+
+// Log encapsulates a decoded Ethereum event log. It includes the event's details such as its name,
+// signature, the contract that emitted the event, and the decoded data and topics.
+type Log struct {
+	Event        *abi.Event         `json:"-"`             // ABI definition of the log's event.
+	Address      common.Address     `json:"address"`       // Address of the contract that emitted the event.
+	Abi          string             `json:"abi"`           // ABI string of the event.
+	SignatureHex common.Hash        `json:"signature_hex"` // Hex-encoded signature of the event.
+	Signature    string             `json:"signature"`     // Signature of the event.
+	Type         utils.LogEventType `json:"type"`          // Type of the event, classified by solgo.
+	Name         string             `json:"name"`          // Name of the event.
+	Data         map[string]any     `json:"data"`          // Decoded event data.
+	Topics       []Topic            `json:"topics"`        // Decoded topics of the event.
+}
+
+// DecodeLogFromAbi decodes an Ethereum event log using the provided ABI data. It returns a Log
+// instance containing the decoded event name, data, and topics. The function requires the event log
+// and its ABI as inputs. It handles errors such as missing topics or failure to parse the ABI.
+func DecodeLogFromAbi(log *types.Log, abiData []byte) (*Log, error) {
+	if log == nil || len(log.Topics) < 1 {
+		return nil, fmt.Errorf("log is nil or has no topics")
+	}
+
+	logABI, err := abi.JSON(bytes.NewReader(abiData))
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse abi: %s", err)
+	}
+
+	event, err := logABI.EventByID(log.Topics[0])
+	if err != nil {
+		return nil, fmt.Errorf("failed to get event by id %s: %s", log.Topics[0].Hex(), err)
+	}
+
+	data := make(map[string]any)
+	if err := event.Inputs.UnpackIntoMap(data, log.Data); err != nil {
+		return nil, fmt.Errorf("failed to unpack inputs into map: %s", err)
+	}
+
+	decodedTopics := make([]Topic, len(log.Topics))
+	for i, topic := range log.Topics {
+		if i == 0 {
+			continue
+		}
+
+		decodedTopic, err := decodeTopic(topic, event.Inputs[i-1])
+		if err != nil {
+			return nil, fmt.Errorf("failed to decode topic: %s", err)
+		}
+
+		decodedTopics[i] = Topic{
+			Name:  event.Inputs[i-1].Name,
+			Value: decodedTopic,
+		}
+	}
+
+	eventAbi, err := utils.EventToABI(event)
+	if err != nil {
+		return nil, fmt.Errorf("failed to cast event into the abi: %w", err)
+	}
+
+	toReturn := &Log{
+		Event:        event,
+		Address:      log.Address,
+		Abi:          eventAbi,
+		SignatureHex: log.Topics[0],
+		Signature:    strings.TrimLeft(event.String(), "event "),
+		Name:         event.Name,
+		Type:         utils.LogEventType(strings.ToLower(event.Name)),
+		Data:         data,
+		Topics:       decodedTopics[1:], // Exclude the first topic (event signature)
+	}
+
+	return toReturn, nil
+}
+
+// decodeTopic decodes a single topic from an Ethereum event log based on its ABI argument type.
+// It supports various data types including addresses, booleans, integers, strings, bytes, and more.
+// This function is internal and used within DecodeLogFromAbi to process each topic individually.
+func decodeTopic(topic common.Hash, argument abi.Argument) (interface{}, error) {
+	switch argument.Type.T {
+	case abi.AddressTy:
+		return common.BytesToAddress(topic.Bytes()), nil
+	case abi.BoolTy:
+		return topic[common.HashLength-1] == 1, nil
+	case abi.IntTy, abi.UintTy:
+		size := argument.Type.Size
+		if size > 256 {
+			return nil, fmt.Errorf("unsupported integer size: %d", size)
+		}
+		integer := new(big.Int).SetBytes(topic[:])
+		if argument.Type.T == abi.IntTy && size < 256 {
+			integer = adjustIntSize(integer, size)
+		}
+		return integer, nil
+	case abi.StringTy:
+		return topic, nil
+	case abi.BytesTy, abi.FixedBytesTy:
+		return topic.Bytes(), nil
+	case abi.SliceTy, abi.ArrayTy:
+		return nil, fmt.Errorf("array/slice decoding not implemented")
+	default:
+		return nil, fmt.Errorf("decoding for type %v not implemented", argument.Type.T)
+	}
+}
+
+// adjustIntSize adjusts the size of an integer to match its ABI-specified size, which is relevant
+// for signed integers smaller than 256 bits. This function ensures the integer is correctly
+// interpreted according to its defined bit size in the ABI.
+func adjustIntSize(integer *big.Int, size int) *big.Int {
+	if size == 256 || integer.Bit(size-1) == 0 {
+		return integer
+	}
+	return new(big.Int).Sub(integer, new(big.Int).Lsh(big.NewInt(1), uint(size)))
+}
+
+// GetTopicByName searches for and returns a Topic by its name from a slice of Topic instances.
+// It facilitates accessing specific topics directly by name rather than iterating over the slice.
+// If the topic is not found, it returns nil.
+func GetTopicByName(name string, topics []Topic) *Topic {
+	for _, topic := range topics {
+		if topic.Name == name {
+			return &topic
+		}
+	}
+	return nil
+}

bytecode/metadata.go

@@ -16,16 +16,18 @@ import (
 // The structure and encoding of the metadata is defined by the Solidity compiler.
 // More information can be found at https://docs.soliditylang.org/en/v0.8.20/metadata.html#encoding-of-the-metadata-hash-in-the-bytecode
 type Metadata struct {
-	executionBytecode []byte // The execution bytecode of the contract
-	cborLength        int16  // The length of the CBOR metadata
-	auxbytes          []byte // The raw CBOR metadata
-	Ipfs              []byte `cbor:"ipfs"`         // The IPFS hash of the metadata, if present
-	Bzzr1             []byte `cbor:"bzzr1"`        // The Swarm hash of the metadata, if present (version 1)
-	Bzzr0             []byte `cbor:"bzzr0"`        // The Swarm hash of the metadata, if present (version 0)
-	Experimental      []byte `cbor:"experimental"` // Experimental metadata, if present
-	Solc              []byte `cbor:"solc"`         // The version of the Solidity compiler used
+	executionBytecode []byte      // The execution bytecode of the contract
+	cborLength        int16       // The length of the CBOR metadata
+	auxbytes          []byte      // The raw CBOR metadata
+	Ipfs              []byte      `cbor:"ipfs"`         // The IPFS hash of the metadata, if present
+	Bzzr1             []byte      `cbor:"bzzr1"`        // The Swarm hash of the metadata, if present (version 1)
+	Bzzr0             []byte      `cbor:"bzzr0"`        // The Swarm hash of the metadata, if present (version 0)
+	Experimental      interface{} `cbor:"experimental"` // Experimental metadata, if present
+	Solc              []byte      `cbor:"solc"`         // The version of the Solidity compiler used
 }
 
+// ToProto converts the Metadata instance into a protobuf representation, suitable for
+// serialization and transmission across different systems or networks.
 func (m *Metadata) ToProto() *metadata_pb.BytecodeMetadata {
 	return &metadata_pb.BytecodeMetadata{
 		ExecutionBytecode: m.executionBytecode,
@@ -36,7 +38,7 @@ func (m *Metadata) ToProto() *metadata_pb.BytecodeMetadata {
 		Bzzr0:             m.GetBzzr0(),
 		Experimental:      m.GetExperimental(),
 		Solc:              m.GetCompilerVersion(),
-		Solgo:             "",
+		Solgo:             "", // TODO: Solgo version should be appended...
 	}
 }
 
@@ -51,11 +53,19 @@ func (m *Metadata) GetCompilerVersion() string {
 
 // GetExperimental returns whether the contract includes experimental metadata.
 func (m *Metadata) GetExperimental() bool {
-	toReturn, err := strconv.ParseBool(string(m.Experimental))
-	if err != nil {
-		return false
+	if experimental, ok := m.Experimental.(string); ok {
+		toReturn, err := strconv.ParseBool(experimental)
+		if err != nil {
+			return false
+		}
+		return toReturn
+	}
+
+	if experimental, ok := m.Experimental.(bool); ok {
+		return experimental
 	}
-	return toReturn
+
+	return false
 }
 
 // GetIPFS returns the IPFS hash of the contract's metadata, if present.
@@ -134,7 +144,6 @@ func DecodeContractMetadata(bytecode []byte) (*Metadata, error) {
 	if len(bytecode) >= bytesLength+cborLength {
 		toReturn.executionBytecode = bytecode[:len(bytecode)-bytesLength-cborLength]
 		toReturn.auxbytes = bytecode[len(bytecode)-bytesLength-cborLength : len(bytecode)-bytesLength]
-
 		if err := cbor.Unmarshal(toReturn.auxbytes, &toReturn); err != nil {
 			return nil, err
 		}

bytecode/metadata_test.go

@@ -67,9 +67,6 @@ func TestDecodeContractCreationMetadata(t *testing.T) {
 				assert.NotNil(t, got.GetExecutionBytecode())
 				assert.NotNil(t, got.ToProto())
 				assert.GreaterOrEqual(t, len(got.GetUrls()), 0)
-
-				got.Experimental = []byte("true")
-				assert.True(t, got.GetExperimental())
 			}
 		})
 	}

bytecode/transaction.go

@@ -0,0 +1,69 @@
+package bytecode
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	abi "github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/unpackdev/solgo/utils"
+)
+
+// Transaction encapsulates a decoded Ethereum transaction, providing detailed information
+// about the transaction's method, its arguments, and the associated ABI.
+// This structured format makes it easier to work with Ethereum transactions programmatically.
+type Transaction struct {
+	Abi            string                      `json:"abi"`             // ABI string of the transaction's method.
+	SignatureBytes []byte                      `json:"signature_bytes"` // Raw signature bytes of the transaction.
+	Signature      string                      `json:"signature"`       // Human-readable signature of the transaction's method.
+	Type           utils.TransactionMethodType `json:"type"`            // Type of the transaction, classified by its method name.
+	Name           string                      `json:"name"`            // Name of the transaction's method.
+	Method         *abi.Method                 `json:"-"`               // ABI method information, not serialized to JSON.
+	Inputs         map[string]interface{}      `json:"inputs"`          // Decoded arguments passed to the transaction's method.
+}
+
+// DecodeTransactionFromAbi decodes an Ethereum transaction using the provided ABI.
+// It extracts the method signature and arguments from the raw transaction data, constructing
+// a Transaction object that includes this information along with the method's ABI.
+//
+// The function requires the raw transaction data (`data`) and the ABI of the smart contract
+// (`abiData`) in JSON format. It returns a pointer to a Transaction object, populated with
+// the decoded method information and its arguments, or an error if decoding fails.
+//
+// This function simplifies the process of interacting with raw Ethereum transactions, making
+// it easier to analyze and use the transaction data programmatically.
+func DecodeTransactionFromAbi(data []byte, abiData []byte) (*Transaction, error) {
+	// The first 4 bytes of the data represent the ID of the method in the ABI.
+	methodSigData := data[:4]
+
+	contractABI, err := abi.JSON(bytes.NewReader(abiData))
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse abi: %s", err)
+	}
+
+	method, err := contractABI.MethodById(methodSigData)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get method by id: %s", err)
+	}
+
+	inputsSigData := data[4:]
+	inputsMap := make(map[string]interface{})
+	if err := method.Inputs.UnpackIntoMap(inputsMap, inputsSigData); err != nil {
+		return nil, fmt.Errorf("failed to unpack inputs into map: %s", err)
+	}
+
+	txAbi, err := utils.MethodToABI(method)
+	if err != nil {
+		return nil, fmt.Errorf("failure to cast method into abi: %w", err)
+	}
+
+	return &Transaction{
+		Abi:            txAbi,
+		SignatureBytes: methodSigData,
+		Signature:      method.String(),
+		Name:           method.Name,
+		Method:         method,
+		Type:           utils.TransactionMethodType(strings.ToLower(method.Name)),
+		Inputs:         inputsMap,
+	}, nil
+}