forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-05-24 08:49:29 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Switched to stack-based language

Browse source
This commit is contained in:
Vitalik Buterin 2013-12-30 16:49:41 -05:00
parent 8e2a08ffde
commit 9115adbcca
2 changed files with 252 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
mining.py Normal file
View file

@ -0,0 +1,56 @@
import hashlib
def bin_sha256(x): return hashlib.sha256(x).digest()
def spread(L): return 16 if L == 9 else 3
def nodes(L): return 2**25 if L == 9 else 8**L
def to_binary(x): return '' if x == 0 else to_binary(int(x / 256)) + chr(x % 256)
def from_binary(x): return 0 if x == '' else 256 * from_binary(x[:-1]) + ord(x[-1])
def mine(root,difficulty,extranonce):
layers = [[] for x in range(9)]
layers[0] = [root]
for L in range(1,10):
prefix = root + to_binary(extranonce) + to_binary(L)
for i in range(nodes(L)):
p = []
for k in range(spread(L)):
h = bin_sha256(prefix + to_binary(i) + to_binary(k))
ind = from_binary(h) % nodes(L-1)
p.append(layers[L-1][ind])
layers[L].append(bin_sha256(''.join(p)))
print "Computed level ",L
prefix = root + to_binary(extranonce)
for i in range(2**26):
p = []
for k in range(4):
h = bin_sha256(prefix + to_binary(i) + to_binary(k))
ind = from_binary(h) % nodes(9)
p.append(layers[9][ind])
h = from_binary(bin_sha256(''.join(p)))
if h * difficulty <= 2**256:
return i
return None
def verify(root,difficulty,extranonce,nonce):
layers = [{} for x in range(9)]
layers[0] = [root]
def getnode(L,i):
if i not in layers[L]:
p = []
for k in range(spread(L)):
h = bin_sha256(root + to_binary(extranonce) + to_binary(L) + to_binary(o) + to_binary(k))
ind = from_binary(h) % nodes(L-1)
p.append(getnode(L-1,ind))
layers[L][i] = bin_sha256(''.join(p))
return layers[L][i]
p = []
for k in range(4):
h = bin_sha256(root + to_binary(extranonce) + to_binary(nonce) + to_binary(k))
ind = from_binary(h) % nodes(9)
p.append(getnode(9,ind))
h = from_binary(bin_sha256(''.join(p)))
return h * difficulty <= 2**256

332
processblock.py
View file

@ -3,50 +3,62 @@ from blocks import Block
import time import time
import sys import sys
import rlp import rlp
import math
scriptcode_map = { scriptcode_map = {
0x00: 'STOP', 0x00: 'STOP',
0x10: 'ADD', 0x01: 'ADD',
0x11: 'SUB', 0x02: 'SUB',
0x12: 'MUL', 0x03: 'MUL',
0x13: 'DIV', 0x04: 'DIV',
0x14: 'SDIV', 0x05: 'SDIV',
0x15: 'MOD', 0x06: 'MOD',
0x16: 'SMOD', 0x07: 'SMOD',
0x17: 'EXP', 0x08: 'EXP',
0x18: 'NEG', 0x09: 'NEG',
0x20: 'LT', 0x0a: 'LT',
0x21: 'LE', 0x0b: 'LE',
0x22: 'GT', 0x0c: 'GT',
0x23: 'GE', 0x0d: 'GE',
0x24: 'EQ', 0x0e: 'EQ',
0x25: 'NOT', 0x0f: 'NOT',
0x30: 'SHA256', 0x10: 'MYADDRESS',
0x31: 'RIPEMD-160', 0x11: 'TXSENDER',
0x32: 'ECMUL', 0x12: 'TXVALUE',
0x33: 'ECADD', 0x13: 'TXFEE',
0x34: 'ECSIGN', 0x14: 'TXDATAN',
0x35: 'ECRECOVER', 0x15: 'TXDATA',
0x40: 'COPY', 0x16: 'BLK_PREVHASH',
0x41: 'STORE', 0x17: 'BLK_COINBASE',
0x42: 'LOAD', 0x18: 'BLK_TIMESTAMP',
0x43: 'SET', 0x19: 'BLK_NUMBER',
0x50: 'JMP', 0x1a: 'BLK_DIFFICULTY',
0x51: 'JMPI', 0x20: 'SHA256',
0x52: 'IND', 0x21: 'RIPEMD160',
0x60: 'EXTRO', 0x22: 'ECMUL',
0x61: 'BALANCE', 0x23: 'ECADD',
0x70: 'MKTX', 0x24: 'ECSIGN',
0x71: 'RAWTX', 0x25: 'ECRECOVER',
0x80: 'DATA', 0x26: 'ECVALID',
0x81: 'DATAN', 0x30: 'PUSH',
0x90: 'MYADDRESS', 0x31: 'POP',
0x91: 'BLKHASH', 0x32: 'DUP',
0x33: 'DUPN',
0x34: 'SWAP',
0x35: 'SWAPN',
0x36: 'LOAD',
0x37: 'STORE',
0x40: 'JMP',
0x41: 'JMPI',
0x42: 'IND',
0x50: 'EXTRO',
0x51: 'BALANCE',
0x60: 'MKTX',
0xff: 'SUICIDE' 0xff: 'SUICIDE'
} }
params = { params = {
'stepfee': 2**64 / 64, 'stepfee': 10**16,
'txfee': 2**64, 'txfee': 2**64,
'newcontractfee': 2**64, 'newcontractfee': 2**64,
'memoryfee': 2**64 / 4, 'memoryfee': 2**64 / 4,
@ -156,12 +168,8 @@ def eval(block,transactions,timestamp,coinbase):
def eval_contract(block,transaction_list,tx): def eval_contract(block,transaction_list,tx):
sys.stderr.write("evaluating contract\n") sys.stderr.write("evaluating contract\n")
address = tx.to address = tx.to
# Initialize registers # Initialize stack
reg = [0] * 256 stack = []
reg[0] = decode(tx.sender,256)
reg[1] = decode(tx.to,256)
reg[2] = tx.value
reg[3] = tx.fee
index = 0 index = 0
stepcounter = 0 stepcounter = 0
contract = block.get_contract(address) contract = block.get_contract(address)
@ -174,7 +182,7 @@ def eval_contract(block,transaction_list,tx):
code[0] = scriptcode_map.get(code[0],'INVALID') code[0] = scriptcode_map.get(code[0],'INVALID')
sys.stderr.write("Evaluating: "+ str(code)+"\n") sys.stderr.write("Evaluating: "+ str(code)+"\n")
# Invalid code instruction or STOP code stops execution sans fee # Invalid code instruction or STOP code stops execution sans fee
if val_at_index >= 256**6 or code[0] in ['STOP','INVALID']: if val_at_index >= 256 or code[0] in ['STOP','INVALID']:
sys.stderr.write("stop code, exiting\n") sys.stderr.write("stop code, exiting\n")
break break
# Calculate fee # Calculate fee
@ -202,141 +210,193 @@ def eval_contract(block,transaction_list,tx):
block.set_balance(address,block.get_balance(address) - nullfee - minerfee) block.set_balance(address,block.get_balance(address) - nullfee - minerfee)
block.reward += minerfee block.reward += minerfee
sys.stderr.write("evaluating operation\n") sys.stderr.write("evaluating operation\n")
exit = False
def stack_pop(n):
if len(stack) < n:
sys.stderr.write("Stack height insufficient, exiting")
exit = True
return [0] * n
o = stack[-n:]
stack = stack[:-n]
return o
# Evaluate operations # Evaluate operations
if c == 'ADD': if c == 'ADD':
reg[code[3]] = (reg[code[1]] + reg[code[2]]) % 2**256 x,y = stack_pop(2)
stack.append((x + y) % 2**256)
elif c == 'MUL': elif c == 'MUL':
reg[code[3]] = (reg[code[1]] * reg[code[2]]) % 2**256 x,y = stack_pop(2)
stack.append((x * y) % 2**256)
elif c == 'SUB': elif c == 'SUB':
reg[code[3]] = (reg[code[1]] + 2**256 - reg[code[2]]) % 2**256 x,y = stack_pop(2)
stack.append((x - y) % 2**256)
elif c == 'DIV': elif c == 'DIV':
reg[code[3]] = int(reg[code[1]] / reg[code[2]]) x,y = stack_pop(2)
if y == 0: break
stack.append(int(x / y))
elif c == 'SDIV': elif c == 'SDIV':
sign = 1 x,y = stack_pop(2)
sign *= (1 if reg[code[1]] < 2**255 else -1) if y == 0: break
sign *= (1 if reg[code[2]] < 2**255 else -1) sign = (1 if x < 2**255 else -1) * (1 if y < 2**255 else -1)
x = reg[code[1]] if reg[code[1]] < 2**255 else 2**256 - reg[code[1]] xx = x if x < 2**255 else 2**256 - x
y = reg[code[2]] if reg[code[2]] < 2**255 else 2**256 - reg[code[2]] yy = y if y < 2**255 else 2**256 - y
z = int(x/y) z = int(xx/yy)
reg[code[3]] = z if sign == 1 else 2**256 - z stack.append(z if sign == 1 else 2**256 - z)
elif code == 'MOD': elif code == 'MOD':
reg[code[3]] = reg[code[1]] % reg[code[2]] x,y = stack_pop(2)
if y == 0: break
stack.append(x % y)
elif code == 'SMOD': elif code == 'SMOD':
sign = 1 x,y = stack_pop(2)
sign *= (1 if reg[code[1]] < 2**255 else -1) if y == 0: break
sign *= (1 if reg[code[2]] < 2**255 else -1) sign = (1 if x < 2**255 else -1) * (1 if y < 2**255 else -1)
x = reg[code[1]] if reg[code[1]] < 2**255 else 2**256 - reg[code[1]] xx = x if x < 2**255 else 2**256 - x
y = reg[code[2]] if reg[code[2]] < 2**255 else 2**256 - reg[code[2]] yy = y if y < 2**255 else 2**256 - y
z = x%y z = xx%yy
reg[code[3]] = z if sign == 1 else 2**256 - z stack.append(z if sign == 1 else 2**256 - z)
elif code == 'EXP': elif code == 'EXP':
reg[code[3]] = pow(reg[code[1]],reg[code[2]],2**256) x,y = stack_pop(2)
stack.append(pow(x,y,2**256))
elif code == 'NEG': elif code == 'NEG':
reg[code[2]] = 2**256 - reg[code[1]] stack.append(2**256 - stack.pop(1)[0])
elif code == 'LT': elif code == 'LT':
reg[code[3]] = 1 if reg[code[1]] < reg[code[2]] else 0 x,y = stack_pop(2)
stack.append(1 if x < y else 0)
elif code == 'LE': elif code == 'LE':
reg[code[3]] = 1 if reg[code[1]] <= reg[code[2]] else 0 x,y = stack_pop(2)
stack.append(1 if x <= y else 0)
elif code == 'GT': elif code == 'GT':
reg[code[3]] = 1 if reg[code[1]] > reg[code[2]] else 0 x,y = stack_pop(2)
stack.append(1 if x > y else 0)
elif code == 'GE': elif code == 'GE':
reg[code[3]] = 1 if reg[code[1]] >= reg[code[2]] else 0 x,y = stack_pop(2)
stack.append(1 if x >= y else 0)
elif code == 'EQ': elif code == 'EQ':
reg[code[3]] = 1 if reg[code[1]] == reg[code[2]] else 0 x,y = stack_pop(2)
stack.append(1 if x == y else 0)
elif code == 'NOT': elif code == 'NOT':
reg[code[2]] = 1 if reg[code[1]] == 0 else 0 stack.append(1 if stack.pop(1)[0] == 0 else 0)
elif code == 'MYADDRESS':
stack.append(address)
elif code == 'TXSENDER':
stack.append(decode(tx.sender,256))
elif code == 'TXVALUE':
stack.append(tx.value)
elif code == 'TXFEE':
stack.append(tx.fee)
elif code == 'TXDATAN':
stack.append(len(tx.data))
elif code == 'TXDATA':
x, = stack_pop(1)
stack.append(0 if x >= len(tx.data) else tx.data[x])
elif code == 'BLK_PREVHASH':
stack.append(decode(block.prevhash,256))
elif code == 'BLK_COINBASE':
stack.append(decode(block.coinbase,160))
elif code == 'BLK_TIMESTAMP':
stack.append(block.timestamp)
elif code == 'BLK_NUMBER':
stack.append(block.number)
elif code == 'BLK_DIFFICULTY':
stack.append(block.difficulty)
elif code == 'SHA256': elif code == 'SHA256':
inp = encode(reg[code[1]],256,32) L = stack_pop(1)
reg[code[2]] = decode(hashlib.sha256(inp).digest(),256) hdataitems = stack_pop(math.ceil(L / 32.0))
hdata = ''.join([encode(x,256,32) for x in hdataitems])[:L]
stack.append(decode(hashlib.sha256(hdata).digest(),256))
elif code == 'RIPEMD-160': elif code == 'RIPEMD-160':
inp = encode(reg[code[1]],256,32) L = stack_pop(1)
reg[code[2]] = decode(hashlib.new('ripemd160',inp).digest(),256) hdataitems = stack_pop(math.ceil(L / 32.0))
hdata = ''.join([encode(x,256,32) for x in hdataitems])[:L]
stack.append(decode(hashlib.new('ripemd160',hdata).digest(),256))
elif code == 'ECMUL': elif code == 'ECMUL':
pt = (reg[code[1]],reg[code[2]]) n,x,y = stack_pop(3)
# Point at infinity # Point at infinity
if pt[0] == 0 and pt[1] == 0: if x == 0 and y == 0:
reg[code[4]], reg[code[5]] = 0,0 stack.extend([0,0])
# Point not on curve, coerce to infinity # Point not on curve, coerce to infinity
elif (pt[0] ** 3 + 7 - pt[1] ** 2) % N != 0: elif x >= P or y >= P or (x ** 3 + 7 - y ** 2) % P != 0:
reg[code[4]], reg[code[5]] = 0,0 stack.extend([0,0])
# Legitimate point # Legitimate point
else: else:
pt2 = base10_multiply(pt,reg[code[3]]) x2,y2 = base10_multiply((x,y),n)
reg[code[4]], reg[code[5]] = pt2[0], pt2[1] stack.extend([x2,y2])
elif code == 'ECADD': elif code == 'ECADD':
pt1 = (reg[code[1]],reg[code[2]]) x1,y1,x2,y2 = stack_pop(4)
pt2 = (reg[code[3]],reg[code[4]])
# Invalid point 1 # Invalid point 1
if (pt1[0] ** 3 + 7 - pt1[1] ** 2) % N != 0: if x1 >= P or y1 >= P or (x1 ** 3 + 7 - y1 ** 2) % P != 0:
reg[code[5]], reg[code[6]] = 0,0 stack.extend([0,0])
# Invalid point 2 # Invalid point 2
elif (pt2[0] ** 3 + 7 - pt2[1] ** 2) % N != 0: elif x2 >= P or y2 >= P or (x2 ** 3 + 7 - y2 ** 2) % P != 0:
reg[code[5]], reg[code[6]] = 0,0 stack.extend([0,0])
# Legitimate points # Legitimate points
else: else:
pt3 = base10_add(pt1,pt2) x3,y3 = base10_add((x1,y1),(x2,y2))
reg[code[5]], reg[code[6]] = pt3[0], pt3[1] stack.extend([x3,y3])
elif code == 'ECSIGN': elif code == 'ECSIGN':
reg[code[3]], reg[code[4]], reg[code[5]] = ecdsa_raw_sign(reg[code[1]],reg[code[2]]) k,h = stack_pop(2)
v,r,s = ecdsa_raw_sign(h,k)
stack.extend([v,r,s])
elif code == 'ECRECOVER': elif code == 'ECRECOVER':
pt = ecdsa_raw_recover((reg[code[2]],reg[code[3]],reg[code[4]]),reg[code[1]]) h,v,r,s = stack_pop(4)
reg[code[5]] = pt[0] x,y = ecdsa_raw_recover((v,r,s),h)
reg[code[6]] = pt[1] stack.extend([x,y])
elif code == 'COPY': elif code == 'PUSH':
reg[code[2]] = reg[code[1]] stack.append(contract.get(encode(index + 1,256,32)))
elif code == 'STORE': index += 1
contract.update(encode(reg[code[2]],256,32),reg[code[1]]) elif code == 'POP':
stack_pop(1)
elif code == 'DUP':
x, = stack_pop(1)
stack.extend([x,x])
elif code == 'DUPN':
arr = stack_pop(contract.get(encode(index + 1,256,32)))
arr.append(arr[0])
stack.extend(arr)
index += 1
elif code == 'SWAP':
x,y = stack_pop(2)
stack.extend([y,x])
elif code = 'SWAPN':
arr = stack_pop(contract.get(encode(index + 1,256,32)))
arr.append(arr[0])
arr.pop(0)
stack.extend(arr)
index += 1
elif code == 'LOAD': elif code == 'LOAD':
reg[code[2]] = contract.get(encode(reg[code[1]],256,32)) stack.append(contract.get(encode(stack_pop(1)[0],256,32)))
elif code == 'SET': elif code == 'STORE':
reg[code[1]] = (code[2] + 256 * code[3] + 65536 * code[4] + 16777216 * code[5]) * 2**code[6] % 2**256 x,y = stack_pop(2)
if exit: break
contract.update(encode(x,256,32),y)
elif code == 'JMP': elif code == 'JMP':
index = reg[code[1]] index = stack_pop(1)[0]
elif code == 'JMPI': elif code == 'JMPI':
if reg[code[1]]: index = reg[code[2]] newpos,c = stack_pop(2)
if c != 0: index = newpos
elif code == 'IND': elif code == 'IND':
reg[code[1]] = index stack.append(index)
elif code == 'EXTRO': elif code == 'EXTRO':
if reg[code[1]] >= 2**160: ind,addr = stack_pop(2)
reg[code[3]] = 0 stack.push(block.get_contract(encode(addr,256,20)).get(encode(ind,256,32)))
else:
address = encode(reg[code[1]],256,20)
field = encode(reg[code[2]])
reg[code[3]] = block.get_contract(address).get(field)
elif code == 'BALANCE': elif code == 'BALANCE':
if reg[code[1]] >= 2**160: stack.push(block.get_balance(encode(stack_pop(1)[0],256,20)))
reg[code[2]] = 0
else:
address = encode(reg[code[1]],256,20)
reg[code[2]] = block.get_balance(address)
elif code == 'MKTX': elif code == 'MKTX':
to = encode(reg[code[1]],256,32) datan,fee,value,to = stack_pop(4)
value = reg[code[2]] if exit:
fee = reg[code[3]] break
if (value + fee) > block.get_balance(address): elif (value + fee) > block.get_balance(address):
pass break
else: else:
datan = reg[code[4]] data = stack_pop(datan)
data = [] tx = Transaction(0,encode(to,256,20),value,fee,data)
for i in range(datan):
ind = encode((reg[code[5]] + i) % 2**256,256,32)
data.append(contract.get(ind))
tx = Transaction(0,to,value,fee,data)
tx.sender = address tx.sender = address
transaction_list.insert(0,tx) transaction_list.insert(0,tx)
elif code == 'DATA':
reg[code[2]] = tx.data[reg[code[1]]]
elif code == 'DATAN':
reg[code[1]] = len(tx.data)
elif code == 'MYADDRESS':
reg[code[1]] = address
elif code == 'BLKHASH':
reg[code[1]] = decode(block.hash())
elif code == 'SUICIDE': elif code == 'SUICIDE':
sz = contract.get_size() sz = contract.get_size()
negfee = -sz * params["memoryfee"] negfee = -sz * params["memoryfee"]
toaddress = encode(reg[code[1]],256,20) toaddress = encode(stack_pop(1)[0],256,20)
block.pay_fee(roaddress,negfee,False) block.pay_fee(toaddress,negfee,False)
contract.root = '' contract.root = ''
break break
if exit: break
block.update_contract(address,contract) block.update_contract(address,contract)