status-im
/
nimbus-eth1
mirror of https://github.com/status-im/nimbus-eth1.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

implement macro_assembler and opcodes test suite

This commit is contained in:
andri lim 2019-01-30 19:29:04 +07:00 committed by zah
parent bf8e7a74b5
commit 58b5aa5f39
8 changed files with 3183 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
tests/all_tests.nim
View File

@ -16,4 +16,9 @@ import ./test_code_stream,
./test_generalstate_json,
./test_tracer_json,
./test_persistblock_json,
./test_rpc
./test_rpc,
./test_op_arith,
./test_op_bit,
./test_op_env,
./test_op_memory,
./test_op_misc

552
tests/macro_assembler.nim Normal file
View File

@ -0,0 +1,552 @@
import
macros, strutils, unittest, byteutils, chronicles,
../nimbus/vm/interpreter/opcode_values, ranges, eth_common
import
options, json, os, eth_trie/[db, hexary],
../nimbus/[vm_state, tracer, vm_types, transaction],
../nimbus/db/[db_chain, state_db],
../nimbus/vm_state_transactions,
../nimbus/vm/interpreter/[vm_forks, gas_costs],
../nimbus/utils/addresses,
../nimbus/vm/[message, computation, memory]
export opcode_values, byteutils
{.experimental: "dynamicBindSym".}
type
VMWord* = array[32, byte]
Storage* = tuple[key, val: VMWord]
Assembler* = object
title*: string
stack*: seq[VMWord]
memory*: seq[VMWord]
storage*: seq[Storage]
code*: seq[byte]
logs*: seq[Log]
success*: bool
gasLimit*: GasInt
gasUsed*: GasInt
data*: seq[byte]
output*: seq[byte]
OpcodeDesc = object
numParams: int
var
g_asm {.compileTime.}: Assembler
g_code {.compileTime.}: NimNode
g_lookup {.compileTime.}: array[256, OpcodeDesc]
proc writeLUT(opcode: Op, numParams: int) {.compileTime.} =
g_lookup[ord(opcode)] = OpcodeDesc(numParams: numParams)
proc initializeLUT() {.compileTime.} =
writeLUT(Stop, 0)
writeLUT(Add, 2)
writeLUT(Mul, 2)
writeLUT(Sub, 2)
writeLUT(Div, 2)
writeLUT(Sdiv, 2)
writeLUT(Mod, 2)
writeLUT(Smod, 2)
writeLUT(Addmod, 3)
writeLUT(Mulmod, 3)
writeLUT(Exp, 2)
writeLUT(SignExtend, 2)
writeLUT(Lt, 2)
writeLUT(Gt, 2)
writeLUT(Slt, 2)
writeLUT(Sgt, 2)
writeLUT(Eq, 2)
writeLUT(IsZero, 1)
writeLUT(And, 2)
writeLUT(Or, 2)
writeLUT(Xor, 2)
writeLUT(Not, 1)
writeLUT(Byte, 2)
writeLUT(Sha3, 2)
writeLUT(Address, 0)
writeLUT(Balance, 1)
writeLUT(Origin, 0)
writeLUT(Caller, 0)
writeLUT(CallValue, 0)
writeLUT(CallDataLoad, 1)
writeLUT(CallDataSize, 0)
writeLUT(CallDataCopy, 3)
writeLUT(CodeSize, 0)
writeLUT(CodeCopy, 3)
writeLUT(GasPrice, 0)
writeLUT(ExtCodeSize, 1)
writeLUT(ExtCodeCopy, 4)
writeLUT(ReturnDataSize, 0)
writeLUT(ReturnDataCopy, 3)
writeLUT(Blockhash, 1)
writeLUT(Coinbase, 0)
writeLUT(Timestamp, 0)
writeLUT(Number, 0)
writeLUT(Difficulty, 0)
writeLUT(GasLimit, 0)
writeLUT(Pop, 1)
writeLUT(Mload, 1)
writeLUT(Mstore, 2)
writeLUT(Mstore8, 2)
writeLUT(Sload, 1)
writeLUT(Sstore, 2)
writeLUT(Jump, 1)
writeLUT(JumpI, 2)
writeLUT(Pc, 0)
writeLUT(Msize, 0)
writeLUT(Gas, 0)
writeLUT(JumpDest, 0)
for i in Push1 .. Push32:
writeLUT(i, 1)
for i in Dup1 .. Dup16:
writeLUT(i, 0)
for i in Swap1 .. Swap16:
writeLUT(i, 0)
for i in Log0 .. Log4:
writeLUT(i, 0)
writeLUT(Create, 3)
writeLUT(Call, 7)
writeLUT(CallCode, 7)
writeLUT(Return, 2)
writeLUT(DelegateCall, 6)
writeLUT(StaticCall, 6)
writeLUT(Revert, 2)
writeLUT(Invalid, 1)
writeLUT(SelfDestruct, 1)
static:
initializeLUT()
proc validateVMWord(val: string, n: NimNode): VMWord =
if val.len <= 2 or val.len > 66:
error("invalid hex string", n)
if not (val[0] == '0' and val[1] == 'x'):
error("invalid hex string", n)
let zerosLen = 64 - (val.len - 2)
let value = repeat('0', zerosLen) & val.substr(2)
hexToByteArray(value, result)
proc validateVMWord(val: NimNode): VMWord =
val.expectKind(nnkStrLit)
validateVMWord(val.strVal, val)
proc parseVMWords(list: NimNode): seq[VMWord] =
result = @[]
list.expectKind nnkStmtList
for val in list:
result.add validateVMWord(val)
proc validateStorage(val: NimNode): Storage =
val.expectKind(nnkCall)
val[0].expectKind(nnkStrLit)
val[1].expectKind(nnkStmtList)
assert(val[1].len == 1)
val[1][0].expectKind(nnkStrLit)
result = (validateVMWord(val[0]), validateVMWord(val[1][0]))
proc parseStorage(list: NimNode): seq[Storage] =
result = @[]
list.expectKind nnkStmtList
for val in list:
result.add validateStorage(val)
proc parseSuccess(list: NimNode): bool =
list.expectKind nnkStmtList
list[0].expectKind(nnkIdent)
$list[0] == "true"
proc parseData(list: NimNode): seq[byte] =
result = @[]
list.expectKind nnkStmtList
for n in list:
n.expectKind(nnkStrLit)
result.add hexToSeqByte(n.strVal)
proc validateOpcode(sym: NimNode) =
let typ = getTypeInst(sym)
typ.expectKind(nnkSym)
if $typ != "Op":
error("unknown opcode '" & $sym & "'", sym)
proc addOpCode(opcode: Op, node: NimNode, params: varargs[string]) =
let lut = g_lookup[opcode.ord]
if lut.numParams > 0 and params.len > 0:
if lut.numParams != params.len:
error("Opcode '" & $opcode & "' expect " & $lut.numParams & " params, but got " & $params.len, node)
case opcode
of Push1..Push32:
if params.len != 1:
error("expect 1 param, but got " & $params.len, node)
let paramWidth = (opcode.ord - 95) * 2
var val = params[0]
if val[0] == '0' and val[1] == 'x':
val = val.substr(2)
if val.len != paramWidth:
error("expected param with " & $paramWidth & " hex digits, got " & $val.len, node)
g_asm.code.add byte(opcode)
g_asm.code.add hexToSeqByte(val)
else:
error("invalid hex format", node)
else:
if params.len > 0:
for i in countDown(params.len - 1, 0):
g_asm.code.add byte(Push32)
g_asm.code.add validateVMWord(params[i], node)
g_asm.code.add byte(opcode)
proc addLiteral(node: NimNode, rawCode: string) =
if rawCode[0] == '0' and rawCode[1] == 'x':
let val = rawCode.substr(2)
g_asm.code.add hexToSeqByte(val)
else:
error("invalid hex format", node)
proc generateVMProxy(boa: Assembler): NimNode =
let vmProxy = genSym(nskProc, "vmProxy")
var body = newStmtList()
let
boaIdent = ident("boa")
title = boa.title
success = ident(if boa.success: "true" else: "false")
code = boa.code.toHex()
blockNumber = ident("blockNumber")
chainDB = ident("chainDB")
gasLimit = boa.gasLimit
gasUsed = boa.gasUsed
data = boa.data.toHex()
output = boa.output.toHex()
body.add quote do:
var `boaIdent`: Assembler
`boaIdent`.success = `success`
`boaIdent`.code = hexToSeqByte(`code`)
`boaIdent`.title = `title`
`boaIdent`.gasLimit = `gasLimit`
`boaIdent`.gasUsed = `gasUsed`
if boa.data.len > 0:
body.add quote do:
`boaIdent`.data = hexToSeqByte(`data`)
if boa.output.len > 0:
body.add quote do:
`boaIdent`.output = hexToSeqByte(`output`)
if boa.stack.len > 0:
let len = boa.stack.len
body.add quote do:
`boaIdent`.stack = newSeq[VMWord](`len`)
if boa.memory.len > 0:
let len = boa.memory.len
body.add quote do:
`boaIdent`.memory = newSeq[VMWord](`len`)
if boa.storage.len > 0:
let len = boa.storage.len
body.add quote do:
`boaIdent`.storage = newSeq[Storage](`len`)
for i, s in boa.stack:
let val = s.toHex()
body.add quote do:
hexToByteArray(`val`, `boaIdent`.stack[`i`])
for i, s in boa.memory:
let val = s.toHex()
body.add quote do:
hexToByteArray(`val`, `boaIdent`.memory[`i`])
for i, kv in boa.storage:
let key = kv[0].toHex()
let val = kv[1].toHex()
body.add quote do:
hexToByteArray(`key`, `boaIdent`.storage[`i`].key)
hexToByteArray(`val`, `boaIdent`.storage[`i`].val)
if boa.logs.len > 0:
let len = boa.logs.len
body.add quote do:
`boaIdent`.logs = newSeq[Log](`len`)
for i, log in boa.logs:
let address = log.address.toHex()
let data = log.data.toHex()
body.add quote do:
hexToByteArray(`address`, `boaIdent`.logs[`i`].address)
`boaIdent`.logs[`i`].data = hexToSeqByte(`data`)
if log.topics.len > 0:
let len = log.topics.len
body.add quote do:
`boaIdent`.logs[`i`].topics = newSeq[Topic](`len`)
for x, t in log.topics:
let topic = t.toHex()
body.add quote do:
hexToByteArray(`topic`, `boaIdent`.logs[`i`].topics[`x`])
body.add quote do: runVM(`blockNumber`, `chainDB`, `boaIdent`)
result = quote do:
test `title`:
proc `vmProxy`(): bool =
`body`
check `vmProxy`()
when defined(macro_assembler_debug):
echo result.toStrLit.strVal
proc assemblerImpl(boa: var Assembler, codes: NimNode): NimNode =
g_code = codes
boa.code = @[]
codes.expectKind nnkStmtList
let macroName = genSym(nskMacro, "asmProxy")
var addStop = true
var body = newStmtList()
for pc, line in codes:
line.expectKind({nnkCommand, nnkIdent, nnkStrLit})
if line.kind == nnkStrLit:
body.add quote do:
addLiteral(g_code[`pc`], `line`)
elif line.kind == nnkIdent:
let sym = bindSym(line)
validateOpcode(sym)
body.add quote do:
addOpCode(`sym`, g_code[`pc`])
if pc == codes.len - 1:
if normalize($sym) == "stop":
addStop = false
elif line.kind == nnkCommand:
let ident = line[0]
let sym = bindSym(ident)
validateOpcode(sym)
var params = newNimNode(nnkBracket)
for i in 1 ..< line.len:
params.add line[i]
body.add quote do:
addOpCode(`sym`, g_code[`pc`], `params`)
else:
error("unknown syntax: " & line.toStrLit.strVal, line)
let stop = ident("Stop")
if addStop:
body.add quote do:
addOpCode(`stop`, newEmptyNode())
let resIdent = ident("result")
result = quote do:
macro `macroName`(): untyped =
`body`
`resIdent` = generateVMProxy(g_asm)
`macroName`()
when defined(macro_assembler_debug):
echo result.toStrLit.strVal
const
blockFile = "fixtures" / "PersistBlockTests" / "block47205.json"
proc initComputation(vmState: BaseVMState, tx: Transaction, sender: EthAddress, data: seq[byte], forkOverride=none(Fork)) : BaseComputation =
assert tx.isContractCreation
let fork =
if forkOverride.isSome:
forkOverride.get
else:
vmState.blockNumber.toFork
let gasUsed = 0 #tx.payload.intrinsicGas.GasInt + gasFees[fork][GasTXCreate]
let contractAddress = generateAddress(sender, tx.accountNonce)
let msg = newMessage(tx.gasLimit - gasUsed, tx.gasPrice, tx.to, sender, tx.value, data, tx.payload,
options = newMessageOptions(origin = sender, createAddress = contractAddress))
newBaseComputation(vmState, vmState.blockNumber, msg, some(fork))
proc initDatabase*(): (Uint256, BaseChainDB) =
let
node = json.parseFile(blockFile)
blockNumber = UInt256.fromHex(node["blockNumber"].getStr())
memoryDB = newMemoryDB()
state = node["state"]
for k, v in state:
let key = hexToSeqByte(k)
let value = hexToSeqByte(v.getStr())
memoryDB.put(key, value)
result = (blockNumber, newBaseChainDB(memoryDB, false))
proc initComputation(blockNumber: Uint256, chainDB: BaseChainDB, payload, data: seq[byte]): BaseComputation =
let
parentNumber = blockNumber - 1
parent = chainDB.getBlockHeader(parentNumber)
header = chainDB.getBlockHeader(blockNumber)
headerHash = header.blockHash
body = chainDB.getBlockBody(headerHash)
vmState = newBaseVMState(parent, chainDB)
var
tx = body.transactions[0]
sender = tracer.getSender(tx)
tx.payload = payload
tx.gasLimit = 500000000
initComputation(vmState, tx, sender, data, none(Fork))
proc runVM*(blockNumber: Uint256, chainDB: BaseChainDB, boa: Assembler): bool =
var computation = initComputation(blockNumber, chainDB, boa.code, boa.data)
let gas = computation.gasMeter.gasRemaining
let computationResult = execComputation(computation)
let gasUsed = gas - computation.gasMeter.gasRemaining
if computationResult:
if boa.success == false:
error "different success value", expected=boa.success, actual=true
return false
else:
if boa.success == true:
error "different success value", expected=boa.success, actual=false
return false
if boa.stack.len != computation.stack.values.len:
error "different stack len", expected=boa.stack.len, actual=computation.stack.values.len
return false
for i, v in computation.stack.values:
let actual = v.dumpHex()
let val = boa.stack[i].toHex()
if actual != val:
error "different stack value", idx=i, expected=val, actual=actual
return false
const chunkLen = 32
let numChunks = computation.memory.len div chunkLen
if numChunks != boa.memory.len:
error "different memory len", expected=boa.memory.len, actual=numChunks
return false
for i in 0 ..< numChunks:
let actual = computation.memory.bytes.toOpenArray(i * chunkLen, (i + 1) * chunkLen - 1).toHex()
let mem = boa.memory[i].toHex()
if mem != actual:
error "different memory value", idx=i, expected=mem, actual=actual
return false
var
stateDB = computation.vmState.accountDb
account = stateDB.getAccount(computation.msg.storageAddress)
trie = initSecureHexaryTrie(chainDB.db, account.storageRoot)
for kv in boa.storage:
let key = kv[0].toHex()
let val = kv[1].toHex()
let keyBytes = (@(kv[0])).toRange
let actual = trie.get(keyBytes).toOpenArray().toHex()
let zerosLen = 64 - (actual.len)
let value = repeat('0', zerosLen) & actual
if val != value:
error "storage has different value", key=key, expected=val, actual=value
return false
let logs = computation.vmState.logEntries
if logs.len != boa.logs.len:
error "different logs len", expected=boa.logs.len, actual=logs.len
return false
for i, log in boa.logs:
let eAddr = log.address.toHex()
let aAddr = logs[i].address.toHex()
if eAddr != aAddr:
error "different address", expected=eAddr, actual=aAddr, idx=i
return false
let eData = log.data.toHex()
let aData = logs[i].data.toHex()
if eData != aData:
error "different data", expected=eData, actual=aData, idx=i
return false
if log.topics.len != logs[i].topics.len:
error "different topics len", expected=log.topics.len, actual=logs[i].topics.len, idx=i
return false
for x, t in log.topics:
let eTopic = t.toHex()
let aTopic = logs[i].topics[x].toHex()
if eTopic != aTopic:
error "different topic in log entry", expected=eTopic, actual=aTopic, logIdx=i, topicIdx=x
return false
if boa.output.len > 0:
let actual = computation.output.toHex()
let expected = boa.output.toHex()
if expected != actual:
error "different output detected", expected=expected, actual=actual
return false
result = true
proc parseLog(node: NimNode): Log =
node.expectKind(nnkPar)
for item in node:
item.expectKind(nnkExprColonExpr)
let label = item[0].strVal
let body = item[1]
case label.normalize
of "address":
body.expectKind(nnkStrLit)
let value = body.strVal
if value.len < 20:
error("bad address format", body)
hexToByteArray(value, result.address)
of "topics":
body.expectKind(nnkBracket)
for x in body:
result.topics.add validateVMWord(x.strVal, x)
of "data":
result.data = hexToSeqByte(body.strVal)
else:error("unknown log section '" & label & "'", item[0])
proc parseLogs(list: NimNode): seq[Log] =
result = @[]
list.expectKind nnkStmtList
for n in list:
result.add parseLog(n)
macro assembler*(list: untyped): untyped =
var boa: Assembler
boa.success = true
list.expectKind nnkStmtList
for callSection in list:
callSection.expectKind(nnkCall)
let label = callSection[0].strVal
let body = callSection[1]
case label.normalize
of "title":
let title = body[0]
title.expectKind(nnkStrLit)
boa.title = title.strVal
of "code" : result = assemblerImpl(boa, body)
of "memory": boa.memory = parseVMWords(body)
of "stack" : boa.stack = parseVMWords(body)
of "storage": boa.storage = parseStorage(body)
of "logs": boa.logs = parseLogs(body)
of "success": boa.success = parseSuccess(body)
of "data": boa.data = parseData(body)
of "output": boa.output = parseData(body)
else: error("unknown section '" & label & "'", callSection[0])
g_asm = boa

343
tests/test_op_arith.nim Normal file
View File

@ -0,0 +1,343 @@
import macro_assembler, unittest
suite "Arithmetic Opcodes":
let (blockNumber, chainDB) = initDatabase()
assembler:
title: "ADD_1"
code:
PUSH1 "0x02"
PUSH1 "0x02"
ADD
stack: "0x04"
assembler:
title: "ADD_2"
code:
PUSH2 "0x1002"
PUSH1 "0x02"
ADD
stack: "0x1004"
assembler:
title: "ADD_3"
code:
PUSH2 "0x1002"
PUSH6 "0x123456789009"
ADD
stack: "0x12345678A00B"
assembler:
title: "ADD_4"
code:
PUSH2 "0x1234"
ADD
success: false
stack: "0x1234"
assembler:
title: "ADDMOD_1"
code:
PUSH1 "0x02"
PUSH1 "0x02"
PUSH1 "0x03"
ADDMOD
stack: "0x01"
assembler:
title: "ADDMOD_2"
code:
PUSH2 "0x1000"
PUSH1 "0x02"
PUSH2 "0x1002"
ADDMOD
PUSH1 "0x00"
stack:
"0x04"
"0x00"
assembler:
title: "ADDMOD_3"
code:
PUSH2 "0x1002"
PUSH6 "0x123456789009"
PUSH1 "0x02"
ADDMOD
stack: "0x093B"
assembler:
title: "ADDMOD_4"
code:
PUSH2 "0x1234"
ADDMOD
stack: "0x1234"
success: false
assembler:
title: "MUL_1"
code:
PUSH1 "0x03"
PUSH1 "0x02"
MUL
stack: "0x06"
assembler:
title: "MUL_2"
code:
PUSH3 "0x222222"
PUSH1 "0x03"
MUL
stack: "0x666666"
assembler:
title: "MUL_3"
code:
PUSH3 "0x222222"
PUSH3 "0x333333"
MUL
stack: "0x6D3A05F92C6"
assembler:
title: "MUL_4"
code:
PUSH1 "0x01"
MUL
stack: "0x01"
success: false
assembler: # MULMOD OP
title: "MULMOD_2"
code:
PUSH3 "0x222222"
PUSH1 "0x03"
PUSH1 "0x04"
MULMOD
stack: "0x000000000000000000000000000000000000000000000000000000000000000C"
assembler: # MULMOD OP
title: "MULMOD_3"
code:
PUSH3 "0x222222"
PUSH3 "0x333333"
PUSH3 "0x444444"
MULMOD
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # MULMOD OP mal
title: "MULMOD_4"
code:
PUSH1 "0x01"
MULMOD
success: false
stack: "0x01"
assembler: # DIV OP
title: "DIV_1"
code:
PUSH1 "0x02"
PUSH1 "0x04"
DIV
stack: "0x0000000000000000000000000000000000000000000000000000000000000002"
assembler: # DIV OP
title: "DIV_2"
code:
PUSH1 "0x33"
PUSH1 "0x99"
DIV
stack: "0x0000000000000000000000000000000000000000000000000000000000000003"
assembler: # DIV OP
title: "DIV_3"
code:
PUSH1 "0x22"
PUSH1 "0x99"
DIV
stack: "0x0000000000000000000000000000000000000000000000000000000000000004"
assembler: # DIV OP
title: "DIV_4"
code:
PUSH1 "0x15"
PUSH1 "0x99"
DIV
stack: "0x0000000000000000000000000000000000000000000000000000000000000007"
assembler: # DIV OP
title: "DIV_5"
code:
PUSH1 "0x04"
PUSH1 "0x07"
DIV
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # DIV OP
title: "DIV_6"
code:
PUSH1 "0x07"
DIV
success: false
stack: "0x07"
assembler: # SDIV OP
title: "SDIV_1"
code:
PUSH2 "0x03E8"
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC18"
SDIV
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SDIV OP
title: "SDIV_2"
code:
PUSH1 "0xFF"
PUSH1 "0xFF"
SDIV
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SDIV OP
title: "SDIV_3"
code:
PUSH1 "0x00"
PUSH1 "0xFF"
SDIV
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SDIV OP mal
title: "SDIV_4"
code:
PUSH1 "0xFF"
SDIV
success: false
stack: "0xFF"
assembler: # SUB OP
title: "SUB_1"
code:
PUSH1 "0x04"
PUSH1 "0x06"
SUB
stack: "0x0000000000000000000000000000000000000000000000000000000000000002"
assembler: # SUB OP
title: "SUB_2"
code:
PUSH2 "0x4444"
PUSH2 "0x6666"
SUB
stack: "0x0000000000000000000000000000000000000000000000000000000000002222"
assembler: # SUB OP
title: "SUB_3"
code:
PUSH2 "0x4444"
PUSH4 "0x99996666"
SUB
stack: "0x0000000000000000000000000000000000000000000000000000000099992222"
assembler: # SUB OP mal
title: "SUB_4"
code:
PUSH4 "0x99996666"
SUB
success: false
stack: "0x99996666"
assembler: # EXP OP
title: "EXP_1"
code:
PUSH1 "0x03"
PUSH1 "0x02"
EXP
stack: "0x0000000000000000000000000000000000000000000000000000000000000008"
#assertEquals(4, gas);
assembler: # EXP OP
title: "EXP_2"
code:
PUSH1 "0x00"
PUSH3 "0x123456"
EXP
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
#assertEquals(3, gas);
assembler: # EXP OP
title: "EXP_3"
code:
PUSH2 "0x1122"
PUSH1 "0x01"
EXP
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
#assertEquals(5, gas);
assembler: # EXP OP mal
title: "EXP_4"
code:
PUSH3 "0x123456"
EXP
success: false
stack: "0x123456"
assembler: # MOD OP
title: "MOD_1"
code:
PUSH1 "0x03"
PUSH1 "0x04"
MOD
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # MOD OP
title: "MOD_2"
code:
PUSH2 "0x012C"
PUSH2 "0x01F4"
MOD
stack: "0x00000000000000000000000000000000000000000000000000000000000000C8"
assembler: # MOD OP
title: "MOD_3"
code:
PUSH1 "0x04"
PUSH1 "0x02"
MOD
stack: "0x0000000000000000000000000000000000000000000000000000000000000002"
assembler: # MOD OP mal
title: "MOD_4"
code:
PUSH1 "0x04"
MOD
success: false
stack: "0x04"
assembler: # SMOD OP
title: "SMOD_1"
code:
PUSH1 "0x03"
PUSH1 "0x04"
SMOD
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SMOD OP
title: "SMOD_2"
code:
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE2" # -30
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" # -170
SMOD
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEC"
assembler: # SMOD OP
title: "SMOD_3"
code:
PUSH32 "0x000000000000000000000000000000000000000000000000000000000000001E" # 30
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" # -170
SMOD
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEC"
assembler: # SMOD OP mal
title: "SMOD_4"
code:
PUSH32 "0x000000000000000000000000000000000000000000000000000000000000001E" # 30
SMOD
success: false
stack: "0x000000000000000000000000000000000000000000000000000000000000001E"

654
tests/test_op_bit.nim Normal file
View File

@ -0,0 +1,654 @@
import macro_assembler, unittest
suite "Bitwise Opcodes":
let (blockNumber, chainDB) = initDatabase()
assembler: # AND OP
title: "AND_1"
code:
PUSH1 "0x0A"
PUSH1 "0x0A"
AND
stack: "0x000000000000000000000000000000000000000000000000000000000000000A"
assembler: # AND OP
title: "AND_2"
code:
PUSH1 "0xC0"
PUSH1 "0x0A"
AND
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # AND OP mal data
title: "AND_3"
code:
PUSH1 "0xC0"
AND
success: false
stack: "0xC0"
assembler: # OR OP
title: "OR_1"
code:
PUSH1 "0xF0"
PUSH1 "0x0F"
OR
stack: "0x00000000000000000000000000000000000000000000000000000000000000FF"
assembler: # OR OP
title: "OR_2"
code:
PUSH1 "0xC3"
PUSH1 "0x3C"
OR
stack: "0x00000000000000000000000000000000000000000000000000000000000000FF"
assembler: # OR OP mal data
title: "OR_3"
code:
PUSH1 "0xC0"
OR
success: false
stack: "0xC0"
assembler: # XOR OP
title: "XOR_1"
code:
PUSH1 "0xFF"
PUSH1 "0xFF"
XOR
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # XOR OP
title: "XOR_2"
code:
PUSH1 "0x0F"
PUSH1 "0xF0"
XOR
stack: "0x00000000000000000000000000000000000000000000000000000000000000FF"
assembler: # XOR OP mal data
title: "XOR_3"
code:
PUSH1 "0xC0"
XOR
success: false
stack: "0xC0"
assembler: # BYTE OP
title: "BYTE_1"
code:
PUSH6 "0xAABBCCDDEEFF"
PUSH1 "0x1E"
BYTE
stack: "0x00000000000000000000000000000000000000000000000000000000000000EE"
assembler: # BYTE OP
title: "BYTE_2"
code:
PUSH6 "0xAABBCCDDEEFF"
PUSH1 "0x20"
BYTE
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # BYTE OP
title: "BYTE_3"
code:
PUSH6 "0xAABBCCDDEE3A"
PUSH1 "0x1F"
BYTE
stack: "0x000000000000000000000000000000000000000000000000000000000000003A"
assembler: # BYTE OP mal data
title: "BYTE_4"
code:
PUSH6 "0xAABBCCDDEE3A"
BYTE
success: false
stack: "0xAABBCCDDEE3A"
#[
assembler: # SHL OP
title: "SHL_1"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000001"
PUSH1 "0x00"
SHL
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SHL OP
title: "SHL_2"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000001"
PUSH1 "0x01" SHL
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000002"
assembler: # SHL OP
title: "SHL_3"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000001"
PUSH1 "0xff"
SHL
fork: constantinople
stack: "0x8000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHL OP
title: "SHL_4"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000001"
PUSH2 "0x0100"
SHL
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHL OP
title: "SHL_5"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000001"
PUSH2 "0x0101"
SHL
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHL OP
title: "SHL_6"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0x00"
SHL
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SHL OP
title: "SHL_7"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0x01"
SHL
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE"
assembler: # SHL OP
title: "SHL_8"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0xff"
SHL
fork: constantinople
stack: "0x8000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHL OP
title: "SHL_9"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH2 "0x0100"
SHL
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHL OP
title: "SHL_10"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000000"
PUSH1 "0x01"
SHL
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHL OP
title: "SHL_11"
code:
PUSH32 "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0x01"
SHL
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE"
assembler: # SHR OP
title: "SHR_1"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000001"
PUSH1 "0x00"
SHR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SHR OP
title: "SHR_2"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000001"
PUSH1 "0x01"
SHR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHR OP
title: "SHR_3"
code:
PUSH32 "0x8000000000000000000000000000000000000000000000000000000000000000"
PUSH1 "0x01"
SHR
fork: constantinople
stack: "0x4000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHR OP
title: "SHR_4"
code:
PUSH32 "0x8000000000000000000000000000000000000000000000000000000000000000"
PUSH1 "0xff"
SHR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SHR OP
title: "SHR_5"
code:
PUSH32 "0x8000000000000000000000000000000000000000000000000000000000000000"
PUSH2 "0x0100"
SHR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHR OP
title: "SHR_6"
code:
PUSH32 "0x8000000000000000000000000000000000000000000000000000000000000000"
PUSH2 "0x0101"
SHR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHR OP
title: "SHR_7"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0x00"
SHR
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SHR OP
title: "SHR_8"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0x01"
SHR
fork: constantinople
stack: "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SHR OP
title: "SHR_9"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0xff"
SHR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SHR OP
title: "SHR_10"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH2 "0x0100"
SHR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SHR OP
title: "SHR_11"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000000"
PUSH1 "0x01"
SHR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SAR OP
title: "SAR_1"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000001"
PUSH1 "0x00"
SAR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SAR OP
title: "SAR_2"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000001"
PUSH1 "0x01"
SAR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SAR OP
title: "SAR_3"
code:
PUSH32 "0x8000000000000000000000000000000000000000000000000000000000000000"
PUSH1 "0x01"
SAR
fork: constantinople
stack: "0xC000000000000000000000000000000000000000000000000000000000000000"
assembler: # SAR OP
title: "SAR_4"
code:
PUSH32 "0x8000000000000000000000000000000000000000000000000000000000000000"
PUSH1 "0xff"
SAR
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SAR OP
title: "SAR_5"
code:
PUSH32 "0x8000000000000000000000000000000000000000000000000000000000000000"
PUSH2 "0x0100"
SAR
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SAR OP
title: "SAR_6"
code:
PUSH32 "0x8000000000000000000000000000000000000000000000000000000000000000"
PUSH2 "0x0101"
SAR
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SAR OP
title: "SAR_7"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0x00"
SAR
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SAR OP
title: "SAR_8"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0x01"
SAR
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SAR OP
title: "SAR_9"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0xff"
SAR
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SAR OP
title: "SAR_10"
code:
PUSH32 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH2 "0x0100"
SAR
fork: constantinople
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
assembler: # SAR OP
title: "SAR_11"
code:
PUSH32 "0x0000000000000000000000000000000000000000000000000000000000000000"
PUSH1 "0x01"
SAR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SAR OP
title: "SAR_12"
code:
PUSH32 "0x4000000000000000000000000000000000000000000000000000000000000000"
PUSH1 "0xfe"
SAR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SAR OP
title: "SAR_13"
code:
PUSH32 "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0xf8"
SAR
fork: constantinople
stack: "0x000000000000000000000000000000000000000000000000000000000000007F"
assembler: # SAR OP
title: "SAR_14"
code:
PUSH32 "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0xfe"
SAR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SAR OP
title: "SAR_15"
code:
PUSH32 "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH1 "0xff"
SAR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SAR OP
title: "SAR_16"
code:
PUSH32 "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
PUSH2 "0x0100"
SAR
fork: constantinople
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
]#
assembler: # ISZERO OP
title: "ISZERO_1"
code:
PUSH1 "0x00"
ISZERO
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # ISZERO OP
title: "ISZERO_2"
code:
PUSH1 "0x2A"
ISZERO
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # ISZERO OP mal data
title: "ISZERO_3"
code: ISZERO
success: false
assembler: # EQ OP
title: "EQ_1"
code:
PUSH1 "0x2A"
PUSH1 "0x2A"
EQ
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # EQ OP
title: "EQ_2"
code:
PUSH3 "0x2A3B4C"
PUSH3 "0x2A3B4C"
EQ
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # EQ OP
title: "EQ_3"
code:
PUSH3 "0x2A3B5C"
PUSH3 "0x2A3B4C"
EQ
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # EQ OP mal data
title: "EQ_4"
code:
PUSH3 "0x2A3B4C"
EQ
success: false
stack: "0x2A3B4C"
assembler: # GT OP
title: "GT_1"
code:
PUSH1 "0x01"
PUSH1 "0x02"
GT
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # GT OP
title: "GT_2"
code:
PUSH1 "0x01"
PUSH2 "0x0F00"
GT
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # GT OP
title: "GT_3"
code:
PUSH4 "0x01020304"
PUSH2 "0x0F00"
GT
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # GT OP mal data
title: "GT_4"
code:
PUSH3 "0x2A3B4C"
GT
success: false
stack: "0x2A3B4C"
assembler: # SGT OP
title: "SGT_1"
code:
PUSH1 "0x01"
PUSH1 "0x02"
SGT
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SGT OP
title: "SGT_2"
code:
PUSH32 "0x000000000000000000000000000000000000000000000000000000000000001E" # 30
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" # -170
SGT
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SGT OP
title: "SGT_3"
code:
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" # -170
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF57" # -169
SGT
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SGT OP mal
title: "SGT_4"
code:
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" # -170
SGT
success: false
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56"
assembler: # LT OP
title: "LT_1"
code:
PUSH1 "0x01"
PUSH1 "0x02"
LT
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # LT OP
title: "LT_2"
code:
PUSH1 "0x01"
PUSH2 "0x0F00"
LT
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # LT OP
title: "LT_3"
code:
PUSH4 "0x01020304"
PUSH2 "0x0F00"
LT
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # LT OP mal data
title: "LT_4"
code:
PUSH3 "0x2A3B4C"
LT
success: false
stack: "0x2A3B4C"
assembler: # SLT OP
title: "SLT_1"
code:
PUSH1 "0x01"
PUSH1 "0x02"
SLT
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SLT OP
title: "SLT_2"
code:
PUSH32 "0x000000000000000000000000000000000000000000000000000000000000001E" # 30
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" # -170
SLT
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # SLT OP
title: "SLT_3"
code:
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" # -170
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF57" # -169
SLT
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SLT OP mal
title: "SLT_4"
code:
PUSH32 "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56" # -170
SLT
success: false
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF56"
assembler: # NOT OP
title: "NOT_1"
code:
PUSH1 "0x01"
NOT
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE"
assembler: # NOT OP
title: "NOT_2"
code:
PUSH2 "0xA003"
NOT
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5FFC"
assembler: # BNOT OP
title: "BNOT_4"
code: NOT
success: false
assembler: # NOT OP
title: "NOT_5"
code:
PUSH1 "0x00"
NOT
stack: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

306
tests/test_op_custom.nim Normal file
View File

@ -0,0 +1,306 @@
import
macro_assembler, unittest, macros, strutils,
byteutils, eth_common, ../nimbus/db/state_db,
../nimbus/db/db_chain, ranges
suite "Custom Opcodes Test":
let (blockNumber, chainDB) = initDatabase()
var acc: EthAddress
hexToByteArray("0xc669eaad75042be84daaf9b461b0e868b9ac1871", acc)
var
parent = chainDB.getBlockHeader(blockNumber - 1)
stateDB = newAccountStateDB(chainDB.db, parent.stateRoot, false)
stateDB.setBalance(acc, 1000.u256)
parent.stateRoot = stateDB.rootHash
chainDB.setHead(parent, true)
assembler: # CALLDATASIZE OP
title: "CALLDATASIZE_1"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
CallDataSize
stack: "0x0000000000000000000000000000000000000000000000000000000000000040"
assembler: # CALLDATALOAD OP
title: "CALLDATALOAD_1"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x00"
CallDataLoad
stack: "0x00000000000000000000000000000000000000000000000000000000000000A1"
assembler: # CALLDATALOAD OP
title: "CALLDATALOAD_2"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x02"
CallDataLoad
stack: "0x0000000000000000000000000000000000000000000000000000000000A10000"
assembler: # CALLDATALOAD OP
title: "CALLDATALOAD_3"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x20"
CallDataLoad
stack: "0x00000000000000000000000000000000000000000000000000000000000000B1"
assembler: # CALLDATALOAD OP
title: "CALLDATALOAD_4"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x23"
CallDataLoad
stack: "0x00000000000000000000000000000000000000000000000000000000B1000000"
assembler: # CALLDATALOAD OP
title: "CALLDATALOAD_5"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x3F"
CallDataLoad
stack: "0xB100000000000000000000000000000000000000000000000000000000000000"
assembler: # CALLDATALOAD OP mal
title: "CALLDATALOAD_6"
code:
CallDataLoad
success: false
assembler: # CALLDATACOPY OP
title: "CALLDATACOPY_1"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x20"
Push1 "0x00"
Push1 "0x00"
CallDataCopy
memory: "0x00000000000000000000000000000000000000000000000000000000000000A1"
assembler: # CALLDATACOPY OP
title: "CALLDATACOPY_2"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x40"
Push1 "0x00"
Push1 "0x00"
CallDataCopy
memory:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
assembler: # CALLDATACOPY OP
title: "CALLDATACOPY_3"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x40"
Push1 "0x04"
Push1 "0x00"
CallDataCopy
memory:
"0x000000000000000000000000000000000000000000000000000000A100000000"
"0x000000000000000000000000000000000000000000000000000000B100000000"
assembler: # CALLDATACOPY OP
title: "CALLDATACOPY_4"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x40"
Push1 "0x00"
Push1 "0x04"
CallDataCopy
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x000000A100000000000000000000000000000000000000000000000000000000"
"0x000000B100000000000000000000000000000000000000000000000000000000"
assembler: # CALLDATACOPY OP
title: "CALLDATACOPY_5"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x40"
Push1 "0x00"
Push1 "0x04"
CallDataCopy
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x000000A100000000000000000000000000000000000000000000000000000000"
"0x000000B100000000000000000000000000000000000000000000000000000000"
assembler: # CALLDATACOPY OP mal
title: "CALLDATACOPY_6"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code:
Push1 "0x40"
Push1 "0x00"
CallDataCopy
success: false
stack:
"0x40"
"0x00"
assembler: # CALLDATACOPY OP mal
title: "CALLDATACOPY_7"
data:
"0x00000000000000000000000000000000000000000000000000000000000000A1"
"0x00000000000000000000000000000000000000000000000000000000000000B1"
code: "0x6020600073CC0929EB16730E7C14FEFC63006AC2D794C5795637"
success: false
assembler: # ADDRESS OP
title: "ADDRESS_1"
code:
Address
stack: "0x000000000000000000000000c669eaad75042be84daaf9b461b0e868b9ac1871"
assembler: # BALANCE OP
title: "BALANCE_1"
code:
Address
Balance
stack: "0x00000000000000000000000000000000000000000000000000000000000003E8"
assembler: # ORIGIN OP
title: "ORIGIN_1"
code:
Origin
stack: "0x000000000000000000000000fbe0afcd7658ba86be41922059dd879c192d4c73"
assembler: # CALLER OP
title: "CALLER_1"
code:
Caller
stack: "0x000000000000000000000000fbe0afcd7658ba86be41922059dd879c192d4c73"
assembler: # CALLVALUE OP
title: "CALLVALUE_1"
code:
CallValue
stack: "0xcff56a1b273a8000"
assembler: # SHA3 OP
title: "SHA3_1"
code:
Push1 "0x01"
Push1 "0x00"
Mstore8
Push1 "0x01"
Push1 "0x00"
Sha3
stack: "0x5FE7F977E71DBA2EA1A68E21057BEEBB9BE2AC30C6410AA38D4F3FBE41DCFFD2"
memory: "0x0100000000000000000000000000000000000000000000000000000000000000"
assembler: # SHA3 OP
title: "SHA3_2"
code:
Push2 "0x0201"
Push1 "0x00"
Mstore
Push1 "0x02"
Push1 "0x1E"
Sha3
stack: "0x114A3FE82A0219FCC31ABD15617966A125F12B0FD3409105FC83B487A9D82DE4"
memory: "0x0000000000000000000000000000000000000000000000000000000000000201"
assembler: # SHA3 OP mal
title: "SHA3_3"
code:
Push2 "0x0201"
Push1 "0x00"
Mstore
Push1 "0x02"
Sha3
success: false
stack: "0x02"
memory: "0x0000000000000000000000000000000000000000000000000000000000000201"
#[
assembler: # BLOCKHASH OP
title: "BLOCKHASH_1"
code:
Push1 "0x01"
Blockhash
stack: "0xC89EFDAA54C0F20C7ADF612882DF0950F5A951637E0307CDCB4C672F298B8BC6"
]#
# current coinbase or parent coinbase?
assembler: # COINBASE OP
title: "COINBASE_1"
code:
Coinbase
stack: "0x000000000000000000000000c0ede9a639d107851462c15f2fb729c7c61bbf62"
# current timestamp or parent timestamp?
assembler: # TIMESTAMP OP
title: "TIMESTAMP_1"
code:
TimeStamp
stack: "0x0000000000000000000000000000000000000000000000000000000055c46bb3"
# current number or parent number?
assembler: # NUMBER OP
title: "NUMBER_1"
code:
Number
stack: "0x000000000000000000000000000000000000000000000000000000000000b864"
# current difficulty or parent dificulty?
assembler: # DIFFICULTY OP
title: "DIFFICULTY_1"
code:
Difficulty
stack: "0x0000000000000000000000000000000000000000000000000000015451e94505"
# ??
assembler: # GASPRICE OP
title: "GASPRICE_1"
code:
GasPrice
stack: "0x000000000000000000000000000000000000000000000000000000746a528800"
# ??
assembler: # GAS OP
title: "GAS_1"
code:
Gas
stack: "0x000000000000000000000000000000000000000000000000000000001dcd64fe"
# ??
assembler: # GASLIMIT OP
title: "GASLIMIT_1"
code:
GasLimit
stack: "0x000000000000000000000000000000000000000000000000000000000000a271"
assembler: # INVALID OP
title: "INVALID_1"
code: "0x60012F6002"
stack: "0x0000000000000000000000000000000000000000000000000000000000000001"
success: false

306
tests/test_op_env.nim Normal file
View File

@ -0,0 +1,306 @@
import
macro_assembler, unittest, macros, strutils,
byteutils, eth_common, ../nimbus/db/state_db,
../nimbus/db/db_chain, ranges
suite "Environmental Information Opcodes":
let (blockNumber, chainDB) = initDatabase()
assembler: # CODECOPY OP
title: "CODECOPY_1"
code:
PUSH1 "0x03" # size
PUSH1 "0x08" # copy start pos
PUSH1 "0x00" # mem start pos
CODECOPY
STOP
SLT
CALLVALUE
JUMP
memory: "0x1234560000000000000000000000000000000000000000000000000000000000"
# assertEquals(6, gas); ??
assembler: # CODECOPY OP
title: "CODECOPY_2"
code:
PUSH1 "0x5E" # size
PUSH1 "0x08" # copy start pos
PUSH1 "0x00" # mem start pos
CODECOPY
STOP
PUSH1 "0x00"
PUSH1 "0x5f"
SSTORE
PUSH1 "0x14"
PUSH1 "0x00"
SLOAD
PUSH1 "0x1e"
PUSH1 "0x20"
SLOAD
PUSH4 "0xabcddcba"
PUSH1 "0x40"
SLOAD
JUMPDEST
MLOAD
PUSH1 "0x20"
ADD
PUSH1 "0x0a"
MSTORE
SLOAD
MLOAD
PUSH1 "0x40"
ADD
PUSH1 "0x14"
MSTORE
SLOAD
MLOAD
PUSH1 "0x60"
ADD
PUSH1 "0x1e"
MSTORE
SLOAD
MLOAD
PUSH1 "0x80"
ADD
PUSH1 "0x28"
MSTORE
SLOAD
PUSH1 "0xa0"
MSTORE
SLOAD
PUSH1 "0x16"
PUSH1 "0x48"
PUSH1 "0x00"
CODECOPY
PUSH1 "0x16"
PUSH1 "0x00"
CALLCODE
PUSH1 "0x00"
PUSH1 "0x3f"
SSTORE
PUSH2 "0x03e7"
JUMP
PUSH1 "0x00"
SLOAD
PUSH1 "0x00"
MSTORE8
PUSH1 "0x20"
MUL
CALLDATALOAD
PUSH1 "0x20"
SLOAD
memory:
"0x6000605F556014600054601E60205463ABCDDCBA6040545B51602001600A5254"
"0x516040016014525451606001601E5254516080016028525460A0525460166048"
"0x60003960166000F26000603F556103E756600054600053602002356020540000"
#assertEquals(10, gas); ??
assembler: # CODECOPY OP
title: "CODECOPY_3"
# cost for that:
# 94 - data copied
# 95 - new bytes allocated
code:
Push1 "0x5E"
Push1 "0x08"
Push1 "0x00"
CodeCopy
STOP
"0x6000605f556014600054601e60205463abcddcba6040545b"
"0x51602001600a5254516040016014525451606001601e52545160800160285254"
"0x60a052546016604860003960166000f26000603f556103e75660005460005360"
"0x20023500"
memory:
"0x6000605F556014600054601E60205463ABCDDCBA6040545B51602001600A5254"
"0x516040016014525451606001601E5254516080016028525460A0525460166048"
"0x60003960166000F26000603F556103E756600054600053602002350000000000"
#assertEquals(10, program.getResult().getGasUsed());
assembler: # CODECOPY OP
title: "CODECOPY_4"
code:
Push1 "0x5E"
Push1 "0x07"
Push1 "0x00"
CodeCopy
STOP
"0x6000605f556014600054601e60205463abcddcba6040545b51"
"0x602001600a5254516040016014525451606001601e5254516080016028525460"
"0xa052546016604860003960166000f26000603f556103e756600054600053602002351234"
memory:
"0x006000605F556014600054601E60205463ABCDDCBA6040545B51602001600A52"
"0x54516040016014525451606001601E5254516080016028525460A05254601660"
"0x4860003960166000F26000603F556103E7566000546000536020023512340000"
#assertEquals(10, program.getResult().getGasUsed());
assembler: # CODECOPY OP
title: "CODECOPY_5"
code:
Push2 "0x1234"
Push1 "0x00"
Sload
Push2 "0x5566"
Push1 "0x20"
Sload
Push1 "0x70"
Push1 "0x00"
Push1 "0x20"
CodeCopy
STOP
"0x6000605f55601460"
"0x0054601e60205463abcddcba6040545b51602001600a525451604001"
"0x6014525451606001601e5254516080016028525460a0525460166048"
"0x60003960166000f26000603f556103e75660005460005360200235123400"
stack:
"0x1234"
"0x00"
"0x5566"
"0x00"
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x61123460005461556660205460706000602039006000605f556014600054601e"
"0x60205463abcddcba6040545b51602001600a5254516040016014525451606001"
"0x601e5254516080016028525460a052546016604860003960166000f26000603f"
"0x556103e756600054600053602002351200000000000000000000000000000000"
assembler: # CODECOPY OP mal
title: "CODECOPY_6"
code:
"0x605E6007396000605f556014600054601e60205463abcddcba604054"
"0x5b51602001600a5254516040016014525451606001601e5254516080"
"0x016028525460a052546016604860003960166000f26000603f556103"
"0xe756600054600053602002351234"
success: false
stack:
"0x5e"
"0x07"
var acc: EthAddress
hexToByteArray("0xfbe0afcd7658ba86be41922059dd879c192d4c73", acc)
var
parent = chainDB.getBlockHeader(blockNumber - 1)
stateDB = newAccountStateDB(chainDB.db, parent.stateRoot, false)
code = hexToSeqByte("0x0102030405060708090A0B0C0D0E0F" &
"611234600054615566602054603E6000602073471FD3AD3E9EEADEEC4608B92D" &
"16CE6B500704CC3C6000605f556014600054601e60205463abcddcba6040545b" &
"51602001600a5254516040016014525451606001601e52545160800160285254" &
"60a052546016604860003960166000f26000603f556103e756600054600053602002351234")
stateDB.setCode(acc, code.toRange)
parent.stateRoot = stateDB.rootHash
chainDB.setHead(parent, true)
assembler: # EXTCODECOPY OP
title: "EXTCODECOPY_1"
code:
Push1 "0x04" # size
Push1 "0x07" # code pos
Push1 "0x00" # mem pos
Push20 "0xfbe0afcd7658ba86be41922059dd879c192d4c73"
ExtCodeCopy
STOP
Slt
CallValue
Jump
Stop
memory: "0x08090a0b00000000000000000000000000000000000000000000000000000000"
assembler: # EXTCODECOPY OP
title: "EXTCODECOPY_2"
code:
Push1 "0x3E"
Push1 "0x07"
Push1 "0x00"
Push20 "0xfbe0afcd7658ba86be41922059dd879c192d4c73"
ExtCodeCopy
STOP
"0x6000605f"
"0x556014600054601e60205463abcddcba6040545b51602001600a525451604001"
"0x6014525451606001601e5254516080016028525460a052546016604860003960"
"0x166000f26000603f556103e75660005460005360200235602054"
memory:
"0x08090a0b0c0d0e0f611234600054615566602054603e6000602073471fd3ad3e"
"0x9eeadeec4608b92d16ce6b500704cc3c6000605f556014600054601e60200000"
assembler: # EXTCODECOPY OP
title: "EXTCODECOPY_3"
code:
Push1 "0x5E"
Push1 "0x07"
Push1 "0x00"
Push20 "0xfbe0afcd7658ba86be41922059dd879c192d4c73"
ExtCodeCopy
STOP
"0x6000605f"
"0x556014600054601e60205463abcddcba6040545b51602001600a525451604001"
"0x6014525451606001601e5254516080016028525460a052546016604860003960"
"0x166000f26000603f556103e75660005460005360200235"
memory:
"0x08090a0b0c0d0e0f611234600054615566602054603e6000602073471fd3ad3e"
"0x9eeadeec4608b92d16ce6b500704cc3c6000605f556014600054601e60205463"
"0xabcddcba6040545b51602001600a5254516040016014525451606001601e0000"
assembler: # EXTCODECOPY OP
title: "EXTCODECOPY_4"
code:
Push2 "0x1234"
Push1 "0x00"
Sload
Push2 "0x5566"
Push1 "0x20"
Sload
Push1 "0x3E"
Push1 "0x00"
Push1 "0x20"
Push20 "0xfbe0afcd7658ba86be41922059dd879c192d4c73"
ExtCodeCopy
STOP
"0x6000605f556014600054601e60205463abcddcba6040545b"
"0x51602001600a5254516040016014525451606001601e52545160800160285254"
"0x60a052546016604860003960166000f26000603f556103e756600054600053602002351234"
stack:
"0x1234"
"0x00"
"0x5566"
"0x00"
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0102030405060708090a0b0c0d0e0f611234600054615566602054603e600060"
"0x2073471fd3ad3e9eeadeec4608b92d16ce6b500704cc3c6000605f5560140000"
assembler: # EXTCODECOPY OP mal
title: "EXTCODECOPY_5"
code:
Push1 "0x5E"
Push1 "0x07"
Push20 "0x471FD3AD3E9EEADEEC4608B92D16CE6B500704CC"
ExtCodeCopy
success: false
stack:
"0x5E"
"0x07"
# macro_assembler automatically insert STOP instruction at the end,
# so codesize become 63, not 62 like ethereumj
assembler: # CODESIZE OP
title: "CODESIZE_1"
code:
"0x385E60076000396000605f556014600054601e60205463abcddcba6040545b51"
"0x602001600a5254516040016014525451606001601e5254516080016028525460"
"0xa052546016604860003960166000f26000603f556103e75660005460005360200235"
stack:
"0x0000000000000000000000000000000000000000000000000000000000000063"
success: false
# 0x94 == 148 bytes
assembler: # EXTCODESIZE OP
title: "EXTCODESIZE_1"
code:
Push20 "0xfbe0afcd7658ba86be41922059dd879c192d4c73"
ExtCodeSize
STOP
"0x5E60076000396000605f"
"0x556014600054601e60205463abcddcba6040545b51602001600a525451604001"
"0x6014525451606001601e5254516080016028525460a052546016604860003960"
"0x166000f26000603f556103e75660005460005360200235"
stack: "0x94"

840
tests/test_op_memory.nim Normal file
View File

@ -0,0 +1,840 @@
import macro_assembler, unittest, macros, strutils
suite "Memory Opcodes":
let (blockNumber, chainDB) = initDatabase()
assembler: # PUSH1 OP
title: "PUSH1"
code:
PUSH1 "0xa0"
stack: "0x00000000000000000000000000000000000000000000000000000000000000A0"
assembler: # PUSH2 OP
title: "PUSH2"
code:
PUSH2 "0xa0b0"
stack: "0x000000000000000000000000000000000000000000000000000000000000A0B0"
assembler: # PUSH3 OP
title: "PUSH3"
code:
PUSH3 "0xA0B0C0"
stack: "0x0000000000000000000000000000000000000000000000000000000000A0B0C0"
assembler: # PUSH4 OP
title: "PUSH4"
code:
PUSH4 "0xA0B0C0D0"
stack: "0x00000000000000000000000000000000000000000000000000000000A0B0C0D0"
assembler: # PUSH5 OP
title: "PUSH5"
code:
PUSH5 "0xA0B0C0D0E0"
stack: "0x000000000000000000000000000000000000000000000000000000A0B0C0D0E0"
assembler: # PUSH6 OP
title: "PUSH6"
code:
PUSH6 "0xA0B0C0D0E0F0"
stack: "0x0000000000000000000000000000000000000000000000000000A0B0C0D0E0F0"
assembler: # PUSH7 OP
title: "PUSH7"
code:
PUSH7 "0xA0B0C0D0E0F0A1"
stack: "0x00000000000000000000000000000000000000000000000000A0B0C0D0E0F0A1"
assembler: # PUSH8 OP
title: "PUSH8"
code:
PUSH8 "0xA0B0C0D0E0F0A1B1"
stack: "0x000000000000000000000000000000000000000000000000A0B0C0D0E0F0A1B1"
assembler: # PUSH9 OP
title: "PUSH9"
code:
PUSH9 "0xA0B0C0D0E0F0A1B1C1"
stack: "0x0000000000000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1"
assembler: # PUSH10 OP
title: "PUSH10"
code:
PUSH10 "0xA0B0C0D0E0F0A1B1C1D1"
stack: "0x00000000000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1"
assembler: # PUSH11 OP
title: "PUSH11"
code:
PUSH11 "0xA0B0C0D0E0F0A1B1C1D1E1"
stack: "0x000000000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1"
assembler: # PUSH12 OP
title: "PUSH12"
code:
PUSH12 "0xA0B0C0D0E0F0A1B1C1D1E1F1"
stack: "0x0000000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1"
assembler: # PUSH13 OP
title: "PUSH13"
code:
PUSH13 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2"
stack: "0x00000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2"
assembler: # PUSH14 OP
title: "PUSH14"
code:
PUSH14 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2"
stack: "0x000000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2"
assembler: # PUSH15 OP
title: "PUSH15"
code:
PUSH15 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2"
stack: "0x0000000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2"
assembler: # PUSH16 OP
title: "PUSH16"
code:
PUSH16 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2"
stack: "0x00000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2"
assembler: # PUSH17 OP
title: "PUSH17"
code:
PUSH17 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2"
stack: "0x000000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2"
assembler: # PUSH18 OP
title: "PUSH18"
code:
PUSH18 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2"
stack: "0x0000000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2"
assembler: # PUSH19 OP
title: "PUSH19"
code:
PUSH19 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3"
stack: "0x00000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3"
assembler: # PUSH20 OP
title: "PUSH20"
code:
PUSH20 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3"
stack: "0x000000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3"
assembler: # PUSH21 OP
title: "PUSH21"
code:
PUSH21 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3"
stack: "0x0000000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3"
assembler: # PUSH22 OP
title: "PUSH22"
code:
PUSH22 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3"
stack: "0x00000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3"
assembler: # PUSH23 OP
title: "PUSH23"
code:
PUSH23 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3"
stack: "0x000000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3"
assembler: # PUSH24 OP
title: "PUSH24"
code:
PUSH24 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3"
stack: "0x0000000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3"
assembler: # PUSH25 OP
title: "PUSH25"
code:
PUSH25 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4"
stack: "0x00000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4"
assembler: # PUSH26 OP
title: "PUSH26"
code:
PUSH26 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4"
stack: "0x000000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4"
assembler: # PUSH27 OP
title: "PUSH27"
code:
PUSH27 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4"
stack: "0x0000000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4"
assembler: # PUSH28 OP
title: "PUSH28"
code:
PUSH28 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4"
stack: "0x00000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4"
assembler: # PUSH29 OP
title: "PUSH29"
code:
PUSH29 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4"
stack: "0x000000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4"
assembler: # PUSH30 OP
title: "PUSH30"
code:
PUSH30 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4"
stack: "0x0000A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4"
assembler: # PUSH31 OP
title: "PUSH31"
code:
PUSH31 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1"
stack: "0x00A0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1"
assembler: # PUSH32 OP
title: "PUSH32"
code:
PUSH32 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1B1"
stack: "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1B1"
# macro assembler prevented this
#assembler: # PUSHN OP not enough data
# title: "PUSHN_1"
# code:
# PUSH2 "0xAA"
# stack: "0x000000000000000000000000000000000000000000000000000000000000AA00"
# success: false
#
#assembler: # PUSHN OP not enough data
# title: "PUSHN_2"
# code:
# PUSH32 "0xAABB"
# stack: "0xAABB000000000000000000000000000000000000000000000000000000000000"
# success: false
assembler: # POP OP
title: "POP_1"
code:
PUSH2 "0x0000"
PUSH1 "0x01"
PUSH3 "0x000002"
POP
stack:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000000001"
assembler: # POP OP
title: "POP_2"
code:
PUSH2 "0x0000"
PUSH1 "0x01"
PUSH3 "0x000002"
POP
POP
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler:# POP OP mal data
title: "POP_3"
code:
PUSH2 "0x0000"
PUSH1 "0x01"
PUSH3 "0x000002"
POP
POP
POP
POP
success: false
macro generateDUPS(): untyped =
result = newStmtList()
for i in 1 .. 16:
let title = newStmtList(newLit("DUP_" & $i))
let pushIdent = ident("PUSH1")
var body = newStmtList()
var stack = newStmtList()
for x in 0 ..< i:
let val = newLit("0x" & toHex(x+10, 2))
body.add quote do:
`pushIdent` `val`
stack.add quote do:
`val`
let stackVal = newLit("0x" & toHex(10, 2))
stack.add quote do:
`stackVal`
let dupIdent = ident("DUP" & $i)
body.add quote do:
`dupIdent`
let titleCall = newCall(ident("title"), title)
let codeCall = newCall(ident("code"), body)
let stackCall = newCall(ident("stack"), stack)
result.add quote do:
assembler:
`titleCall`
`codeCall`
`stackCall`
generateDUPS()
assembler: # DUPN OP mal data
title: "DUPN_2"
code:
DUP1
success: false
macro generateSWAPS(): untyped =
result = newStmtList()
for i in 1 .. 16:
let title = newStmtList(newLit("SWAP_" & $i))
let pushIdent = ident("PUSH1")
var body = newStmtList()
var stack = newStmtList()
for x in countDown(i, 0):
let val = newLit("0x" & toHex(x+10, 2))
body.add quote do:
`pushIdent` `val`
if x == i:
let val = newLit("0x" & toHex(0+10, 2))
stack.add quote do:
`val`
elif x == 0:
let val = newLit("0x" & toHex(i+10, 2))
stack.add quote do:
`val`
else:
stack.add quote do:
`val`
let swapIdent = ident("SWAP" & $i)
body.add quote do:
`swapIdent`
let titleCall = newCall(ident("title"), title)
let codeCall = newCall(ident("code"), body)
let stackCall = newCall(ident("stack"), stack)
result.add quote do:
assembler:
`titleCall`
`codeCall`
`stackCall`
generateSWAPS()
assembler:# SWAPN OP mal data
title: "SWAPN_2"
code:
SWAP1
success: false
assembler: # MSTORE OP
title: "MSTORE_1"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
memory: "0x0000000000000000000000000000000000000000000000000000000000001234"
assembler: # MSTORE OP
title: "MSTORE_2"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
PUSH2 "0x5566"
PUSH1 "0x20"
MSTORE
memory:
"0x0000000000000000000000000000000000000000000000000000000000001234"
"0x0000000000000000000000000000000000000000000000000000000000005566"
assembler: # MSTORE OP
title: "MSTORE_3"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
PUSH2 "0x5566"
PUSH1 "0x20"
MSTORE
PUSH2 "0x8888"
PUSH1 "0x00"
MSTORE
memory:
"0x0000000000000000000000000000000000000000000000000000000000008888"
"0x0000000000000000000000000000000000000000000000000000000000005566"
assembler: # MSTORE OP
title: "MSTORE_4"
code:
PUSH2 "0x1234"
PUSH1 "0xA0"
MSTORE
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000001234"
assembler: # MSTORE OP
title: "MSTORE_5"
code:
PUSH2 "0x1234"
MSTORE
success: false
stack: "0x1234"
assembler: # MLOAD OP
title: "MLOAD_1"
code:
PUSH1 "0x00"
MLOAD
memory: "0x0000000000000000000000000000000000000000000000000000000000000000"
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # MLOAD OP
title: "MLOAD_2"
code:
PUSH1 "0x22"
MLOAD
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000000000"
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # MLOAD OP
title: "MLOAD_3"
code:
PUSH1 "0x20"
MLOAD
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000000000"
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # MLOAD OP
title: "MLOAD_4"
code:
PUSH2 "0x1234"
PUSH1 "0x20"
MSTORE
PUSH1 "0x20"
MLOAD
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000001234"
stack: "0x0000000000000000000000000000000000000000000000000000000000001234"
assembler: # MLOAD OP
title: "MLOAD_5"
code:
PUSH2 "0x1234"
PUSH1 "0x20"
MSTORE
PUSH1 "0x1F"
MLOAD
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0000000000000000000000000000000000000000000000000000000000001234"
stack: "0x0000000000000000000000000000000000000000000000000000000000000012"
assembler: # MLOAD OP mal data
title: "MLOAD_6"
code:
MLOAD
success: false
assembler: # MSTORE8 OP
title: "MSTORE8_1"
code:
PUSH1 "0x11"
PUSH1 "0x00"
MSTORE8
memory: "0x1100000000000000000000000000000000000000000000000000000000000000"
assembler: # MSTORE8 OP
title: "MSTORE8_2"
code:
PUSH1 "0x22"
PUSH1 "0x01"
MSTORE8
memory: "0x0022000000000000000000000000000000000000000000000000000000000000"
assembler: # MSTORE8 OP
title: "MSTORE8_3"
code:
PUSH1 "0x22"
PUSH1 "0x21"
MSTORE8
memory:
"0x0000000000000000000000000000000000000000000000000000000000000000"
"0x0022000000000000000000000000000000000000000000000000000000000000"
assembler: # MSTORE8 OP mal
title: "MSTORE8_4"
code:
PUSH1 "0x22"
MSTORE8
success: false
stack: "0x22"
assembler: # SSTORE OP
title: "SSTORE_1"
code:
PUSH1 "0x22"
PUSH1 "0xAA"
SSTORE
storage:
"0xAA": "0x22"
assembler: # SSTORE OP
title: "SSTORE_2"
code:
PUSH1 "0x22"
PUSH1 "0xAA"
SSTORE
PUSH1 "0x22"
PUSH1 "0xBB"
SSTORE
storage:
"0xAA": "0x22"
"0xBB": "0x22"
assembler: # SSTORE OP
title: "SSTORE_3"
code:
PUSH1 "0x22"
SSTORE
success: false
stack: "0x22"
#[
assembler: # SSTORE EIP1283
title: "SSTORE_NET_1"
code: "60006000556000600055"
fork: constantinople
# assertEquals(412, program.getResult().getGasUsed())
# assertEquals(0, program.getResult().getFutureRefund())
assembler: # SSTORE EIP1283
title: "SSTORE_NET_2"
code: "60006000556001600055"
fork: constantinople
# assertEquals(20212, program.getResult().getGasUsed())
# assertEquals(0, program.getResult().getFutureRefund())
assembler: # SSTORE EIP1283
title: "SSTORE_NET_3"
code: "60016000556000600055"
fork: constantinople
# assertEquals(20212, program.getResult().getGasUsed())
# assertEquals(19800, program.getResult().getFutureRefund())
assembler: # SSTORE EIP1283
title: "SSTORE_NET_4"
code: "60016000556002600055"
fork: constantinople
# assertEquals(20212, program.getResult().getGasUsed())
# assertEquals(0, program.getResult().getFutureRefund())
assembler: # SSTORE EIP1283
title: "SSTORE_NET_5"
code: "60016000556001600055"
fork: constantinople
# assertEquals(20212, program.getResult().getGasUsed())
# assertEquals(0, program.getResult().getFutureRefund())
# Sets Storage row on "cow" address:
# 0: 1
# private void setStorageToOne(VM vm) {
# # Sets storage value to 1 and commits
# code: "60006000556001600055"
# fork: constantinople
# invoke.getRepository().commit()
# invoke.setOrigRepository(invoke.getRepository())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_6"
code: "60006000556000600055"
fork: constantinople
# assertEquals(5212, program.getResult().getGasUsed())
# assertEquals(15000, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_7"
code: "60006000556001600055"
fork: constantinople
# assertEquals(5212, program.getResult().getGasUsed())
# assertEquals(4800, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_8"
code: "60006000556002600055"
fork: constantinople
# assertEquals(5212, program.getResult().getGasUsed())
# assertEquals(0, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_9"
code: "60026000556000600055"
fork: constantinople
# assertEquals(5212, program.getResult().getGasUsed())
# assertEquals(15000, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_10"
code: "60026000556003600055"
fork: constantinople
# assertEquals(5212, program.getResult().getGasUsed())
# assertEquals(0, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_11"
code: "60026000556001600055"
fork: constantinople
# assertEquals(5212, program.getResult().getGasUsed())
# assertEquals(4800, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_12"
code: "60026000556002600055"
fork: constantinople
# assertEquals(5212, program.getResult().getGasUsed())
# assertEquals(0, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_13"
code: "60016000556000600055"
fork: constantinople
# assertEquals(5212, program.getResult().getGasUsed())
# assertEquals(15000, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_14"
code: "60016000556002600055"
fork: constantinople
# assertEquals(5212, program.getResult().getGasUsed())
# assertEquals(0, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_15"
code: "60016000556001600055"
fork: constantinople
# assertEquals(412, program.getResult().getGasUsed())
# assertEquals(0, program.getResult().getFutureRefund())
assembler: # SSTORE EIP1283
title: "SSTORE_NET_16"
code: "600160005560006000556001600055"
fork: constantinople
# assertEquals(40218, program.getResult().getGasUsed())
# assertEquals(19800, program.getResult().getFutureRefund())
setStorageToOne(vm)
assembler: # SSTORE EIP1283
title: "SSTORE_NET_17"
code: "600060005560016000556000600055"
fork: constantinople
# assertEquals(10218, program.getResult().getGasUsed())
# assertEquals(19800, program.getResult().getFutureRefund())
]#
assembler: # SLOAD OP
title: "SLOAD_1"
code:
PUSH1 "0xAA"
SLOAD
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # SLOAD OP
title: "SLOAD_2"
code:
PUSH1 "0x22"
PUSH1 "0xAA"
SSTORE
PUSH1 "0xAA"
SLOAD
stack: "0x0000000000000000000000000000000000000000000000000000000000000022"
assembler: # SLOAD OP
title: "SLOAD_3"
code:
PUSH1 "0x22"
PUSH1 "0xAA"
SSTORE
PUSH1 "0x33"
PUSH1 "0xCC"
SSTORE
PUSH1 "0xCC"
SLOAD
stack: "0x0000000000000000000000000000000000000000000000000000000000000033"
assembler: # SLOAD OP
title: "SLOAD_4"
code: SLOAD
success: false
assembler: # PC OP
title: "PC_1"
code: PC
stack:
"0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # PC OP
title: "PC_2"
code:
PUSH1 "0x22"
PUSH1 "0xAA"
MSTORE
PUSH1 "0xAA"
SLOAD
PC
stack:
"0x00"
"0x0000000000000000000000000000000000000000000000000000000000000008"
memory:
"0x00"
"0x00"
"0x00"
"0x00"
"0x00"
"0x00"
"0x0000000000000000002200000000000000000000000000000000000000000000"
assembler: # JUMP OP mal data
title: "JUMP_1"
code:
PUSH1 "0xAA"
PUSH1 "0xBB"
PUSH1 "0x0E"
JUMP
PUSH1 "0xCC"
PUSH1 "0xDD"
PUSH1 "0xEE"
JUMPDEST
PUSH1 "0xFF"
stack:
"0xaa"
"0x00000000000000000000000000000000000000000000000000000000000000bb"
success: false
assembler: # JUMP OP mal data
title: "JUMP_2"
code:
PUSH1 "0x0C"
PUSH1 "0x0C"
SWAP1
JUMP
PUSH1 "0xCC"
PUSH1 "0xDD"
PUSH1 "0xEE"
PUSH1 "0xFF"
success: false
stack : "0x0C"
assembler: # JUMPI OP
title: "JUMPI_1"
code:
PUSH1 "0x01"
PUSH1 "0x05"
JUMPI
JUMPDEST
PUSH1 "0xCC"
stack: "0x00000000000000000000000000000000000000000000000000000000000000CC"
assembler: # JUMPI OP
title: "JUMPI_2"
code:
PUSH4 "0x00000000"
PUSH1 "0x44"
JUMPI
PUSH1 "0xCC"
PUSH1 "0xDD"
stack:
"0x00000000000000000000000000000000000000000000000000000000000000CC"
"0x00000000000000000000000000000000000000000000000000000000000000DD"
assembler: # JUMPI OP mal
title: "JUMPI_3"
code:
PUSH1 "0x01"
JUMPI
success: false
stack: "0x01"
assembler: # JUMPI OP mal
title: "JUMPI_4"
code:
PUSH1 "0x01"
PUSH1 "0x22"
SWAP1
SWAP1
JUMPI
success: false
assembler: # JUMP OP mal data
title: "JUMPDEST_1"
code:
PUSH1 "0x23"
PUSH1 "0x08"
JUMP
PUSH1 "0x01"
JUMPDEST
PUSH1 "0x02"
SSTORE
storage:
"0x02": "0x00"
stack: "0x23"
success: false
# success or not?
assembler: # JUMPDEST OP for JUMPI
title: "JUMPDEST_2"
code:
PUSH1 "0x23"
PUSH1 "0x01"
PUSH1 "0x09"
JUMPI
PUSH1 "0x01"
JUMPDEST
PUSH1 "0x02"
SSTORE
#success: false
storage:
"0x02": "0x23"
assembler: # MSIZE OP
title: "MSIZE_1"
code:
MSIZE
stack: "0x0000000000000000000000000000000000000000000000000000000000000000"
assembler: # MSIZE OP
title: "MSIZE_2"
code:
PUSH1 "0x20"
PUSH1 "0x30"
MSTORE
MSIZE
stack:
"0x60"
memory:
"0x00"
"0x00"
"0x0000000000000000000000000000002000000000000000000000000000000000"

176
tests/test_op_misc.nim Normal file
View File

@ -0,0 +1,176 @@
import
macro_assembler, unittest, macros, strutils,
byteutils, eth_common, ../nimbus/db/state_db,
../nimbus/db/db_chain, ranges
suite "Misc Opcodes":
let (blockNumber, chainDB) = initDatabase()
assembler: # LOG0 OP
title: "Log0"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
PUSH1 "0x20"
PUSH1 "0x00"
LOG0
memory:
"0x1234"
logs:
(
address: "0xc669eaad75042be84daaf9b461b0e868b9ac1871",
data: "0x0000000000000000000000000000000000000000000000000000000000001234"
)
assembler: # LOG1 OP
title: "Log1"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
PUSH2 "0x9999"
PUSH1 "0x20"
PUSH1 "0x00"
LOG1
memory:
"0x1234"
logs:
(
address: "0xc669eaad75042be84daaf9b461b0e868b9ac1871",
topics: ["0x9999"],
data: "0x0000000000000000000000000000000000000000000000000000000000001234"
)
assembler: # LOG2 OP
title: "Log2"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
PUSH2 "0x9999"
PUSH2 "0x6666"
PUSH1 "0x20"
PUSH1 "0x00"
LOG2
memory:
"0x1234"
logs:
(
address: "0xc669eaad75042be84daaf9b461b0e868b9ac1871",
topics: ["0x6666", "0x9999"],
data: "0x0000000000000000000000000000000000000000000000000000000000001234"
)
assembler: # LOG3 OP
title: "Log3"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
PUSH2 "0x9999"
PUSH2 "0x6666"
PUSH2 "0x3333"
PUSH1 "0x20"
PUSH1 "0x00"
LOG3
memory:
"0x1234"
logs:
(
address: "0xc669eaad75042be84daaf9b461b0e868b9ac1871",
topics: ["0x3333", "0x6666", "0x9999"],
data: "0x0000000000000000000000000000000000000000000000000000000000001234"
)
assembler: # LOG4 OP
title: "Log4"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
PUSH2 "0x9999"
PUSH2 "0x6666"
PUSH2 "0x3333"
PUSH2 "0x5555"
PUSH1 "0x20"
PUSH1 "0x00"
LOG4
memory:
"0x1234"
logs:
(
address: "0xc669eaad75042be84daaf9b461b0e868b9ac1871",
topics: ["0x5555", "0x3333", "0x6666", "0x9999"],
data: "0x0000000000000000000000000000000000000000000000000000000000001234"
)
assembler: # STOP OP
title: "STOP_1"
code:
PUSH1 "0x20"
PUSH1 "0x30"
PUSH1 "0x10"
PUSH1 "0x30"
PUSH1 "0x11"
PUSH1 "0x23"
STOP
stack:
"0x20"
"0x30"
"0x10"
"0x30"
"0x11"
"0x23"
assembler: # RETURN OP
title: "RETURN_1"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
PUSH1 "0x20"
PUSH1 "0x00"
RETURN
memory: "0x1234"
output: "0x0000000000000000000000000000000000000000000000000000000000001234"
assembler: # RETURN OP
title: "RETURN_2"
code:
PUSH2 "0x1234"
PUSH1 "0x00"
MSTORE
PUSH1 "0x20"
PUSH1 "0x1F"
RETURN
memory:
"0x1234"
"0x00"
output: "0x3400000000000000000000000000000000000000000000000000000000000000"
assembler: # RETURN OP
title: "RETURN_3"
code:
PUSH32 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1B1"
PUSH1 "0x00"
MSTORE
PUSH1 "0x20"
PUSH1 "0x00"
RETURN
memory: "0xa0b0c0d0e0f0a1b1c1d1e1f1a2b2c2d2e2f2a3b3c3d3e3f3a4b4c4d4e4f4a1b1"
output: "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1B1"
assembler: # RETURN OP
title: "RETURN_4"
code:
PUSH32 "0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1B1"
PUSH1 "0x00"
MSTORE
PUSH1 "0x20"
PUSH1 "0x10"
RETURN
output: "0xE2F2A3B3C3D3E3F3A4B4C4D4E4F4A1B100000000000000000000000000000000"
memory:
"0xA0B0C0D0E0F0A1B1C1D1E1F1A2B2C2D2E2F2A3B3C3D3E3F3A4B4C4D4E4F4A1B1"
"0x00"