evmole 0.8.4

Extracts function selectors and arguments from EVM bytecode
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

package internal

import (
	"context"
	"encoding/binary"
	"errors"
	"sync"

	"github.com/tetratelabs/wazero"
	"github.com/tetratelabs/wazero/api"
)

// Runtime manages the WASM module execution.
type Runtime struct {
	runtime wazero.Runtime
	module  api.Module
	alloc   api.Function
	dealloc api.Function
	analyze api.Function

	// WASM is single-threaded, need mutex for concurrent access
	mu sync.Mutex
}

// NewRuntime creates a new WASM runtime with AOT compilation.
// This takes ~50ms for compilation, so create once and reuse.
func NewRuntime(ctx context.Context, wasmBinary []byte) (*Runtime, error) {
	// Use AOT compilation for better performance
	r := wazero.NewRuntimeWithConfig(ctx, wazero.NewRuntimeConfigCompiler())

	module, err := r.Instantiate(ctx, wasmBinary)
	if err != nil {
		r.Close(ctx)
		return nil, err
	}

	alloc := module.ExportedFunction("wasm_alloc")
	if alloc == nil {
		r.Close(ctx)
		return nil, errors.New("wasm_alloc function not found in WASM module")
	}

	dealloc := module.ExportedFunction("wasm_dealloc")
	if dealloc == nil {
		r.Close(ctx)
		return nil, errors.New("wasm_dealloc function not found in WASM module")
	}

	analyze := module.ExportedFunction("contract_info")
	if analyze == nil {
		r.Close(ctx)
		return nil, errors.New("contract_info function not found in WASM module")
	}

	return &Runtime{
		runtime: r,
		module:  module,
		alloc:   alloc,
		dealloc: dealloc,
		analyze: analyze,
	}, nil
}

// Close releases all runtime resources.
func (r *Runtime) Close(ctx context.Context) error {
	return r.runtime.Close(ctx)
}

// ContractInfo analyzes bytecode and returns the JSON result.
func (r *Runtime) ContractInfo(ctx context.Context, code []byte, opts uint32) ([]byte, error) {
	if len(code) == 0 {
		return nil, errors.New("empty bytecode")
	}

	r.mu.Lock()
	defer r.mu.Unlock()

	// 1. Allocate memory for input code
	codePtrResult, err := r.alloc.Call(ctx, uint64(len(code)))
	if err != nil {
		return nil, err
	}
	if len(codePtrResult) == 0 || codePtrResult[0] == 0 {
		return nil, errors.New("failed to allocate memory for bytecode")
	}
	codePtr := uint32(codePtrResult[0])

	// Ensure code memory is freed
	defer r.dealloc.Call(ctx, uint64(codePtr), uint64(len(code)))

	// 2. Copy code to WASM memory
	if !r.module.Memory().Write(codePtr, code) {
		return nil, errors.New("failed to write bytecode to WASM memory")
	}

	// 3. Call analyze function
	resultPtrArr, err := r.analyze.Call(ctx, uint64(codePtr), uint64(len(code)), uint64(opts))
	if err != nil {
		return nil, err
	}
	if len(resultPtrArr) == 0 || resultPtrArr[0] == 0 {
		return nil, errors.New("contract_info returned null pointer")
	}
	resultPtr := uint32(resultPtrArr[0])

	// 4. Read result length (first 4 bytes) then data
	lenBytes, ok := r.module.Memory().Read(resultPtr, 4)
	if !ok {
		return nil, errors.New("failed to read result length from WASM memory")
	}
	resultLen := binary.LittleEndian.Uint32(lenBytes)

	result, ok := r.module.Memory().Read(resultPtr+4, resultLen)
	if !ok {
		return nil, errors.New("failed to read result from WASM memory")
	}

	// Make a copy since the memory might be reused
	resultCopy := make([]byte, len(result))
	copy(resultCopy, result)

	// 5. Deallocate result (length prefix + data)
	r.dealloc.Call(ctx, uint64(resultPtr), uint64(resultLen)+4)

	return resultCopy, nil
}