def __init__(self): self.w3 = Web3(HTTPProvider('http://localhost:8545')) self.root_chain = Deployer().deploy_contract('RootChain', concise=False) self.child_chain = ChildChain(AUTHORITY['address'], self.root_chain) self.transactions = [] self.accounts = []
def __init__(self): self.root_chain = Deployer().deploy_contract('RootChain', concise=False) self.child_chain = ChildChain(AUTHORITY['address'], self.root_chain) print("child chain {0}".format(self.child_chain)) print("init {0}".format(AUTHORITY['address'])) self.confirmations = {} self.accounts = []
def child_chain(): child_chain = ChildChain(AUTHORITY, Mock()) # Create some valid transations tx1 = Transaction(0, 0, 0, 0, 0, 0, newowner1, amount1, b'\x00' * 20, 0, 0) tx2 = Transaction(0, 0, 0, 0, 0, 0, newowner1, amount1, b'\x00' * 20, 0, 0) # Create a block with those transactions child_chain.blocks[1] = Block([tx1, tx2]) return child_chain
def child_chain(root_chain): child_chain = ChildChain(None, None, None) # Create some valid transations key = b'8b76243a95f959bf101248474e6bdacdedc8ad995d287c24616a41bd51642965' owner, amount1 = '0x8f2ecdd6103c0423f4c3e906666238936e81e538', 200 tx1 = Transaction(0, 0, 0, 0, 0, 0, owner, amount1, b'\x00' * 20, 0, 0) tx2 = Transaction(0, 0, 0, 0, 0, 0, owner, amount1, b'\x00' * 20, 0, 0) # Create a block with those transactions child_chain.blocks[1] = Block([tx1, tx2]) return child_chain
def __init__(self): self.w3 = Web3(HTTPProvider('http://localhost:8545')) self.root_chain = Deployer().deploy_contract('RootChain', concise=False) self.child_chain = ChildChain(bytes.fromhex(AUTHORITY['address'][2:]), self.root_chain) self.transactions = [] self.accounts = [] self.handlers = dict() # Register handlers self.register_handler('Deposit', self.deposit) self.register_handler('Transfer', self.transfer) self.register_handler('SubmitBlock', self.submit_block) self.register_handler('Confirm', self.confirm) self.register_handler('Withdraw', self.withdraw)
def main(root_chain_address, eth_node_endpoint): global child_chain root_chain_address = Web3.toChecksumAddress(root_chain_address) root_chain = Deployer(eth_node_endpoint).get_contract_at_address( "RootChain", root_chain_address, concise=False) print("root_chain is %s" % root_chain) child_chain = ChildChain(root_chain, eth_node_endpoint) run_simple('0.0.0.0', 8546, application)
import rlp from werkzeug.wrappers import Request, Response from werkzeug.serving import run_simple from jsonrpc import JSONRPCResponseManager, dispatcher from ethereum import utils from plasma.child_chain.child_chain import ChildChain from plasma.root_chain.deployer import Deployer from plasma_core.constants import CONTRACT_ADDRESS, AUTHORITY from plasma_core.block import Block from plasma_core.transaction import Transaction from plasma_core.utils.transactions import encode_utxo_id root_chain = Deployer().get_contract_at_address("RootChain", CONTRACT_ADDRESS, concise=False) child_chain = ChildChain(AUTHORITY['address'], root_chain) @Request.application def application(request): # Dispatcher is dictionary {<method_name>: callable} dispatcher["submit_block"] = lambda block: child_chain.submit_block(rlp.decode(utils.decode_hex(block), Block)) dispatcher["apply_transaction"] = lambda transaction: child_chain.apply_transaction(rlp.decode(utils.decode_hex(transaction), Transaction)) dispatcher["get_transaction"] = lambda blknum, txindex: rlp.encode(child_chain.get_transaction(encode_utxo_id(blknum, txindex, 0)), Transaction).hex() dispatcher["get_current_block"] = lambda: rlp.encode(child_chain.get_current_block(), Block).hex() dispatcher["get_current_block_num"] = lambda: child_chain.get_current_block_num() dispatcher["get_block"] = lambda blknum: rlp.encode(child_chain.get_block(blknum), Block).hex() dispatcher["get_test"] = lambda: child_chain.get_test() dispatcher["set_dict"] = lambda **num: child_chain.set_dict(**num) dispatcher["set_test"] = lambda num: child_chain.set_test(num) dispatcher["hello"] = lambda: child_chain.hello() response = JSONRPCResponseManager.handle( request.data, dispatcher)
from werkzeug.wrappers import Request, Response from werkzeug.serving import run_simple from jsonrpc import JSONRPCResponseManager, dispatcher from plasma.child_chain.child_chain import ChildChain from plasma.root_chain.deployer import Deployer from plasma_core.constants import CONTRACT_ADDRESS, AUTHORITY root_chain = Deployer().get_contract_at_address("RootChain", CONTRACT_ADDRESS, concise=False) child_chain = ChildChain(bytes.fromhex(AUTHORITY['address'][2:]), root_chain) @Request.application def application(request): # Dispatcher is dictionary {<method_name>: callable} dispatcher["submit_block"] = lambda block: child_chain.submit_block(block) dispatcher["apply_transaction"] = lambda transaction: child_chain.apply_transaction(transaction) dispatcher["get_transaction"] = lambda blknum, txindex: child_chain.get_transaction(blknum, txindex) dispatcher["get_current_block"] = lambda: child_chain.get_current_block() dispatcher["get_current_block_num"] = lambda: child_chain.get_current_block_num() dispatcher["get_block"] = lambda blknum: child_chain.get_block(blknum) response = JSONRPCResponseManager.handle( request.data, dispatcher) return Response(response.json, mimetype='application/json') if __name__ == '__main__': run_simple('localhost', 8546, application)
class TestingLanguage(object): def __init__(self): self.root_chain = Deployer().deploy_contract('RootChain', concise=False) self.child_chain = ChildChain(AUTHORITY['address'], self.root_chain) self.transactions = [] self.accounts = [] def get_account(self): account = ACCOUNTS[len(self.accounts)] self.accounts.append(account) return account def deposit(self, account, amount): amount = int(amount) self.root_chain.transact({ 'from': account['address'], 'value': amount }).deposit() # Wait for the Deposit event to be detected time.sleep(1) tx = Transaction(0, 0, 0, 0, 0, 0, NULL_ADDRESS, account['address'], amount, NULL_ADDRESS, 0) self.transactions.append({ 'tx': tx, 'confirm_sigs': b'', 'is_deposit': True }) return len(self.transactions) - 1 def transfer(self, input1, oindex1, newowner1, amount1, signatory1, input2=None, oindex2=0, newowner2=None, amount2=None, signatory2=None, cur12=NULL_ADDRESS): newowner_address1 = newowner1['address'] amount1 = int(amount1) newowner_address2 = NULL_ADDRESS if newowner2 is not None: newowner_address2 = newowner2['address'] amount2 = int(amount2) if amount2 is not None else 0 encoded_input_tx1 = rlp.encode(self.transactions[input1]['tx']).hex() blknum1, txindex1 = self.child_chain.get_tx_pos(encoded_input_tx1) blknum2, txindex2 = 0, 0 if input2 is not None: encoded_input_tx2 = rlp.encode(self.transactions[input2]['tx']).hex() blknum2, txindex2 = self.child_chain.get_tx_pos(encoded_input_tx2) tx = Transaction(blknum1, txindex1, oindex1, blknum2, txindex2, oindex2, cur12, newowner_address1, amount1, newowner_address2, amount2) if signatory1 is not None: key1 = signatory1['key'] tx.sign1(key1) if signatory2 is not None: key2 = signatory2['key'] tx.sign2(key2) encoded_tx = rlp.encode(tx).hex() self.child_chain.apply_transaction(encoded_tx) self.transactions.append({ 'tx': tx, 'confirm_sigs': b'', 'is_deposit': False }) return len(self.transactions) - 1 def submit_block(self, signatory=AUTHORITY): signing_key = None if signatory is not None: signing_key = signatory['key'] block = self.child_chain.current_block block.make_mutable() if signing_key: block.sign(signing_key) self.child_chain.submit_block(rlp.encode(block).hex()) def confirm(self, tx_id, signatory1, signatory2=None): transaction = self.transactions[tx_id] tx = transaction['tx'] encoded_tx = rlp.encode(tx).hex() blknum, _ = self.child_chain.get_tx_pos(encoded_tx) block_root = self.child_chain.blocks[blknum].merkle.root confirm_sigs = b'' for signatory in [x for x in [signatory1, signatory2] if x is not None]: confirm_sigs += tx.confirm(block_root, signatory['key']) self.transactions[tx_id]['confirm_sigs'] = confirm_sigs def withdraw(self, tx_id, oindex, exitor): transaction = self.transactions[tx_id] tx = transaction['tx'] encoded_tx = rlp.encode(tx).hex() tx_bytes = rlp.encode(tx, UnsignedTransaction) sigs = tx.sig1 + tx.sig2 + transaction['confirm_sigs'] blknum, txindex = self.child_chain.get_tx_pos(encoded_tx) utxo_pos = blknum * 1000000000 + txindex * 10000 + oindex * 1 if transaction['is_deposit']: deposit_amount = tx.amount1 self.root_chain.transact({ 'from': exitor['address'] }).startDepositExit(utxo_pos + 1, NULL_ADDRESS_HEX, deposit_amount) else: output_block = self.child_chain.blocks[blknum] hashed_transaction_set = [transaction.merkle_hash for transaction in output_block.transaction_set] merkle = FixedMerkle(16, hashed_transaction_set, hashed=True) proof = merkle.create_membership_proof(tx.merkle_hash) self.root_chain.transact({ 'from': exitor['address'] }).startExit(utxo_pos, tx_bytes, proof, sigs)
def __init__(self): self.root_chain = Deployer().deploy_contract('RootChain', concise=False) self.child_chain = ChildChain(AUTHORITY['address'], self.root_chain) self.transactions = [] self.accounts = []
from werkzeug.wrappers import Request, Response from werkzeug.serving import run_simple from jsonrpc import JSONRPCResponseManager, dispatcher from plasma.child_chain.child_chain import ChildChain from plasma.config import plasma_config from plasma.root_chain.deployer import Deployer child_chain = ChildChain(plasma_config['AUTHORITY'], Deployer().get_contract("RootChain/RootChain.sol")) @Request.application def application(request): # Dispatcher is dictionary {<method_name>: callable} dispatcher["submit_block"] = lambda block: child_chain.submit_block(block) dispatcher[ "apply_transaction"] = lambda transaction: child_chain.apply_transaction( transaction) dispatcher[ "get_transaction"] = lambda blknum, txindex: child_chain.get_transaction( blknum, txindex) dispatcher["get_current_block"] = lambda: child_chain.get_current_block() dispatcher[ "get_current_block_num"] = lambda: child_chain.get_current_block_num() dispatcher["get_block"] = lambda blknum: child_chain.get_block(blknum) response = JSONRPCResponseManager.handle(request.data, dispatcher) return Response(response.json, mimetype='application/json') if __name__ == '__main__': run_simple('localhost', 8546, application)
class TestingLanguage(object): def __init__(self): self.root_chain = Deployer().deploy_contract('RootChain', concise=False) self.child_chain = ChildChain(AUTHORITY['address'], self.root_chain) self.confirmations = {} self.accounts = [] def get_account(self): account = ACCOUNTS[len(self.accounts)] self.accounts.append(account) return account def deposit(self, account, amount): deposit_blknum = self.child_chain.chain.next_deposit_block self.root_chain.transact({ 'from': account['address'], 'value': amount }).deposit() # Wait for the Deposit event to be detected time.sleep(1) return encode_utxo_id(deposit_blknum, 0, 0) def transfer(self, input1, newowner1, amount1, signatory1, input2=0, newowner2=None, amount2=0, signatory2=None, cur12=NULL_ADDRESS): newowner_address1 = newowner1['address'] newowner_address2 = NULL_ADDRESS if newowner2 is not None: newowner_address2 = newowner2['address'] tx = Transaction(*decode_utxo_id(input1), *decode_utxo_id(input2), cur12, newowner_address1, amount1, newowner_address2, amount2) if signatory1 is not None: key1 = signatory1['key'] tx.sign1(key1) if signatory2 is not None: key2 = signatory2['key'] tx.sign2(key2) spend_id = self.child_chain.apply_transaction(tx) self.submit_block() return spend_id def submit_block(self, signatory=AUTHORITY): signing_key = None if signatory is not None: signing_key = signatory['key'] block = self.child_chain.current_block if signing_key: block.sign(signing_key) self.child_chain.submit_block(block) def confirm(self, tx_id, signatory1, signatory2=None): tx = self.child_chain.get_transaction(tx_id) (blknum, _, _) = decode_utxo_id(tx_id) block_root = self.child_chain.get_block(blknum).root confirm_sigs = b'' for signatory in [x for x in [signatory1, signatory2] if x is not None]: confirm_sigs += confirm_tx(tx, block_root, signatory['key']) self.confirmations[tx_id] = confirm_sigs def start_deposit_exit(self, utxo_id, exitor): tx = self.child_chain.get_transaction(utxo_id) self.root_chain.transact({ 'from': exitor['address'] }).startDepositExit(utxo_id, NULL_ADDRESS_HEX, tx.amount1) def start_exit(self, utxo_id, exitor): tx = self.child_chain.get_transaction(utxo_id) sigs = tx.sig1 + tx.sig2 + self.confirmations[utxo_id] (blknum, _, _) = decode_utxo_id(utxo_id) block = self.child_chain.get_block(blknum) proof = block.merkle.create_membership_proof(tx.merkle_hash) self.root_chain.transact({ 'from': exitor['address'] }).startExit(utxo_id, tx.encoded, proof, sigs)
import rlp from werkzeug.wrappers import Request, Response from werkzeug.serving import run_simple from jsonrpc import JSONRPCResponseManager, dispatcher from ethereum import utils from plasma.child_chain.child_chain import ChildChain from plasma.root_chain.deployer import Deployer from plasma_core.constants import CONTRACT_ADDRESS, AUTHORITY from plasma_core.block import Block from plasma_core.transaction import Transaction root_chain = Deployer().get_contract_at_address("RootChain", CONTRACT_ADDRESS, concise=False) child_chain = ChildChain(AUTHORITY['address'], AUTHORITY['ecrecoveredAddr'], root_chain) @Request.application def application(request): # Dispatcher is dictionary {<method_name>: callable} dispatcher["submit_block"] = lambda block: child_chain.submit_block(rlp.decode(utils.decode_hex(block), Block)) dispatcher["apply_transaction"] = lambda transaction: child_chain.apply_transaction(rlp.decode(utils.decode_hex(transaction), Transaction)) dispatcher["get_transaction"] = lambda utxo_id: rlp.encode(child_chain.get_transaction(utxo_id), Transaction).hex() dispatcher["get_current_block"] = lambda: rlp.encode(child_chain.get_current_block(), Block).hex() dispatcher["get_current_block_num"] = lambda: child_chain.get_current_block_num() dispatcher["get_block"] = lambda blknum: rlp.encode(child_chain.get_block(blknum), Block).hex() response = JSONRPCResponseManager.handle( request.data, dispatcher) return Response(response.json, mimetype='application/json') if __name__ == '__main__': run_simple('localhost', 8546, application)
from werkzeug.serving import run_simple from jsonrpc import JSONRPCResponseManager, dispatcher from plasma.child_chain.child_chain import ChildChain from plasma.child_chain.partially_signed_transaction_pool import PartiallySignedTransactionPool from plasma.child_chain.block_auto_submitter import BlockAutoSubmitter from plasma.child_chain.finalize_exits_auto_submitter import FinalizeExitsAutoSubmitter # from plasma.child_chain.liquidity_provider import LiquidilyProvider from plasma.config import plasma_config from plasma.root_chain.deployer import Deployer deployer = Deployer() root_chain = deployer.get_contract_at_address( "RootChain", plasma_config['ROOT_CHAIN_CONTRACT_ADDRESS'], concise=False) partially_signed_transaction_pool = PartiallySignedTransactionPool() child_chain = ChildChain( plasma_config['AUTHORITY'], root_chain, partially_signed_transaction_pool=partially_signed_transaction_pool) BlockAutoSubmitter(child_chain, plasma_config['BLOCK_AUTO_SUMBITTER_INTERVAL']).start() FinalizeExitsAutoSubmitter( plasma_config['AUTHORITY'], root_chain, plasma_config['FINALIZE_EXITS_AUTO_SUBMITTER_INTERVAL']).start() # liquidity_provider = LiquidilyProvider(child_chain) def printKey(key): def decorator(func): @wraps(func) def wrapper(*args, **kwargs): print("Dispatcher: " + key) return func(*args, **kwargs)
from werkzeug.wrappers import Request, Response from werkzeug.serving import run_simple from jsonrpc import JSONRPCResponseManager, dispatcher from plasma.child_chain.child_chain import ChildChain from plasma.config import plasma_config from plasma.root_chain.deployer import Deployer root_chain = Deployer().get_contract_at_address( "RootChain", plasma_config['ROOT_CHAIN_CONTRACT_ADDRESS'], concise=False) child_chain = ChildChain(plasma_config['AUTHORITY'], root_chain) @Request.application def application(request): # Dispatcher is dictionary {<method_name>: callable} dispatcher["submit_block"] = lambda block: child_chain.submit_block(block) dispatcher[ "apply_transaction"] = lambda transaction: child_chain.apply_transaction( transaction) dispatcher[ "get_transaction"] = lambda blknum, txindex: child_chain.get_transaction( blknum, txindex) dispatcher["get_current_block"] = lambda: child_chain.get_current_block() dispatcher[ "get_current_block_num"] = lambda: child_chain.get_current_block_num() dispatcher["get_block"] = lambda blknum: child_chain.get_block(blknum) response = JSONRPCResponseManager.handle(request.data, dispatcher) return Response(response.json, mimetype='application/json') if __name__ == '__main__':