ethereum examples

readme

Serpent examples

capability_example.py

clist_code="""

# A Capability List system
#
# Gronvetter introduction diagram
# Alice introduces Carol to Bob.
# 
#   Alice --[foo->]--->  Bob
#            //
#           //
#   Carol --\=-->
#

init:
   # Initial state goes here!
   
code:

   # Ignore a message while the contract is lcoked
   if contract.storage[0] == 1:
      stop()

   # Create a new object
   if msg.data[0] == 1:

      parent = msg.sender
      contract.storage[0] == 1 # Lock the contract before transferring control
      child = create(msg.data[1], msg.data[2], msg.data[3], ...) # TODO: fix?
      contract.storage[0] = 0 # unlock the contract

      # Parenthood
      contract.storage[[parent,child]] = 1


   # Grant a capability by introduction
   if msg.data[0] == 2:

      # Alice is the sender
      sender = msg.sender

      # Bob is the object
      object = msg.data[1]

      # Carol is the receiver
      receiver = msg.data[2]

      # To grant a capability, the sender must hold a capability 
      # to both the object and to the receiver
      if !(contract.storage[[sender,object]] and 
           contract.storage[[sender,receiver]]):
          return(1)

      # Grant access
      contract.storage[[receiver,object]] = 1

      
   # Check a capability
   if msg.data[0] == 3:
      # returns 1 if the capability is granted, 0 otherwise 
      return contract.storage[[msg.data[1],msg.data[2]]]


   # Additional rule: 
   # A "top level" object with no 
"""

check_example = """
   # Check if the sender has capability to check this object
   if !call(${clist}, [3, msg.sender, this]):
       stop()

   ...

"""

import serpent
from pyethereum import transactions, blocks, processblock, utils

processblock.print_debug = 1
code = serpent.compile(contract_code)
key = utils.sha3('cow')
addr = utils.privtoaddr(key)
genesis = blocks.genesis({ addr: 10**18 })
tx1 = transactions.contract(0,10**12,10000,0,code).sign(key)
result, contract = processblock.apply_transaction(genesis,tx1)

concurrency_example.py

contract_code = """                                                                                                                                                                                                               
// Reentrant contract

command = msg.data[0]
if command == 1:
   contract.storage[0] = 99
   contractToCall = msg.data[1]
   params = [2]
   #msg(200, contractToCall, 0, params, 1)

   if contract.storage[0] != 99:
       suicide()

if command == 2: // option 2
   contract.storage[0] = -1
"""

import serpent
from pyethereum import transactions, blocks, processblock, utils

processblock.print_debug = 1
code = serpent.compile(contract_code)
key = utils.sha3('cow')
addr = utils.privtoaddr(key)
genesis = blocks.genesis({ addr: 10**18 })
tx1 = transactions.contract(0,10**12,10000,0,code).sign(key)
result, contract = processblock.apply_transaction(genesis,tx1)
#print genesis.to_dict()

tx2 = transactions.Transaction(1,10**12,2000,contract,0,
                               serpent.encode_datalist([1,contract])).sign(key)
result, ans = processblock.apply_transaction(genesis,tx2)

print 'result:', serpent.decode_datalist(ans)

#print genesis.to_dict()

locking_example.py

contract_code = """                                                                                                                                                                                                               
// Locked contract

if contract.storage[100] == 1:
   stop # Don't enter a contract that's locked
contract.storage[100] = 1 # Lock the contract

command = msg.data[0]
if command == 1:
   contract.storage[0] = 99
   contractToCall = msg.data[1]
   params = [2]
   msg(200, contractToCall, 0, params, 1)

   if contract.storage[0] != 99:
       suicide()     

if command == 2: // option 2
   contract.storage[0] = -1

contract.storage[100] = 0 # Unlock
return(0)
"""

import serpent
from pyethereum import transactions, blocks, processblock, utils

processblock.print_debug = 1
code = serpent.compile(contract_code)
key = utils.sha3('cow')
addr = utils.privtoaddr(key)
genesis = blocks.genesis({ addr: 10**18 })
tx1 = transactions.contract(0,10**12,10000,0,code).sign(key)
result, contract = processblock.apply_transaction(genesis,tx1)
#print genesis.to_dict()

tx2 = transactions.Transaction(1,10**12,10000,contract,0,
                               serpent.encode_datalist([1,contract])).sign(key)
result, ans = processblock.apply_transaction(genesis,tx2)

print 'result:', serpent.decode_datalist(ans)

#print genesis.to_dict()

namecoin_example.py

namecoin_code = """                                                                                                                                                                                                               
// Namecoin                                                                                                                                                                                                                       
                                                                                                                                                                                                                                  
if !contract.storage[msg.data[0]]: # Is the key not yet taken?                                                                                                                                                                    
    # Then take it!                                                                                                                                                                                                               
    contract.storage[msg.data[0]] = msg.data[1]                                                                                                                                                                                   
    return(1)                                                                                                                                                                                                                     
else:                                                                                                                                                                                                                             
    return(0) // Otherwise do nothing                                                                                                                                                                                             
"""

import serpent
from pyethereum import transactions, blocks, processblock, utils
processblock.print_debug = 1
code = serpent.compile(namecoin_code)
key = utils.sha3('cow')
addr = utils.privtoaddr(key)
genesis = blocks.genesis({ addr: 10**18 })
tx1 = transactions.contract(0,10**12,10000,0,code).sign(key)
result, contract = processblock.apply_transaction(genesis,tx1)
print genesis.to_dict()
tx2 = transactions.Transaction(1,10**12,10000,contract,0,
     serpent.encode_datalist(['george',45])).sign(key)
result, ans = processblock.apply_transaction(genesis,tx2)
serpent.decode_datalist(ans)
print genesis.to_dict()

queue_example.py

contract_code = """
//
// A message queue contract

init:
   contract.storage[0] = 0   # Starts unlocked
   contract.storage[1] = 3   # Queue head
   contract.storage[2] = 3   # Queue tail

code:

   command = msg.data[0]
   if command == 1:       # Append to queue

      error = 0
      tail = contract.storage[2]

      # First element is a contract address
      contract = msg.data[1]

      # Second element is gas price
      gasprice = msg.data[2]

      # Third element is gas cost
      gascost = msg.data[3]

      # Fourth element is value
      value = msg.data[4]

      # Fifth element is argument data
      argument = msg.data[5]

      # Assign a fixed fee for whoever *executes* this transaction
      fee = 200

      # Check that the msg value is enough
      if msg.value < gascost + value + fee:
         return(1) # Insufficient value

      # Push this message to the end of the queue
      contract.storage[tail*5+0] = contract
      contract.storage[tail*5+1] = gasprice
      contract.storage[tail*5+2] = gascost
      contract.storage[tail*5+3] = value
      contract.storage[tail*5+4] = argument
      contract.storage[2] += 1

      return(0)


   if command == 2:       # Execute the front of queue

      # CRITICAL SECTION - Shouldn't be reentrant

      # Don't enter a contract that's locked
      if contract.storage[0] == 1:
         return(1)

      # Lock the contract
      contract.storage[0] = 1

      head = contract.storage[1]
      tail = contract.storage[2]

      if head >= tail: # The queue is empty, nothing to execute
         contract.storage[0] = 0 
         return(2)
      
      contract = contract.storage[head*5+0]
      gasprice = contract.storage[head*5+1]
      gascost = contract.storage[head*5+2]
      value = contract.storage[head*5+3]
      argument = contract.storage[head*5+4]

      # Check the gas price is low enough
      if tx.gasprice > gasprice:
         contract.storage[0] = 0 
         return(3)  # Wrong gas price
         
      # Check the gas is sufficient to finish the transaction
      if tx.gas < gascost + 200 # (remainder)
         contract.storage[0] = 0 
         return(4)  # Insufficient gas

      # Call the contract
      msg(gascost, contract, value, argument)

      # Return fee
      send(msg.sender, fee + gascost)

      # Clear the storage and advance the queue
      contract.storage[tail] = 0
      contract.storage[1] += 1

      # Unlock the queue
      contract.storage[0] = 0

      # END CRITICAL SECTION
      return(0)
"""

second_contract_code = """
code:
   if msg.data[0] > 0:
      contract.storage[0] = msg.data[0]

   else:
      return(contract.storage[0])
"""


import serpent
from pyethereum import transactions, blocks, processblock, utils

#processblock.print_debug = 1

key = utils.sha3('cow')
addr = utils.privtoaddr(key)
genesis = blocks.genesis({ addr: 10**18 })

code = serpent.compile(contract_code)
tx1 = transactions.contract(0,10**12,10000,0,code).sign(key)
result, contract = processblock.apply_transaction(genesis,tx1)
print 'contract1', contract
#print genesis.to_dict()

code = serpent.compile(second_contract_code)
tx1 = transactions.contract(1,10**12,10000,0,code).sign(key)
result, contract2 = processblock.apply_transaction(genesis,tx1)
print 'contract2', contract2

# Register a message in the message queue
tx2 = transactions.Transaction(2,10**12,10**5,contract,3000,
                               serpent.encode_datalist([1,contract2,10**12,300,200,80])).sign(key)
result, ans = processblock.apply_transaction(genesis,tx2)
print 'result:', serpent.decode_datalist(ans)

# Cause the message queue to pop
tx2 = transactions.Transaction(3,10**12,10**5,contract,3000,
                               serpent.encode_datalist([2])).sign(key)
result, ans = processblock.apply_transaction(genesis,tx2)
print 'result:', serpent.decode_datalist(ans)

# 
tx2 = transactions.Transaction(4,10**12,10**5,contract2,3000,
                               serpent.encode_datalist([0])).sign(key)
result, ans = processblock.apply_transaction(genesis,tx2)
print 'Value after message is applied:', serpent.decode_datalist(ans)



#print genesis.to_dict()