def lazy_function(): sig = ContractFunction.check_sig(function_sign) return JsonRPC.send(JsonRPC.eth_send_transaction( dict(tx, data=sig + AbiEncoder.encodes(function_args, function_args_type))), rpc_host=host)['result']
def temporary_transact(tx, host, dapp): if host == "http://47.254.66.11:26657": from py_nsbcli import Client, Admin from hexbytes import HexBytes admin = Admin() admin.set_rpc_host(host) cli = Client(admin) if tx['trans_type'] == "invoke": from contract.tendermint.option.contract import Option opt = Option(cli) opt.buy_option(tom, 5, bytes.fromhex(tx['dst'][2:])) else: from py_nsbcli.system_token import SystemToken token_cli = SystemToken(cli) print(token_cli.transfer(alice, HexBytes(tx['dst']), tx['fund'])) else: print(dapp.__dict__, host) dapp.unlockself(host) tx_json = JsonRPC.eth_send_transaction(tx) print(tx) resp = JsonRPC.send(tx_json, HTTP_HEADER, host)['result'] get_tx = JsonRPC.eth_get_transaction_receipt(resp) while True: response = JsonRPC.send(get_tx, HTTP_HEADER, host) if response['result'] is None: print("Exec...") time.sleep(1) continue else: print(response) break
def temporary_transact(tx, host): if host == "http://47.251.2.73:26657": from py_nsbcli import Client, Admin from py_nsbcli.system_token import SystemToken from hexbytes import HexBytes admin = Admin() admin.set_rpc_host(host) cli = Client(admin) token_cli = SystemToken(cli) print(token_cli.transfer(alice, HexBytes(tx['dst']), tx['fund'])) else: tx_json = JsonRPC.eth_send_transaction(tx) print(tx) resp = JsonRPC.send(tx_json, HTTP_HEADER, host)['result'] get_tx = JsonRPC.eth_get_transaction_receipt(resp) while True: response = JsonRPC.send(get_tx, HTTP_HEADER, host) if response['result'] is None: print("Exec...") time.sleep(1) continue else: print(response) break
def lazy_function(transaction=None): if transaction is None: transaction = {} return JsonRPC.send(JsonRPC.eth_send_transaction( dict(transaction, data=function_sign + AbiEncoder.encodes(function_args, function_args_type))), rpc_host=host)['result']
def make_contract(owners, signature, rlped_txs, tx_count, ves, bytescode=None, bin_dir=isc_bin_dir): try: rlped_txs = HexBytes(rlped_txs) encoded_data = AbiEncoder.encodes( [ owners, [0, 0, 0], HexBytes(ETHSIGN_HEADER + bytes(str(len(rlped_txs)).encode(ENC)) + bytes(rlped_txs)).hex(), signature, keccak(ETHSIGN_HEADER + b'\x36\x35' + HexBytes(signature)), tx_count ], ['address[]', 'uint256[]', 'bytes', 'bytes', 'bytes32', 'uint256'] ) if bytescode is None: bytescode = FileLoad.getbytecode(bin_dir) ves.unlockself() tx_json = JsonRPC.eth_send_transaction({ 'from': ves.address, 'data': bytescode.decode(ENC) + encoded_data, 'gas': hex(8000000) }) # print(tx_json) response = JsonRPC.send(tx_json, rpc_host=ves.chain_host) rp_json = JsonRPC.eth_get_transaction_receipt(response['result']) except Exception as e: isc_log.debug('ISCBulidError: {}'.format(str(e))) raise e while True: try: response = JsonRPC.send(rp_json, rpc_host=ves.chain_host) if response['result'] is None: console_logger.info("Contract is deploying, please stand by") time.sleep(2) continue console_logger.info("got Transaction_result {}".format(response['result'])) block_number = response['result']['blockNumber'] contract_addr = response['result']['contractAddress'] cd_json = JsonRPC.eth_get_code(contract_addr, block_number) response = JsonRPC.send(cd_json, rpc_host=ves.chain_host) if response['result'] == '0x': raise IndexError("Contract deployment failed") return contract_addr except Exception as e: isc_log.debug('ISCBulidError: {exec}'.format(exec=str(e)), extra={"addr": ""}) raise e
def send(self, trans, passphrase=None): """ transact the contract_methods :param trans: transaction with contract invocation's information :param passphrase: :return: None """ if passphrase is None: passphrase = self.info[trans.chain_host] if trans.chain_type == 'Ethereum': unlock = JsonRPC.personal_unlock_account( self.info[trans.chain_host]['address'], passphrase, 20) tx_response = JsonRPC.send(unlock, HTTP_HEADER, trans.chain_host) print( json.dumps(tx_response, sort_keys=True, indent=4, separators=(', ', ': '))) packet_transaction = JsonRPC.eth_send_transaction(trans.jsonize()) tx_response = JsonRPC.send(packet_transaction, HTTP_HEADER, trans.chain_host) print( json.dumps(tx_response, sort_keys=True, indent=4, separators=(', ', ': '))) tx_hash = tx_response['result'] query = JsonRPC.eth_get_transaction_receipt(tx_hash) while True: tx_response = JsonRPC.send(query, HTTP_HEADER, trans.chain_host) if tx_response['result'] is None: print("transacting") time.sleep(2) continue break print( json.dumps(tx_response, sort_keys=True, indent=4, separators=(', ', ': '))) else: raise TypeError("unsupported chain-type: ", +trans.chain_type)
def temporary_transact(tx, host): if host == "http://47.251.2.73:26657": from py_nsbcli import Client, Admin admin = Admin() admin.set_rpc_host(host) cli = Client(admin) from contract.tendermint.delegate.contract import DelegateContract opt = DelegateContract(cli) print(opt.vote(tom, bytes.fromhex(tx['dst'][2:]))) else: tx_json = JsonRPC.eth_send_transaction(tx) print(tx) resp = JsonRPC.send(tx_json, HTTP_HEADER, host)['result'] get_tx = JsonRPC.eth_get_transaction_receipt(resp) while True: response = JsonRPC.send(get_tx, HTTP_HEADER, host) print("result", response) break
print(ves.nsb.is_active_isc(isc.address)) user_table = [(dapp_x, ves), (dapp_y, ves)] unlock_table = [enc_info_x, enc_info_relay_y] session_id = int(session_content[0]) from uiputils.ethtools import AbiEncoder import random testnumber = random.randint(0, 100) tx = JsonRPC.eth_send_transaction({ 'from': dapp_x.info['http://127.0.0.1:8545']['address'], 'to': "0x7c7b26fa65e091f7b9f23db77ad5f714f1dae5ea", "data": "0x67eb4a3c" + AbiEncoder.encodes([testnumber], ['uint']), "gas": hex(7999999) }) dapp_x.unlockself('http://127.0.0.1:8545') console_logger.info('genuineValue set: {0}\n response: {1}'.format( testnumber, JsonRPC.send(tx, HTTP_HEADER, 'http://127.0.0.1:8545'))) for idx, [u, v] in enumerate(user_table): # assert tx_intent is on ISC # Part_A # inited ############################################################################################## # compute on_chain_tx tx = tx_intents.intents[idx].jsonize()
print(tx) atte = u.init_attestation(tx, StateType.inited, int(session_content[0]), 0) # update # relay atte_rec = v.receive(atte.encode()) rlped_data = v.sign_attestation(atte_rec) # update # check u.receive(rlped_data) # open unlock_user(tx['from']) tx_json = JsonRPC.eth_send_transaction(tx) print( JsonRPC.send(tx_json, HTTP_HEADER, tx_intents.intents[idx].chain_host)) # verify_transaction_state? atte = u.init_attestation(tx, StateType.open, int(session_content[0]), 0) # v.receive(atte.encode()) atte = v.init_attestation(tx, StateType.opened, int(session_content[0]), 0) # ves check ves.receive(atte.encode()) # close