package main

import (
	"encoding/hex"
	"fmt"
	"log"

	"github.com/pk910/go-evmjit/irgen"
)

func main() {
	// Example: PUSH1 0x42 PUSH1 0x01 ADD STOP -> 604260010100
	bytecodeHex := "604260010100"
	bytecode, err := hex.DecodeString(bytecodeHex)
	if err != nil {
		log.Fatalf("Failed to decode bytecode: %v", err)
	}

	parser := irgen.NewParser("evm0")
	if parser == nil {
		log.Fatal("Failed to create parser for evm0")
	}

	err = parser.ParseCodeSection("main", bytecode)
	if err != nil {
		log.Fatalf("Failed to parse code section: %v", err)
	}

	llvmIR := parser.GenerateIR()

	fmt.Println("Generated LLVM IR:")
	fmt.Println(llvmIR)
}

package main

import (
	"encoding/hex"
	"fmt"
	"log"

	"github.com/pk910/go-evmjit/irgen"
	"github.com/pk910/go-evmjit/llvm"
)

func main() {
	// 1. Generate IR (as shown in the previous example)
	bytecodeHex := "604260010100" // PUSH1 42 PUSH1 01 ADD STOP
	bytecode, _ := hex.DecodeString(bytecodeHex)
	parser := irgen.NewParser("evm0")
	if parser == nil {
		log.Fatal("Failed to create parser for evm0")
	}
	err := parser.ParseCodeSection("main", bytecode)
	if err != nil {
		log.Fatalf("Failed to parse code section: %v", err)
	}
	llvmIR := parser.GenerateIR()

	// 2. Load IR code into module
	mod := llvm.NewModule()
	mod.LoadIR(llvmIR)

	// 3. Persist the IR in bytecode format (optional)
	modBytes, err := mod.Marshal()
	if err != nil {
		fmt.Println("Error marshalling module:", err)
	}

	// 4. Load the persisted IR bytecode (optional)
	err = mod.Unmarshal(modBytes)
	if err != nil {
		fmt.Println("Error unmarshalling module:", err)
	}

	// 4. Create call context & execute code
	callctx, err := llvm.NewCallCtx(nil, 10000) // 10000 gas
	if err != nil {
		fmt.Println("Error creating call context:", err)
		return
	}
	defer callctx.Dispose()

	res, err := mod.Call(callctx, "main")
	if err != nil {
		fmt.Println("Error executing contract: ", err)
		return
	}
	fmt.Println("Contract execution result: ", res)
}

package main

import (
	"fmt"
	"github.com/pk910/go-evmjit/llvm"
	// ... other necessary imports like irgen, hex, log ...
)

// Example binding function for a hypothetical LOG opcode (0xA5)
func handleLog(c *llvm.CallCtx, inputs []byte, output []byte, gasleft *uint64) error {
	offset := inputs[0:32]
	length := inputs[32:64]

	// In a real scenario, you'd read memory based on offset/length
	// from the CallCtx (c) and interact with the host environment.
	fmt.Printf("LOGGING: offset=%x length=%x\n", offset, length)

	// Consume gas (example)
	const gasCost = 50
	if *gasleft < gasCost {
		return llvm.ErrOutOfGas
	}
	*gasleft -= gasCost

	return nil
}

func main() {
	opBindings := llvm.NewOpBindings()
	defer opBindings.Dispose()

	// Add the binding for opcode 0xA5
	opBindings.AddBinding(0xA5, handleLog)

	// ... 
}