async def test_interledger_with_two_ethereum_transaction_failure(config): # set up ledgerA and ledgerB tokenId = uuid4().int total_cost = 0 (contract_minter_A, contract_address_A, contract_abi_A, url, portA) = setUp(config, 'left') (contract_minter_B, contract_address_B, contract_abi_B, url, portB) = setUp(config, 'right') w3_A = Web3(Web3.HTTPProvider(url+":"+str(portA))) w3_B = Web3(Web3.HTTPProvider(url+":"+str(portB))) token_instance_A = w3_A.eth.contract(abi=contract_abi_A, address=contract_address_A) token_instance_B = w3_B.eth.contract(abi=contract_abi_B, address=contract_address_B) (tokenId, cost) = await create_token(contract_minter_A, token_instance_A, w3_A, tokenId) # Activate token in ledgerA cost = await accept_token(contract_minter_A, token_instance_A, w3_A, tokenId) assert token_instance_A.functions.getStateOfToken(tokenId).call() == 2 #the token will not be created on ledgerB to emulate transaction failure on the responder side print("Test setup ready, performing measurement for unsuccessful asset transfer") with patch("data_transfer.interledger.Interledger.cleanup") as mock_cleanup: # mock cleanup to check the transfer reaches the end # Create interledger with a bridge in direction from A to B print("Building Interledger bridge A -> B...") start_time = time.time() inititator = EthereumInitiator(contract_minter_A, contract_address_A, contract_abi_A, url, port=portA) responder = EthereumResponder(contract_minter_B, contract_address_B, contract_abi_B, url, port=portB) interledger = Interledger(inititator, responder) print("Creating Intelredger run coroutine...") interledger_task = asyncio.ensure_future(interledger.run()) print("A smart contract call in ledger A marks the token in 'TransferOut'...") (data, blockNumber,gas_used)= await transfer_token(contract_minter_A, token_instance_A, w3_A, tokenId) await asyncio.sleep(1.5) # Simulate Interledger running, should be longer than block time tx_hash = interledger.results_abort[0]["abort_tx_hash"] assert token_instance_A.functions.getStateOfToken(tokenId).call() == 2 elapsed_time = time.time() - start_time print("Time interval: ", elapsed_time) total_cost += gas_used total_cost += calculate_used_gas(tx_hash, w3_A) print("Total cost: ", total_cost) print("Stopping Interledger run coroutine") interledger.stop() await interledger_task print("*----------------------------------------------------*")
def test_init(config): # Setup web3 and state (contract_minter, contract_address, contract_abi, url, port) = setUp(config, 'right') resp = EthereumResponder(contract_minter, contract_address, contract_abi, url, port=port) w3 = Web3(Web3.HTTPProvider(url+":"+str(port))) token_instance = w3.eth.contract(abi=contract_abi, address=contract_address) assert resp.web3.isConnected() assert resp.minter == contract_minter #assert resp.contract == token_instance assert resp.timeout == 120
async def test_responder_receive_reject_event(config): (contract_minter, contract_address, contract_abi, url, port) = setUp(config, 'right') w3 = Web3(Web3.HTTPProvider(url+":"+str(port))) token_instance = w3.eth.contract(abi=contract_abi, address=contract_address) # # Create a token (tokenId,cost) = await create_token(contract_minter, token_instance, w3) assert token_instance.functions.getStateOfToken(tokenId).call() == 0 await accept_token(contract_minter, token_instance, w3, tokenId) assert token_instance.functions.getStateOfToken(tokenId).call() == 2 ## Test Ethereum Responder ### resp = EthereumResponder(contract_minter, contract_address, contract_abi, url, port=port) #passing an asset with the wrong state to simulate emitting a reject event nonce = "42" data = encode_abi(['uint256'], [tokenId]) result = await resp.send_data(nonce, data) tx_hash = result["tx_hash"] tx_info = w3.eth.getTransaction(tx_hash) tx_receipt = w3.eth.getTransactionReceipt(tx_hash) assert tx_info ['blockHash'] != None assert tx_info ['hash'] == tx_hash assert tx_info ['to'] == contract_address # check function name and abi decoded_input = token_instance.decode_function_input(tx_info['input']) assert decoded_input[0].fn_name == token_instance.get_function_by_name("interledgerReceive").fn_name assert decoded_input[0].abi == token_instance.get_function_by_name("interledgerReceive").abi # check for accepted/rejected events logs_accept = token_instance.events.InterledgerEventAccepted().processReceipt(tx_receipt) logs_reject = token_instance.events.InterledgerEventRejected().processReceipt(tx_receipt) assert len(logs_accept) == 0 assert len(logs_reject) == 1 assert logs_reject[0]['args']['nonce'] == int(nonce) assert result["status"] == False assert result["error_code"] == ErrorCode.APPLICATION_REJECT assert result["message"] == "InterledgerEventRejected() event received"
async def test_responder_receive(config): (contract_minter, contract_address, contract_abi, url, port) = setUp(config, 'right') w3 = Web3(Web3.HTTPProvider(url+":"+str(port))) token_instance = w3.eth.contract(abi=contract_abi, address=contract_address) # # Create a token (tokenId,cost) = await create_token(contract_minter, token_instance, w3) assert token_instance.functions.getStateOfToken(tokenId).call() == 0 ## Test Ethereum Responder ### resp = EthereumResponder(contract_minter, contract_address, contract_abi, url, port=port) data = encode_abi(['uint256'], [tokenId]) nonce= "42" result = await resp.send_data(nonce, data) print(result) tx_hash = result["tx_hash"] tx_info = w3.eth.getTransaction(tx_hash) tx_receipt = w3.eth.getTransactionReceipt(tx_hash) assert tx_info ['blockHash'] != None assert tx_info ['hash'] == tx_hash assert tx_info ['to'] == contract_address # check function name and abi decoded_input = token_instance.decode_function_input(tx_info['input']) assert decoded_input[0].fn_name == token_instance.get_function_by_name("interledgerReceive").fn_name assert decoded_input[0].abi == token_instance.get_function_by_name("interledgerReceive").abi # check function parameters assert decoded_input[1]['data'] == data # check for accepted/rejected events logs_accept = token_instance.events.InterledgerEventAccepted().processReceipt(tx_receipt) logs_reject = token_instance.events.InterledgerEventRejected().processReceipt(tx_receipt) assert len(logs_accept) == 1 assert logs_accept[0]['args']['nonce'] == int(nonce) assert len(logs_reject) == 0 assert result["status"] == True
async def test_responder_receive_transaction_failure(config): (contract_minter, contract_address, contract_abi, url, port) = setUp(config, 'right') w3 = Web3(Web3.HTTPProvider(url+":"+str(port))) token_instance = w3.eth.contract(abi=contract_abi, address=contract_address) # # Create a token (tokenId,cost) = await create_token(contract_minter, token_instance, w3) assert token_instance.functions.getStateOfToken(tokenId).call() == 0 ## Test Ethereum Responder ### resp = EthereumResponder(contract_minter, contract_address, contract_abi, url, port=port) #passing wrong tokenId to simulate transaction failure nonce, data = "42", b"dummy" result = await resp.send_data(nonce, data) assert result["status"] == False assert result["tx_hash"] == None assert result["error_code"] == ErrorCode.TRANSACTION_FAILURE assert result["message"].find('revert') >= 0
async def test_interledger_with_two_ethereum_multiple_transfer(config): total_cost = 0 # set up ledgerA and ledgerB print("Test setup ready, performing measurement for multiple asset transfers") (contract_minter_A, contract_address_A, contract_abi_A, url, portA) = setUp(config, 'left') (contract_minter_B, contract_address_B, contract_abi_B, url, portB) = setUp(config, 'right') w3_A = Web3(Web3.HTTPProvider(url+":"+str(portA))) w3_B = Web3(Web3.HTTPProvider(url+":"+str(portB))) token_instance_A = w3_A.eth.contract(abi=contract_abi_A, address=contract_address_A) token_instance_B = w3_B.eth.contract(abi=contract_abi_B, address=contract_address_B) # prepare for asset transfer simultaneous_transfers = [1, 2, 5, 10, 20, 50] #simultaneous_transfers = [2, 5, 10] for transfers in simultaneous_transfers: tokens = [] # needed for token creation create = [] # these contain tokens transiting between various states transfer_out = [] need_accept = [] accept = [] completed = [] # Create tokens in both ledgers and set their state in ledger A start_time = time.time() filter_A = token_instance_A.events.NewTokenAsset().createFilter(fromBlock = 'latest') filter_B = token_instance_B.events.NewTokenAsset().createFilter(fromBlock = 'latest') for i in range(transfers): (tokenId, tx_hash) = non_blocking_create_token(contract_minter_A, token_instance_A, w3_A) (tokenId, tx_hash) = non_blocking_create_token(contract_minter_B, token_instance_B, w3_B, tokenId) create.append(tokenId) while(True): # Check wherever token has been created in both ledgers to_remove = [] entries = filter_A.get_new_entries() for entry in entries: token = entry['args']['tokenId'] if token in create: need_accept.append(token) to_remove.append(token) create = [x for x in create if x not in to_remove] # Accept created tokens in ledger A to_remove = [] for token in need_accept: non_blocking_accept_token(contract_minter_A, token_instance_A, w3_A, token) accept.append(token) to_remove.append(token) need_accept = [x for x in need_accept if x not in to_remove] # Check wherever token is in Here state in ledger A to_remove = [] for token in accept: if token_instance_A.functions.getStateOfToken(tokenId).call() == 2: tokens.append(token) to_remove.append(token) accept = [x for x in accept if x not in to_remove] if (len(tokens) == transfers) and (len(need_accept) == 0) and (len(accept) == 0): # all tokens have been created and accepted in ledger A break elapsed_time = time.time() - start_time print(f"Token setup ready for {transfers} simultaneous transfers, took: {elapsed_time} seconds") #print("\t", tokens) inititator = EthereumInitiator(contract_minter_A, contract_address_A, contract_abi_A, url, port=portA) responder = EthereumResponder(contract_minter_B, contract_address_B, contract_abi_B, url, port=portB) interledger = Interledger(inititator, responder) print("Creating Intelredger run coroutine") start_time = time.time() interledger_task = asyncio.ensure_future(interledger.run()) # Initiate transfer by calling transferOut for each token for token in tokens: tx_hash1 = non_blocking_transfer_token(contract_minter_A, token_instance_A, w3_A, token) transfer_out.append(token) while(True): # Check wherever some tokens have moved to Here state on ledger B and Not Here state on ledger to_remove = [] for token in transfer_out: if (token_instance_B.functions.getStateOfToken(token).call() == 2) and (token_instance_A.functions.getStateOfToken(token).call() == 0): completed.append(token) to_remove.append(token) transfer_out = [x for x in transfer_out if x not in to_remove] # Check wherever we have completed all transfers if len(completed) == transfers: elapsed_time = time.time() - start_time print(f"Took {elapsed_time} seconds for completing {transfers} transfers\n") break # Simulate Interledger running await asyncio.sleep(0.00001) interledger.stop() await interledger_task
async def test_interledger_with_two_ethereum_multiple_transfer(config): #set up ledgerA and ledgerB ids = [[],[],[],[],[],[]] (contract_minter_A, contract_address_A, contract_abi_A, url, portA) = setUp(config, 'left') (contract_minter_B, contract_address_B, contract_abi_B, url, portB) = setUp(config, 'right') w3_A = Web3(Web3.HTTPProvider(url+":"+str(portA))) w3_B = Web3(Web3.HTTPProvider(url+":"+str(portB))) token_instance_A = w3_A.eth.contract(abi=contract_abi_A, address=contract_address_A) token_instance_B = w3_B.eth.contract(abi=contract_abi_B, address=contract_address_B) #prepare for asset transfer indexes = [2, 5, 10, 20, 50, 100] # for i in range (0,6): index = indexes[i] for j in range(0, index): tokenId = uuid4().int ids[i].append(tokenId) (tokenId,cost) = await create_token(contract_minter_A, token_instance_A, w3_A, tokenId) (tokenId,cost) = await create_token(contract_minter_B, token_instance_B, w3_B, tokenId) assert token_instance_B.functions.getStateOfToken(tokenId).call() == 0 assert token_instance_A.functions.getStateOfToken(tokenId).call() == 0 #Activate token in ledgerA cost = await accept_token(contract_minter_A, token_instance_A, w3_A, tokenId) assert token_instance_A.functions.getStateOfToken(tokenId).call() == 2 print("Test setup ready, performing measurement for multiple asset transfers") with patch("data_transfer.interledger.Interledger.cleanup") as mock_cleanup: #mock cleanup to check the transfer reaches the end #Create interledger with a bridge in direction from A to B print("Building Interledger bridge A -> B") inititator = EthereumInitiator(contract_minter_A, contract_address_A, contract_abi_A, url, port=portA) responder = EthereumResponder(contract_minter_B, contract_address_B, contract_abi_B, url, port=portB) interledger = Interledger(inititator, responder) print("Creating Intelredger run coroutine") interledger_task = asyncio.ensure_future(interledger.run()) print("A smart contract call in ledger A marks the token in 'TransferOut'") start_time = time.time() total_cost = 0 for j in range(0, index): (data, blockNumber,gas_used)= await transfer_token(contract_minter_A, token_instance_A, w3_A, ids[i][j]) total_cost += gas_used await asyncio.sleep(1.5*index) # Simulate Interledger running, should be longer than block time for j in range(0, index): tx_hash1 = interledger.transfers_sent[j].result["tx_hash"] tx_hash2 = interledger.results_commit[j]["commit_tx_hash"] assert token_instance_B.functions.getStateOfToken(ids[i][j]).call() == 2 # Here assert token_instance_A.functions.getStateOfToken(ids[i][j]).call() == 0 # Not Here total_cost += calculate_used_gas(tx_hash1, w3_B) total_cost += calculate_used_gas(tx_hash2, w3_A) elapsed_time = time.time() - start_time print("number of transfers: ", index) print("time: ", elapsed_time) print("Total cost: ", total_cost) print("Stopping Interledger run coroutine") interledger.stop() await interledger_task print("*----------------------------------------------------*")
async def test_interledger_with_two_ethereum_transaction_failure(config): # set up ledgerA and ledgerB tokenId = uuid4().int (contract_minter_A, contract_address_A, contract_abi_A, url, portA) = setUp(config, 'left') (contract_minter_B, contract_address_B, contract_abi_B, url, portB) = setUp(config, 'right') w3_A = Web3(Web3.HTTPProvider(url + ":" + str(portA))) w3_B = Web3(Web3.HTTPProvider(url + ":" + str(portB))) token_instance_A = w3_A.eth.contract(abi=contract_abi_A, address=contract_address_A) token_instance_B = w3_B.eth.contract(abi=contract_abi_B, address=contract_address_B) await create_token(contract_minter_A, token_instance_A, w3_A, tokenId) #the token will not be created on ledgerB to emulate transaction failure on the responder side assert token_instance_A.functions.getStateOfToken(tokenId).call() == 0 print("Test setup ready") with patch( "data_transfer.interledger.Interledger.cleanup") as mock_cleanup: # mock cleanup to check the transfer reaches the end # Create interledger with a bridge in direction from A to B print("Building Interledger bridge A -> B...") inititator = EthereumInitiator(contract_minter_A, contract_address_A, contract_abi_A, url, port=portA) responder = EthereumResponder(contract_minter_B, contract_address_B, contract_abi_B, url, port=portB) interledger = Interledger(inititator, responder) print("Creating Intelredger run coroutine...") interledger_task = asyncio.ensure_future(interledger.run()) print( "A smart contract call in ledger A marks the token in 'TransferOut'..." ) # Activate token in ledgerA await accept_token(contract_minter_A, token_instance_A, w3_A, tokenId) assert token_instance_A.functions.getStateOfToken(tokenId).call() == 2 (data, blockNumber, gas_used) = await transfer_token(contract_minter_A, token_instance_A, w3_A, tokenId) assert token_instance_A.functions.getStateOfToken(tokenId).call() == 1 await asyncio.sleep( 4 ) # Simulate Interledger running, should be longer than block time assert len(interledger.transfers) == 1 assert len(interledger.results_abort) == 1 tx_hash = interledger.results_abort[0]["tx_hash"] status = interledger.results_abort[0]["status"] assert tx_hash == None assert status == False assert token_instance_A.functions.getStateOfToken(tokenId).call() == 2 assert len(interledger.results_commit) == 0 assert len(interledger.results_abort) == 1 tx_hash = interledger.results_abort[0]["abort_tx_hash"] status = interledger.results_abort[0]["abort_status"] assert status == True tx_info = w3_A.eth.getTransaction(tx_hash) tx_receipt = w3_A.eth.getTransactionReceipt(tx_hash) # check also other information about the transaction assert tx_info['hash'] == tx_hash assert tx_info['blockHash'] != None assert tx_info['to'] == contract_address_A print(tx_info) # check function name and abi decoded_input = token_instance_A.decode_function_input( tx_info['input']) assert decoded_input[ 0].fn_name == token_instance_A.get_function_by_name( "interledgerAbort").fn_name assert decoded_input[0].abi == token_instance_A.get_function_by_name( "interledgerAbort").abi # check function parameters assert decoded_input[1]['tokenId'] == tokenId assert decoded_input[1]['reason'] == 2 #ErrorCode.TRANSACTION_FAILURE print("Stopping Interledger run coroutine") interledger.stop() await interledger_task
async def test_interledger_with_two_ethereum(config): # set up ledgerA and ledgerB tokenId = uuid4().int (contract_minter_A, contract_address_A, contract_abi_A, url, portA) = setUp(config, 'left') (contract_minter_B, contract_address_B, contract_abi_B, url, portB) = setUp(config, 'right') w3_A = Web3(Web3.HTTPProvider(url + ":" + str(portA))) w3_B = Web3(Web3.HTTPProvider(url + ":" + str(portB))) token_instance_A = w3_A.eth.contract(abi=contract_abi_A, address=contract_address_A) token_instance_B = w3_B.eth.contract(abi=contract_abi_B, address=contract_address_B) await create_token(contract_minter_A, token_instance_A, w3_A, tokenId) await create_token(contract_minter_B, token_instance_B, w3_B, tokenId) assert token_instance_B.functions.getStateOfToken(tokenId).call() == 0 assert token_instance_A.functions.getStateOfToken(tokenId).call() == 0 print("Test setup ready") with patch( "data_transfer.interledger.Interledger.cleanup") as mock_cleanup: # mock cleanup to check the transfer reaches the end # Create interledger with a bridge in direction from A to B print("Building Interledger bridge A -> B") inititator = EthereumInitiator(contract_minter_A, contract_address_A, contract_abi_A, url, port=portA) responder = EthereumResponder(contract_minter_B, contract_address_B, contract_abi_B, url, port=portB) interledger = Interledger(inititator, responder) print("Creating Intelredger run coroutine") interledger_task = asyncio.ensure_future(interledger.run()) print( "A smart contract call in ledger A marks the token in 'TransferOut'" ) # Activate token in ledgerA await accept_token(contract_minter_A, token_instance_A, w3_A, tokenId) assert token_instance_A.functions.getStateOfToken(tokenId).call() == 2 (data, blockNumber, gas_used) = await transfer_token(contract_minter_A, token_instance_A, w3_A, tokenId) assert token_instance_A.functions.getStateOfToken(tokenId).call() == 1 await asyncio.sleep( 4 ) # Simulate Interledger running, should be longer than block time assert token_instance_B.functions.getStateOfToken( tokenId).call() == 2 # Here assert token_instance_A.functions.getStateOfToken( tokenId).call() == 0 # Not Here assert len(interledger.transfers) == 1 assert len(interledger.results_commit) == 1 print(interledger.results_commit[0]) tx_hash = interledger.results_commit[0]["tx_hash"] status = interledger.results_commit[0]["status"] assert status == True tx_info = w3_B.eth.getTransaction(tx_hash) tx_receipt = w3_B.eth.getTransactionReceipt(tx_hash) # check also other information about the transaction assert tx_info['hash'] == tx_hash assert tx_info['blockHash'] != None assert tx_info['to'] == contract_address_B print(tx_info) # check function name and abi decoded_input = token_instance_B.decode_function_input( tx_info['input']) assert decoded_input[ 0].fn_name == token_instance_B.get_function_by_name( "interledgerReceive").fn_name assert decoded_input[0].abi == token_instance_B.get_function_by_name( "interledgerReceive").abi # check function parameters assert decoded_input[1]['data'] == data nonce = decoded_input[1]['nonce'] # check for accepted/rejected events logs_accept = token_instance_B.events.InterledgerEventAccepted( ).processReceipt(tx_receipt) logs_reject = token_instance_B.events.InterledgerEventRejected( ).processReceipt(tx_receipt) assert len(logs_accept) == 1 assert logs_accept[0]['args']['nonce'] == nonce assert len(logs_reject) == 0 assert len(interledger.results_commit) == 1 tx_hash = interledger.results_commit[0]["commit_tx_hash"] status = interledger.results_commit[0]["commit_status"] assert status == True tx_info = w3_A.eth.getTransaction(tx_hash) tx_receipt = w3_A.eth.getTransactionReceipt(tx_hash) # check also other information about the transaction assert tx_info['hash'] == tx_hash assert tx_info['blockHash'] != None assert tx_info['to'] == contract_address_A print(tx_info) # check function name and abi decoded_input = token_instance_A.decode_function_input( tx_info['input']) assert decoded_input[ 0].fn_name == token_instance_A.get_function_by_signature( 'interledgerCommit(uint256)').fn_name assert decoded_input[ 0].abi == token_instance_A.get_function_by_signature( 'interledgerCommit(uint256)').abi # check function parameters assert decoded_input[1]['tokenId'] == tokenId print("Stopping Interledger run coroutine") interledger.stop() await interledger_task print("*----------*") print("Building Interledger bridge B -> A") inititator = EthereumInitiator(contract_minter_B, contract_address_B, contract_abi_B, url, port=portB) responder = EthereumResponder(contract_minter_A, contract_address_A, contract_abi_A, url, port=portA) interledger = Interledger(inititator, responder) print("Creating Intelredger run coroutine") interledger_task = asyncio.ensure_future(interledger.run()) print( "A smart contract call in ledger B marks the token in 'TransferOut'" ) (data, blockNumber, gas_used) = await transfer_token(contract_minter_B, token_instance_B, w3_B, tokenId) assert token_instance_B.functions.getStateOfToken(tokenId).call() == 1 await asyncio.sleep( 4 ) # Simulate Interledger running, should be longer than block time assert token_instance_A.functions.getStateOfToken(tokenId).call() == 2 assert token_instance_B.functions.getStateOfToken(tokenId).call() == 0 assert len(interledger.transfers) == 1 assert len(interledger.results_commit) == 1 tx_hash = interledger.results_commit[0]["tx_hash"] status = interledger.results_commit[0]["status"] assert status == True tx_info = w3_A.eth.getTransaction(tx_hash) tx_receipt = w3_A.eth.getTransactionReceipt(tx_hash) assert tx_info['blockHash'] != None assert tx_info['hash'] == tx_hash assert tx_info['to'] == contract_address_A print(tx_info) # check function name and abi decoded_input = token_instance_A.decode_function_input( tx_info['input']) assert decoded_input[ 0].fn_name == token_instance_A.get_function_by_name( "interledgerReceive").fn_name assert decoded_input[0].abi == token_instance_A.get_function_by_name( "interledgerReceive").abi # check function parameters assert decoded_input[1]['data'] == data nonce = decoded_input[1]['nonce'] # check for accepted/rejected events logs_accept = token_instance_A.events.InterledgerEventAccepted( ).processReceipt(tx_receipt) logs_reject = token_instance_A.events.InterledgerEventRejected( ).processReceipt(tx_receipt) assert len(logs_accept) == 1 assert logs_accept[0]['args']['nonce'] == nonce assert len(logs_reject) == 0 assert len(interledger.results_commit) == 1 tx_hash = interledger.results_commit[0]["commit_tx_hash"] status = interledger.results_commit[0]["commit_status"] assert status == True tx_info = w3_B.eth.getTransaction(tx_hash) tx_receipt = w3_B.eth.getTransactionReceipt(tx_hash) # check also other information about the transaction assert tx_info['hash'] == tx_hash assert tx_info['blockHash'] != None assert tx_info['to'] == contract_address_B print(tx_info) # check function name and abi decoded_input = token_instance_B.decode_function_input( tx_info['input']) assert decoded_input[ 0].fn_name == token_instance_B.get_function_by_signature( 'interledgerCommit(uint256)').fn_name assert decoded_input[ 0].abi == token_instance_B.get_function_by_signature( 'interledgerCommit(uint256)').abi # check function parameters assert decoded_input[1]['tokenId'] == tokenId print("Stopping Interledger run coroutine") interledger.stop() await interledger_task
async def async_main(): assert sys.argv[1] # configuration file, e.g. local-config-HF-ETH.cfg config_file = sys.argv[1] parser = ConfigParser() try: parser.read(config_file) except: print("Parsing configuration fails...") exit(-1) print( "Parsing configuarations for HyperLedger Fabric network interaction..." ) # parse the configs for network at left side (net_profile, channel_name, cc_name, cc_version, org_name, user_name, peer_name) = parse_fabric(parser, 'left1') net_profile = os.path.join('.', net_profile) # set up channel and get client cli = await channel_setup(net_profile, channel_name, org_name, user_name) # deploy chaincodes for data sender await data_sender_setup(cli, net_profile, channel_name, cc_name, cc_version, org_name, user_name, peer_name) # connect to initiator 1 initiator1 = FabricInitiator(net_profile=net_profile, channel_name=channel_name, cc_name=cc_name, cc_version=cc_version, org_name=org_name, user_name=user_name, peer_name=peer_name) print("*** Have the Interledger initiator 1 connected ***") # parse the configs for network at right side (net_profile, channel_name, cc_name, cc_version, org_name, user_name, peer_name) = parse_fabric(parser, 'right2') net_profile = os.path.join('.', net_profile) # deploy chaincodes for data receiver await data_receiver_setup(cli, net_profile, channel_name, cc_name, cc_version, org_name, user_name, peer_name) # connect to responder 2 responder2 = FabricResponder(net_profile=net_profile, channel_name=channel_name, cc_name=cc_name, cc_version=cc_version, org_name=org_name, user_name=user_name, peer_name=peer_name) print("*** Have the Interledger responder 2 connected ***") # parse ethereum network (minter, contract_address, contract_abi, url, port, private_key, password, poa) = parse_ethereum(parser, "right1") # connect responder 1 responder1 = EthereumResponder(minter, contract_address, contract_abi, url, port, private_key, password, poa) print("*** Have the Interledger responder 1 connected ***") # parse ethereum network (minter, contract_address, contract_abi, url, port, private_key, password, poa) = parse_ethereum(parser, "left2") # connect initiator 2 initiator2 = EthereumInitiator(minter, contract_address, contract_abi, url, port, private_key, password, poa) print("*** Have the Interledger initiator 2 connected ***") # instantiate the Interledger components interledger1 = Interledger(initiator1, responder1) print("*** Have the interledger ready for HF --> ETH ***") interledger2 = Interledger(initiator2, responder2) print("*** Have the interledger ready for ETH --> HF ***") print('\n' * 5) print("*********************************************") print("Data transfer: Hyperledger Fabric => Ethereum") print("*********************************************") task1 = asyncio.ensure_future(interledger1.run()) set_gopath() await asyncio.sleep(5) org1_admin = cli.get_user(org_name='org1.example.com', name='Admin') # emit data print(f"--- emit data at: {datetime.now()} ---") args = ['0xabc123'] # The response should be true if succeed response = await cli.chaincode_invoke(requestor=org1_admin, channel_name='mychannel', peers=['peer0.org1.example.com'], args=args, cc_name='data_sender', fcn='emitData', wait_for_event=True) await asyncio.sleep(3) interledger1.stop() await asyncio.sleep(1) task1.cancel() print('\n' * 5) print("*********************************************") print("Data transfer: Ethereum => Hyperledger Fabric") print("*********************************************") task2 = asyncio.ensure_future(interledger2.run()) await asyncio.sleep(5) # prepare data sender contract for emitting data w3 = Web3(Web3.HTTPProvider(url + ":" + str(port))) data_sender = w3.eth.contract(abi=contract_abi, address=contract_address) tx_hash = data_sender.functions.emitData(b"0xdef456").transact( {'from': minter}) w3.eth.waitForTransactionReceipt(tx_hash) await asyncio.sleep(3) interledger2.stop() await asyncio.sleep(1) task2.cancel() exit(0)