9149435990

Committed 19 May 2024 05:39PM UTC coverage: 64.249% (-0.5%) from 64.782%

Build # 9149435990

Build Type

push

github

Committed by

web-flow

Commit Message

Overall improvements (#214)

Run Details

27 of 427 new or added lines in 20 files covered. (6.32%)

14 existing lines in 4 files now uncovered.

27494 of 42793 relevant lines covered (64.25%)

0.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.95

/opcode/opcodes.go

package opcode

import (
        "fmt"

        opcode_pb "github.com/unpackdev/protos/dist/go/opcode"
)

// OpCode represents an Ethereum operation code (opcode).
// Opcodes are single byte values that represent a specific operation in the EVM.
// The OpCode type provides methods to retrieve the string representation of the opcode,
// and to determine if an opcode corresponds to specific operations like PUSH or JUMP.
type OpCode byte

// String returns the string representation of the OpCode.
// This method tries to fetch the human-readable name of the opcode from the opCodeToString map.
// If the opcode is not found in the map, it returns a formatted string indicating the undefined opcode.
func (op OpCode) String() string {
        str := opCodeToString[op]
        if len(str) == 0 {
                return fmt.Sprintf("opcode %#x not defined", int(op))
        }

        return str
}

// ToProto converts the opcode to a protobuf message.
func (op OpCode) ToProto() opcode_pb.OpCode {
        return opcode_pb.OpCode(op)
}

// IsPush checks if the given opcode is a PUSH opcode.
// In the Ethereum instruction set, there are several PUSH opcodes ranging from PUSH1 to PUSH32.
// These opcodes are used to place a series of bytes onto the stack.
func (op OpCode) IsPush() bool {
        return PUSH1 <= op && op <= PUSH32
}

// IsJump determines if an opcode corresponds to a jump operation.
// Jump operations in the EVM allow for altering the sequence of execution.
// This method checks for three specific jump-related opcodes: JUMP, JUMPI, and JUMPDEST.
func (op OpCode) IsJump() bool {
        switch op {
        case JUMP, JUMPI, JUMPDEST:
                return true
        default:
                return false
        }
}

// IsArithmetic checks if the given opcode corresponds to an arithmetic operation.
// Arithmetic operations in the EVM include addition, multiplication, subtraction, etc.
func (op OpCode) IsArithmetic() bool {
        switch op {
        case ADD, MUL, SUB, DIV, SDIV, MOD, SMOD, ADDMOD, MULMOD, EXP, SIGNEXTEND:
                return true
        default:
                return false
        }
}

// IsComparison checks if the given opcode corresponds to a comparison operation.
// Comparison operations in the EVM include less than, greater than, equal to, etc.
func (op OpCode) IsComparison() bool {
        switch op {
        case LT, GT, SLT, SGT, EQ, ISZERO:
                return true
        default:
                return false
        }
}

// IsBitwise checks if the given opcode corresponds to a bitwise operation.
// Bitwise operations in the EVM include AND, OR, XOR, NOT, etc.
func (op OpCode) IsBitwise() bool {
        switch op {
        case AND, OR, XOR, NOT, BYTE, SHL, SHR, SAR:
                return true
        default:
                return false
        }
}

// IsBlockInformation checks if the given opcode provides information about the current block.
// These opcodes provide details like the current block's hash, coinbase, timestamp, etc.
func (op OpCode) IsBlockInformation() bool {
        switch op {
        case BLOCKHASH, COINBASE, TIMESTAMP, NUMBER, DIFFICULTY, GASLIMIT:
                return true
        default:
                return false
        }
}

// IsStack checks if the given opcode is related to stack operations.
// Stack operations in the EVM include operations that interact with the main stack.
func (op OpCode) IsStack() bool {
        switch op {
        case POP, MLOAD, MSTORE, MSTORE8, SLOAD, SSTORE, JUMP, JUMPI, PC, MSIZE, GAS:
                return true
        default:
                return false
        }
}

// IsMemory checks if the given opcode is related to memory operations.
// Memory operations in the EVM include operations that interact with the memory segment.
func (op OpCode) IsMemory() bool {
        switch op {
        case MLOAD, MSTORE, MSTORE8, MSIZE:
                return true
        default:
                return false
        }
}

// IsStorage checks if the given opcode is related to storage operations.
// Storage operations in the EVM include operations that interact with the contract's storage.
func (op OpCode) IsStorage() bool {
        switch op {
        case SLOAD, SSTORE:
                return true
        default:
                return false
        }
}

// IsFlowControl checks if the given opcode is related to flow control operations.
// Flow control operations in the EVM include operations that alter the sequence of execution.
func (op OpCode) IsFlowControl() bool {
        switch op {
        case JUMP, JUMPI, PC, MSIZE, GAS, STOP, RETURN, REVERT, INVALID, SELFDESTRUCT:
                return true
        default:
                return false
        }
}

// IsSystem checks if the given opcode is a system operation.
// System operations in the EVM include operations like contract creation, external calls, etc.
func (op OpCode) IsSystem() bool {
        switch op {
        case CREATE, CALL, CALLCODE, RETURN, DELEGATECALL, CREATE2, STATICCALL, REVERT, INVALID, SELFDESTRUCT:
                return true
        default:
                return false
        }
}

// IsFunctionStart checks if the opcode represents the start of a function.
func (op OpCode) IsFunctionStart() bool {
        // JUMPDEST indicates a valid jump destination, which commonly marks the beginning of a function.
        return op == JUMPDEST
}

// IsFunctionEnd checks if the opcode represents the end of a function.
func (op OpCode) IsFunctionEnd() bool {
        // RETURN or STOP typically indicate the end of execution for a function.
        return op == RETURN || op == STOP
}

// IsEvent checks if the given opcode corresponds to an event logging operation.
// The LOG0 to LOG4 opcodes are used to log events in the EVM.
func (op OpCode) IsEvent() bool {
        switch op {
        case LOG0, LOG1, LOG2, LOG3, LOG4:
                return true
        default:
                return false
        }
}

// OpCode extensions for identifying PUSH32 and LOG opcodes
func (op OpCode) IsPush32() bool {
        return op == PUSH32
}

func (op OpCode) IsLog() bool {
        return op >= LOG0 && op <= LOG4
}

// IsSelfDestruct checks if the given opcode corresponds to the SELFDESTRUCT operation.
// The SELFDESTRUCT opcode is used in the EVM to destroy the current contract, sending its funds to the provided address.
func (op OpCode) IsSelfDestruct() bool {
        return op == SELFDESTRUCT
}

1	package opcode
2
3	import (
4	"fmt"
5
6	opcode_pb "github.com/unpackdev/protos/dist/go/opcode"
7	)
8
9	// OpCode represents an Ethereum operation code (opcode).
10	// Opcodes are single byte values that represent a specific operation in the EVM.
11	// The OpCode type provides methods to retrieve the string representation of the opcode,
12	// and to determine if an opcode corresponds to specific operations like PUSH or JUMP.
13	type OpCode byte
14
15	// String returns the string representation of the OpCode.
16	// This method tries to fetch the human-readable name of the opcode from the opCodeToString map.
17	// If the opcode is not found in the map, it returns a formatted string indicating the undefined opcode.
18	func (op OpCode) String() string {	1✔
19	str := opCodeToString[op]	1✔
20	if len(str) == 0 {	2✔
21	return fmt.Sprintf("opcode %#x not defined", int(op))	1✔
22	}	1✔
23
24	return str	1✔
25	}
26
27	// ToProto converts the opcode to a protobuf message.
28	func (op OpCode) ToProto() opcode_pb.OpCode {	1✔
29	return opcode_pb.OpCode(op)	1✔
30	}	1✔
31
32	// IsPush checks if the given opcode is a PUSH opcode.
33	// In the Ethereum instruction set, there are several PUSH opcodes ranging from PUSH1 to PUSH32.
34	// These opcodes are used to place a series of bytes onto the stack.
35	func (op OpCode) IsPush() bool {	1✔
36	return PUSH1 <= op && op <= PUSH32	1✔
37	}	1✔
38
39	// IsJump determines if an opcode corresponds to a jump operation.
40	// Jump operations in the EVM allow for altering the sequence of execution.
41	// This method checks for three specific jump-related opcodes: JUMP, JUMPI, and JUMPDEST.
42	func (op OpCode) IsJump() bool {	1✔
43	switch op {	1✔
44	case JUMP, JUMPI, JUMPDEST:	1✔
45	return true	1✔
46	default:	1✔
47	return false	1✔
48	}
49	}
50
51	// IsArithmetic checks if the given opcode corresponds to an arithmetic operation.
52	// Arithmetic operations in the EVM include addition, multiplication, subtraction, etc.
53	func (op OpCode) IsArithmetic() bool {	1✔
54	switch op {	1✔
55	case ADD, MUL, SUB, DIV, SDIV, MOD, SMOD, ADDMOD, MULMOD, EXP, SIGNEXTEND:	1✔
56	return true	1✔
57	default:	1✔
58	return false	1✔
59	}
60	}
61
62	// IsComparison checks if the given opcode corresponds to a comparison operation.
63	// Comparison operations in the EVM include less than, greater than, equal to, etc.
64	func (op OpCode) IsComparison() bool {	1✔
65	switch op {	1✔
66	case LT, GT, SLT, SGT, EQ, ISZERO:	1✔
67	return true	1✔
68	default:	1✔
69	return false	1✔
70	}
71	}
72
73	// IsBitwise checks if the given opcode corresponds to a bitwise operation.
74	// Bitwise operations in the EVM include AND, OR, XOR, NOT, etc.
75	func (op OpCode) IsBitwise() bool {	1✔
76	switch op {	1✔
77	case AND, OR, XOR, NOT, BYTE, SHL, SHR, SAR:	1✔
78	return true	1✔
79	default:	1✔
80	return false	1✔
81	}
82	}
83
84	// IsBlockInformation checks if the given opcode provides information about the current block.
85	// These opcodes provide details like the current block's hash, coinbase, timestamp, etc.
86	func (op OpCode) IsBlockInformation() bool {	1✔
87	switch op {	1✔
88	case BLOCKHASH, COINBASE, TIMESTAMP, NUMBER, DIFFICULTY, GASLIMIT:	1✔
89	return true	1✔
90	default:	1✔
91	return false	1✔
92	}
93	}
94
95	// IsStack checks if the given opcode is related to stack operations.
96	// Stack operations in the EVM include operations that interact with the main stack.
97	func (op OpCode) IsStack() bool {	1✔
98	switch op {	1✔
99	case POP, MLOAD, MSTORE, MSTORE8, SLOAD, SSTORE, JUMP, JUMPI, PC, MSIZE, GAS:	1✔
100	return true	1✔
101	default:	1✔
102	return false	1✔
103	}
104	}
105
106	// IsMemory checks if the given opcode is related to memory operations.
107	// Memory operations in the EVM include operations that interact with the memory segment.
108	func (op OpCode) IsMemory() bool {	1✔
109	switch op {	1✔
110	case MLOAD, MSTORE, MSTORE8, MSIZE:	1✔
111	return true	1✔
112	default:	1✔
113	return false	1✔
114	}
115	}
116
117	// IsStorage checks if the given opcode is related to storage operations.
118	// Storage operations in the EVM include operations that interact with the contract's storage.
119	func (op OpCode) IsStorage() bool {	1✔
120	switch op {	1✔
121	case SLOAD, SSTORE:	1✔
122	return true	1✔
123	default:	1✔
124	return false	1✔
125	}
126	}
127
128	// IsFlowControl checks if the given opcode is related to flow control operations.
129	// Flow control operations in the EVM include operations that alter the sequence of execution.
130	func (op OpCode) IsFlowControl() bool {	1✔
131	switch op {	1✔
132	case JUMP, JUMPI, PC, MSIZE, GAS, STOP, RETURN, REVERT, INVALID, SELFDESTRUCT:	1✔
133	return true	1✔
134	default:	1✔
135	return false	1✔
136	}
137	}
138
139	// IsSystem checks if the given opcode is a system operation.
140	// System operations in the EVM include operations like contract creation, external calls, etc.
141	func (op OpCode) IsSystem() bool {	1✔
142	switch op {	1✔
143	case CREATE, CALL, CALLCODE, RETURN, DELEGATECALL, CREATE2, STATICCALL, REVERT, INVALID, SELFDESTRUCT:	1✔
144	return true	1✔
145	default:	1✔
146	return false	1✔
147	}
148	}
149
150	// IsFunctionStart checks if the opcode represents the start of a function.
151	func (op OpCode) IsFunctionStart() bool {	×
152	// JUMPDEST indicates a valid jump destination, which commonly marks the beginning of a function.	×
153	return op == JUMPDEST	×
154	}	×
155
156	// IsFunctionEnd checks if the opcode represents the end of a function.
157	func (op OpCode) IsFunctionEnd() bool {	×
158	// RETURN or STOP typically indicate the end of execution for a function.	×
159	return op == RETURN \|\| op == STOP	×
160	}	×
161
162	// IsEvent checks if the given opcode corresponds to an event logging operation.
163	// The LOG0 to LOG4 opcodes are used to log events in the EVM.
NEW 164	func (op OpCode) IsEvent() bool {	×
NEW 165	switch op {	×
NEW 166	case LOG0, LOG1, LOG2, LOG3, LOG4:	×
NEW 167	return true	×
NEW 168	default:	×
NEW 169	return false	×
170	}
171	}
172
173	// OpCode extensions for identifying PUSH32 and LOG opcodes
NEW 174	func (op OpCode) IsPush32() bool {	×
NEW 175	return op == PUSH32	×
NEW 176	}	×
177
NEW 178	func (op OpCode) IsLog() bool {	×
NEW 179	return op >= LOG0 && op <= LOG4	×
NEW 180	}	×
181
182	// IsSelfDestruct checks if the given opcode corresponds to the SELFDESTRUCT operation.
183	// The SELFDESTRUCT opcode is used in the EVM to destroy the current contract, sending its funds to the provided address.
184	func (op OpCode) IsSelfDestruct() bool {	1✔
185	return op == SELFDESTRUCT	1✔
186	}	1✔

unpackdev / solgo / 9149435990

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous