def tiat_create_txns(contract, src_acc, dest_accs, amount): # Clear any cached sessions. This is needed to ensure multiple processes # don't try to reuse the same TCP connection, which would lead to havoc LocalNet = chain.BlockChain(API_ENDPOINT, version=1, network_id=0) chain.set_active_chain(LocalNet) src_acc = Account(private_key=src_acc.private_key) contract = Contract.load_from_address(contract.address, load_state=False) txn_info_list = [] contract.account = src_acc src_addr = src_acc.bech32_address orig_nonce = nonces.get(src_addr, src_acc.get_nonce()) for dest_acc in dest_accs: try: dest = dest_acc.address0x txn_info = contract.call( method="Transfer", params=[ Contract.value_dict("to", "ByStr20", dest), Contract.value_dict("tokens", "Uint128", str(amount)) ], nonce=new_nonce(src_acc), confirm=False) txn_info_list.append(txn_info) print(json.dumps(src_acc.last_params), file=sys.stderr) print("Created {} transactions".format(len(txn_info_list))) except Exception as e: print("Could not send from {} to {}: {}".format( src_acc.address0x, dest, e)) nonce_now = nonces.get(src_addr, src_acc.get_nonce()) # print("{}: created {} transactions; nonce went from {} to {}".format(src_acc.bech32_address, len(txn_info_list), orig_nonce, nonce_now)) return txn_info_list, src_acc, nonce_now
def test_transfer_confirm(self): account = Account(address="b50c2404e699fd985f71b2c3f032059f13d6543b") print(account) balance1 = account.get_balance() print("Account1 balance", balance1) with pytest.raises(RuntimeError): account.transfer("to_addr", 1) account2 = Account.from_keystore("zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) print(account2) balance = account2.get_balance() print("Account2 balance", balance) assert balance > 0 result = account2.transfer(account.checksum_address, Zil(10.3), confirm=True, timeout=300, sleep=20) print("Transfer Result", result) pprint(account2.last_params) pprint(account2.last_txn_info) pprint(account2.last_txn_details) balance2 = account.get_balance() print("Account1 balance", balance2) assert balance2 >= balance1 + 10.299 account = Account(private_key="d0b47febbef2bd0c4a4ee04aa20b60d61eb02635e8df5e7fd62409a2b1f5ddf8") result = account.transfer(account2.bech32_address, 10.3, confirm=True, timeout=600, sleep=20) print("Transfer Result", result) pprint(account2.last_params) pprint(account2.last_txn_info) pprint(account2.last_txn_details)
def iat_create_txns(src_acc, dest_accs, zils): # Clear any cached sessions. This is needed to ensure multiple processes # don't try to reuse the same TCP connection, which would lead to havoc LocalNet = chain.BlockChain(API_ENDPOINT, version=1, network_id=0) chain.set_active_chain(LocalNet) src_acc = Account(private_key=src_acc.private_key) txn_info_list = [] src_addr = src_acc.bech32_address orig_nonce = nonces.get(src_addr, src_acc.get_nonce()) for dest_acc in dest_accs: try: dest = dest_acc.bech32_address txn_info = src_acc.transfer(to_addr=dest, zils=zils, nonce=new_nonce(src_acc), gas_price=100) txn_info_list.append(txn_info) print(json.dumps(src_acc.last_params), file=sys.stderr) print("Created {} transactions".format(len(txn_info_list))) except Exception as e: print("Could not send from {} to {}: {}".format(src_addr, dest, e)) nonce_now = nonces.get(src_addr, src_acc.get_nonce()) # print("{}: created {} transactions; nonce went from {} to {}".format(src_acc.bech32_address, len(txn_info_list), orig_nonce, nonce_now)) return txn_info_list, src_acc, nonce_now
def gen_account(): try: gen_account.counter += 1 except AttributeError: gen_account.counter = 1 if gen_account.counter % ACC_BATCH_SIZE == 0: print("Account #{}".format(gen_account.counter)) # Populate pregen_accs if it is empty if len(saved_accs) == 0: i = 0 with open(ACCOUNTS_FILE, 'r') as af: for line in af: pub, priv, _ = tuple(line.split(',')) saved_accs.append((pub, priv)) # Don't generate a new keypair if we already have enough in accounts file if gen_account.counter < len(saved_accs): pub, priv = saved_accs[gen_account.counter] return Account(public_key=pub, private_key=priv) else: process = Popen([os.path.join(BUILD_PATH, "tests/Zilliqa/genkeypair")], stdout=PIPE, universal_newlines=True) (output, _) = process.communicate() _ = process.wait() pub, priv = output.strip().split(' ') acc = Account(public_key=pub, private_key=priv) with open(ACCOUNTS_FILE, "a") as af: af.write("{},{},{}\n".format(pub, priv, acc.address)) return acc
def test_call_other_account(self): address = self.contracts["hello"] contract = Contract.load_from_address(address) print(contract) print(contract.status) account2 = Account(private_key="d0b47febbef2bd0c4a4ee04aa20b60d61eb02635e8df5e7fd62409a2b1f5ddf8") print("Account2 balance", account2.get_balance()) contract.account = account2 resp = contract.call(gas_price=1000000000, method="setHello", params=[ Contract.value_dict("msg", "String", "hello from another account") ]) print(resp) pprint(contract.last_receipt) assert contract.last_receipt["success"] assert contract.last_receipt["event_logs"][0]["params"][0]["vname"] == "code" assert contract.last_receipt["event_logs"][0]["params"][0]["value"] == "1" resp = contract.call(gas_price=1000000000, method="getHello", params=[]) print(resp) pprint(contract.last_receipt) assert contract.last_receipt["success"] assert contract.last_receipt["event_logs"][0]["_eventname"] == "getHello()" assert contract.last_receipt["event_logs"][0]["params"][0]["vname"] == "msg" assert contract.last_receipt["event_logs"][0]["params"][0]["type"] == "String" assert contract.last_receipt["event_logs"][0]["params"][0]["value"] == "hi contract."
def test_batch_transfer(self): account = Account.from_keystore("zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) print(account) balance = account.get_balance() print("Account balance", balance) assert balance > 0 to_account = Account(address="b50c2404e699fd985f71b2c3f032059f13d6543b") # check address format with pytest.raises(ValueError): account.transfer_batch([ BatchTransfer(to_account.checksum_address, 0.001), BatchTransfer("wrong_address", 0.001) ]) with pytest.raises(ValueError): account.transfer_batch([ BatchTransfer(to_account.address, 0.001), ]) with pytest.raises(ValueError): account.transfer_batch([ BatchTransfer(to_account.address0x, 0.001), ]) batch = [] total_zils = 0 for i in range(2): batch.append(BatchTransfer(to_account.checksum_address, Zil(i * 0.1))) total_zils += (i * 0.1) batch.append(BatchTransfer(to_account.bech32_address, Zil(i * 0.1))) total_zils += (i * 0.1) pprint(batch) txn_infos = account.transfer_batch(batch) pprint(txn_infos) for txn_info in txn_infos: if not txn_info: print("Failed to create txn") else: txn_details = account.wait_txn_confirm(txn_info["TranID"]) pprint(txn_details) if txn_details and txn_details["receipt"]["success"]: print("Txn success") else: print("Txn failed") balance2 = account.get_balance() print("Account1 balance", balance2) account2 = Account(private_key="d0b47febbef2bd0c4a4ee04aa20b60d61eb02635e8df5e7fd62409a2b1f5ddf8") txn_info = account2.transfer(account.bech32_address, total_zils, confirm=True) pprint(txn_info)
def getAddress(self, address, type_): if type_ == "pubKey": old_address = self.eval.call("getAddress", address[2:]) account = Account(address=old_address) return (old_address, account.bech32_address) elif type_ == "toBech32": if is_bech32_address(address): # no need to transfer to bech32 format return (address, address) account = Account(address=address) return (address, account.bech32_address)
def test_keystore(self): account = Account.from_keystore("zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) assert account and account.address == "526a2719b5855ef7d396a62b912a0dfa08e6ae63" account = Account.from_keystore("1234", path_join("crypto", "zilliqa_keystore2.json")) assert account and account.address == "526a2719b5855ef7d396a62b912a0dfa08e6ae63" with pytest.raises(ValueError): account = Account.from_keystore("123", path_join("crypto", "zilliqa_keystore2.json")) assert account and account.address == "526a2719b5855ef7d396a62b912a0dfa08e6ae63"
def _test_transfer_qa(self): chain.set_active_chain(chain.TestNet) account = Account(address="b50c2404e699fd985f71b2c3f032059f13d6543b") print(account) print("Account1 balance", repr(account.get_balance())) account2 = Account.from_keystore( "zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) print(account2) balance = account2.get_balance() print("Account2 balance", repr(balance)) assert balance > 0 txn_info = account2.transfer(account.bech32_address, Qa(123456789)) pprint(txn_info) txn_details = account2.wait_txn_confirm(txn_info["TranID"], timeout=240) pprint(txn_details) assert txn_details print("Account1 balance", repr(account.get_balance())) print("Account1 balance", repr(account.get_balance_qa())) account = Account( private_key= "d0b47febbef2bd0c4a4ee04aa20b60d61eb02635e8df5e7fd62409a2b1f5ddf8") txn_info = account.transfer(account2.checksum_address, Qa(123456789), confirm=True) pprint(txn_info)
def test_transfer(self): chain.set_active_chain(chain.TestNet) account = Account(address="b50c2404e699fd985f71b2c3f032059f13d6543b") print(account) balance1 = account.get_balance() print("Account1 balance", balance1) with pytest.raises(RuntimeError): account.transfer("to_addr", 1) account2 = Account.from_keystore( "zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) print(account2) balance = account2.get_balance() print("Account2 balance", balance) assert balance > 0 # check address format with pytest.raises(ValueError): account2.transfer(account.address, Zil(10.3)) with pytest.raises(ValueError): account2.transfer(account.address0x, Zil(10.3)) # checksum address # check insufficient balance with pytest.raises(ValueError): account2.transfer(account.checksum_address, 50000) txn_info = account2.transfer(account.checksum_address, Zil(10.3)) pprint(txn_info) txn_details = account2.wait_txn_confirm(txn_info["TranID"], timeout=240) pprint(txn_details) assert txn_details balance2 = account.get_balance() print("Account1 balance", balance2) assert balance2 >= balance1 + 10.299 account = Account( private_key= "d0b47febbef2bd0c4a4ee04aa20b60d61eb02635e8df5e7fd62409a2b1f5ddf8") # bech32 address txn_info = account.transfer(account2.bech32_address, 10.3, confirm=True) pprint(txn_info)
def deploy_contract(contract_file, account_sk): # deploy the contract code = open(contract_file).read() contract = Contract.new_from_code(code) print(contract) account = Account(private_key=account_sk) balance = account.get_balance() print("{}: {}".format(account, balance)) # set account before deploy contract.account = account contract.deploy(timeout=300, sleep=10, priority=True) assert contract.status == Contract.Status.Deployed
def test_batch_transfer(self): chain.set_active_chain(chain.TestNet) account = Account.from_keystore("zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) print(account) balance = account.get_balance() print("Account balance", balance) assert balance > 0 batch = [] for i in range(10): batch.append(BatchTransfer( "b50c2404e699fd985f71b2c3f032059f13d6543b", Zil(i * 0.1)) ) pprint(batch) txn_infos = account.transfer_batch(batch) pprint(txn_infos) txn_details = account.wait_txn_confirm(txn_infos[0]["TranID"], timeout=120) pprint(txn_details) assert txn_details for txn_info in txn_infos: txn_details = account.wait_txn_confirm(txn_info["TranID"]) pprint(txn_details) balance2 = account.get_balance() print("Account1 balance", balance2)
def test_transfer(self): chain.set_active_chain(chain.TestNet) account = Account(address="b50c2404e699fd985f71b2c3f032059f13d6543b") print(account) balance1 = account.get_balance() print("Account1 balance", balance1) with pytest.raises(RuntimeError): account.transfer("to_addr", 1) account2 = Account.from_keystore("zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) print(account2) balance = account2.get_balance() print("Account2 balance", balance) assert balance > 0 to_addr = account.address with pytest.raises(ValueError): account2.transfer(to_addr, 50000) txn_info = account2.transfer(to_addr, Zil(10.3)) pprint(txn_info) txn_details = account2.wait_txn_confirm(txn_info["TranID"], timeout=120) pprint(txn_details) assert txn_details balance2 = account.get_balance() print("Account1 balance", balance2) assert balance2 >= balance1 + 10.3
def withdraw(config, gas_price, gas_limit, contract): ''' This function will generate a transaction to transfer the token from TEE accoount to the worker's account. ''' cfg = _parse_config(config) # set the active chain local_chain = BlockChain(cfg["baseChainServer"], int(cfg["baseChainversion"]), int(cfg["baseChainID"])) chain.set_active_chain(local_chain) KMSConnector.rpcserver = cfg["baseChainServer"] KMSConnector.version = cfg["baseChainversion"] KMSConnector.networkid = cfg["baseChainID"] KMSConnector.host = str(cfg["KMS_HOST"]) KMSConnector.port = int(cfg["KMS_PORT"]) contract_addr = cfg[contract] contract = Contract.load_from_address(contract_addr) account = Account(private_key=cfg["oracleSK"]) contract.account = account resp = contract.call(method="get_reward_balance", params=[ Contract.value_dict( 'oracle_owner_address', 'ByStr20', zilkey.normalise_address( cfg['oracleAddress']).lower()) ], gas_price=gas_price, gas_limit=gas_limit) if (resp is not None) and (not resp['receipt']['success']): print("Network error") else: if (resp['receipt']['event_logs'][0]['params'][0]['value']['arguments'] == []) or (resp['receipt']['event_logs'][0]['params'][0] ['value']['arguments'] == ['0']): print("No money") else: money = int(resp['receipt']['event_logs'][0]['params'][0]['value'] ['arguments'][0]) / 1000000000000.0 print("Have money: " + str(money)) kms = KMSConnector() if kms.withdraw( zilkey.normalise_address(cfg['oracleAddress'].lower()), money, cfg[contract]) == "success": print("Withdraw submit success") time.sleep(300) print("Withdraw success") elif kms.withdraw( zilkey.normalise_address(cfg['oracleAddress'].lower()), money, cfg[contract]) is None: print("KMS server has no response") else: print("Withdraw submit fail")
def getAccountData(self, address_old, address_new): # 当账户已经在数据库中时: Account = self.matcher_node.match("Account", address=address_old).first() res = self.getResult("GetBalance", address_old) if Account: # self.printf("account %s existed!" % address) if "error" in res: Account.update({"balance": "0", "existed": "false"}) else: Account.update({"balance": res["balance"], "existed": "true"}) self.graph.push(Account) return Account, 1 Account = Node("Account", address=address_old) Account.update({"address_new": address_new}) # 获取账户当前的余额 if "error" in res: Account.update({"balance": "0", "existed": "false"}) else: Account.update({"balance": res["balance"], "existed": "true"}) return Account, 0
def test_new_account(self): with pytest.raises(ValueError): Account() account = Account.generate() assert account and account.address assert account.zil_key.address == account.address address = "b50c2404e699fd985f71b2c3f032059f13d6543b" account = Account(address=address) assert account and account.address assert account.checksum_address == zilkey.to_checksum_address(address) assert account.zil_key is None pub_key = "0x03949D29723DA4B2628224D3EC8E74C518ACA98C6630B00527F86B8349E982CB57" private_key = "05C3CF3387F31202CD0798B7AA882327A1BD365331F90954A58C18F61BD08FFC" address = "95B27EC211F86748DD985E1424B4058E94AA5814" account = Account(address=address, private_key=private_key) assert account and account.address assert account.checksum_address == zilkey.to_checksum_address(address) assert account.zil_key is not None account = Account(address=address, public_key=pub_key) assert account and account.address assert account.checksum_address == zilkey.to_checksum_address(address) assert account.zil_key is not None account = Account(address=address, public_key=pub_key, private_key=private_key) assert account and account.address assert account.checksum_address == zilkey.to_checksum_address(address) assert account.zil_key is not None
def test_batch_transfer(self): chain.set_active_chain(chain.TestNet) account = Account.from_keystore( "zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) print(account) balance = account.get_balance() print("Account balance", balance) assert balance > 0 batch = [] for i in range(10): batch.append( BatchTransfer("b50c2404e699fd985f71b2c3f032059f13d6543b", Zil(i * 0.1))) pprint(batch) txn_infos = account.transfer_batch(batch) pprint(txn_infos) txn_details = account.wait_txn_confirm(txn_infos[0]["TranID"], timeout=120) pprint(txn_details) assert txn_details for txn_info in txn_infos: txn_details = account.wait_txn_confirm(txn_info["TranID"]) pprint(txn_details) balance2 = account.get_balance() print("Account1 balance", balance2) account2 = Account( private_key= "d0b47febbef2bd0c4a4ee04aa20b60d61eb02635e8df5e7fd62409a2b1f5ddf8") txn_info = account2.transfer(account.address, sum([b.zils for b in batch])) pprint(txn_info)
def register_to_process(self, sk, request_id): account = Account(private_key=sk) contract = Contract.load_from_address(self.contract_addr) contract.account = account resp = contract.call(method="register_to_process", params=[ Contract.value_dict("verify_request_id", "Uint32", request_id) ], amount=DEFAULT_REGISTER_STAKE) if not resp: return False if resp['receipt']['success']: if "event_logs" in resp['receipt']: event_logs = resp['receipt']["event_logs"] for event_log in event_logs: if event_log['_eventname'] == 'register success': return True return False
def __init__(self): self.viewblock_zilswap_url = 'https://api.viewblock.io/v1/zilliqa/addresses/zil1hgg7k77vpgpwj3av7q7vv5dl4uvunmqqjzpv2w/txs?page=' try: fp_viewblock_api = open(str(Path.home()) + "/.viewblock.json") except: print("Failed to connect to Viewblock API") print( "A ~/.viewblock.json file is required in your home directory with the format:" ) print("{") print(" \"X-APIKEY\": {") print(" \"key\" : \"<key_string>\",") print(" \"secret\" : \"<secret_string>\"") print(" }") print("}") sys.exit() apikey = json.load(fp_viewblock_api)["X-APIKEY"] self.viewblock_headers = {'X-APIKEY': apikey["key"]} # Configure MongoDB self.mongoclient = pymongo.MongoClient("mongodb://localhost:27017/") self.mongodb = self.mongoclient["zilcrawl"] # Create database for zilswap contract self.zilswap = self.mongodb["zilswap"] # Load Zilgraph JSON fp_json = open("zilgraph.json") self.tokens = json.load(fp_json)["tokens"] # Setup dictionaries self.token = {} self.tokendb = {} self.ohlcdb_1h = {} self.ohlcdb_24h = {} self.decimals = {"zil": 12} self.trade_cnt = {} for tok in self.tokens: self.token[tok] = Account(address=self.tokens[tok]["addr"]) self.tokendb[tok] = self.mongodb[tok] self.ohlcdb_1h[tok] = self.mongodb["ohlc_1h_" + tok] self.ohlcdb_24h[tok] = self.mongodb["ohlc_24h_" + tok] self.decimals[tok] = self.tokens[tok]["decimals"] self.trade_cnt[tok] = 0
def test_txn(args): global ERROR_MESSAGE global SEND_ZILS_FORWARD_OR_BACK # Load source account account = Account(address=args['srchex'], private_key=args['srckey']) balance = account.get_balance() # Load destination account account2 = Account(address=args['dsthex'], private_key=args['dstkey']) balance2 = account2.get_balance() if SEND_ZILS_FORWARD_OR_BACK == True: print("SRC: {}: {}".format(account, balance)) print("DST: {}: {}".format(account2, balance2)) # Send 100 Qa from srchex to dstzil txn_info = account.transfer(to_addr=args['dstzil'], zils=Qa(100)) SEND_ZILS_FORWARD_OR_BACK = False else: print("SRC: {}: {}".format(account2, balance2)) print("DST: {}: {}".format(account, balance)) # Send 100 Qa from dsthex to srczil txn_info = account2.transfer(to_addr=args['srczil'], zils=Qa(100)) SEND_ZILS_FORWARD_OR_BACK = True pprint(txn_info) txn_id = txn_info["TranID"] sys.stdout.flush() # Wait for confirmation (timeout = 20mins, to take into account a view change) txn_details = account.wait_txn_confirm(txn_id, timeout=1200) pprint(txn_details) if txn_details and txn_details["receipt"]["success"]: print("Txn success: {}".format(txn_id)) else: print("Txn failed: {}".format(txn_id)) raise Exception("Txn failed: {}".format(txn_id))
def test_new_account(self): with pytest.raises(ValueError): Account() account = Account.generate() assert account and account.address assert account.zil_key.address == account.address address = "b50c2404e699fd985f71b2c3f032059f13d6543b" account = Account(address=address) assert account and account.address assert account.checksum_address == zilkey.to_checksum_address(address) assert account.zil_key is None pub_key = "0x03949D29723DA4B2628224D3EC8E74C518ACA98C6630B00527F86B8349E982CB57" private_key = "05C3CF3387F31202CD0798B7AA882327A1BD365331F90954A58C18F61BD08FFC" address = "95B27EC211F86748DD985E1424B4058E94AA5814" account = Account(address=address, private_key=private_key) assert account and account.address assert account.checksum_address == zilkey.to_checksum_address(address) assert account.zil_key is not None account = Account(address=address, public_key=pub_key) assert account and account.address assert account.checksum_address == zilkey.to_checksum_address(address) assert account.zil_key is not None account = Account(address=address, public_key=pub_key, private_key=private_key) assert account and account.address assert account.checksum_address == zilkey.to_checksum_address(address) assert account.zil_key is not None addr = "1d19918a737306218b5cbb3241fcdcbd998c3a72" bech32_addr = "zil1r5verznnwvrzrz6uhveyrlxuhkvccwnju4aehf" account1 = Account(address=addr) account2 = Account(address=bech32_addr) assert account1 == account2 assert account1.bech32_address == bech32_addr assert account2.address == addr
def test_balance(self): account = Account(address="b50c2404e699fd985f71b2c3f032059f13d6543b") balance = account.get_balance() print("balance", balance) assert balance > 0 nonce = account.get_nonce() print("nonce", nonce) assert nonce >= 0 account2 = Account(address="b50c2404e699fd985f71b2c3f032059f13d65432") balance = account2.get_balance() print("balance", balance) assert balance == 0 account3 = Account.from_keystore("zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) balance = account3.get_balance() print("balance", balance) assert balance > 0
def nft_create_txns(contract, src_acc, dest_accs, type='mint'): # Clear any cached sessions. This is needed to ensure multiple processes # don't try to reuse the same TCP connection, which would lead to havoc LocalNet = chain.BlockChain(API_ENDPOINT, version=1, network_id=0) chain.set_active_chain(LocalNet) src_acc = Account(private_key=src_acc.private_key) contract = Contract.load_from_address(contract.address, load_state=False) txn_info_list = [] contract.account = src_acc src_addr = src_acc.bech32_address for dest_acc in dest_accs: try: src = src_acc.address0x dest = dest_acc.address0x txn_info = None if type == 'mint': txn_info = contract.call( method="mint", params=[ Contract.value_dict("to", "ByStr20", dest), Contract.value_dict("tokenId", "Uint256", get_token_id(dest)) ], nonce=1, confirm=False) elif type == 'transfer': txn_info = contract.call( method="transfer", params=[ Contract.value_dict("tokenOwner", "ByStr20", src), Contract.value_dict("to", "ByStr20", dest), Contract.value_dict("tokenId", "Uint256", get_token_id(src)) ], nonce=1, confirm=False) txn_info_list.append(txn_info) print(json.dumps(src_acc.last_params), file=sys.stderr) print("Created {} transactions".format(len(txn_info_list))) except Exception as e: print("Could not send from {} to {}: {}".format( src_acc.address0x, dest, e)) return txn_info_list, src_acc, None
def contract_create_multidest_txns(contract, src_acc, dest_accs, method): # Clear any cached sessions. This is needed to ensure multiple processes # don't try to reuse the same TCP connection, which would lead to havoc LocalNet = chain.BlockChain(API_ENDPOINT, version=1, network_id=0) chain.set_active_chain(LocalNet) src_acc = Account(private_key=src_acc.private_key) contract = Contract.load_from_address(contract.address, load_state=False) txn_info_list = [] contract.account = src_acc src_addr = src_acc.bech32_address for dest_acc in dest_accs: try: dest = dest_acc.address0x txn_info = None if method == 'bestow': label = dest_acc.bech32_address txn_info = contract.call( method="bestow", params=[ Contract.value_dict("node", "ByStr32", parentLabelToNode(rootNode, label)), Contract.value_dict("label", "String", label), Contract.value_dict("owner", "ByStr20", dest), Contract.value_dict( "resolver", "ByStr20", "0x0000000000000000000000000000000000000000") ], nonce=1, confirm=False) txn_info_list.append(txn_info) print(json.dumps(src_acc.last_params), file=sys.stderr) print("Created {} transactions".format(len(txn_info_list))) except Exception as e: print("Could not send from {} to {}: {}".format( src_acc.address0x, dest, e)) return txn_info_list, src_acc, None
def __init__(self): # Configure MongoDB self.mongoclient = pymongo.MongoClient("mongodb://localhost:27017/") self.mongodb = self.mongoclient["zillog"] # Load Zilgraph JSON fp_json = open("zilgraph.json") self.tokens = json.load(fp_json)["tokens"] # Setup dictionaries self.token = {} for tok in self.tokens: self.token[tok] = self.mongodb[tok] # Wallet address addr = "zil1y7kr7nh28p5j3tv76jm5nkp2yq56j8xwsq5utr" # Load account from private key account = Account(address=addr) # Instantiate zilswap class self.swap = zilswap(account)
def __init__(self, account): # Set mainnet chain.set_active_chain(chain.MainNet) # Set contract _addr = "zil1hgg7k77vpgpwj3av7q7vv5dl4uvunmqqjzpv2w" self.contract = Contract.load_from_address(_addr, load_state=True) # Set account self.contract.account = account # Set Zilliqa API self.api = ZilliqaAPI("https://api.zilliqa.com/") # Load Zilgraph JSON fp_json = open("zilgraph.json") self.tokens = json.load(fp_json)["tokens"] # Setup dictionaries self.token = {} self.decimals = {"zil": 12} for tok in self.tokens: self.token[tok] = Account(address=self.tokens[tok]["addr"]) self.decimals[tok] = self.tokens[tok]["decimals"]
def test_transfer_qa(self): chain.set_active_chain(chain.TestNet) account = Account(address="b50c2404e699fd985f71b2c3f032059f13d6543b") print(account) print("Account1 balance", repr(account.get_balance())) account2 = Account.from_keystore("zxcvbnm,", path_join("crypto", "zilliqa_keystore.json")) print(account2) balance = account2.get_balance() print("Account2 balance", repr(balance)) assert balance > 0 to_addr = account.address txn_info = account2.transfer(to_addr, Qa(123456789)) pprint(txn_info) txn_details = account2.wait_txn_confirm(txn_info["TranID"], timeout=120) pprint(txn_details) assert txn_details print("Account1 balance", repr(account.get_balance())) print("Account1 balance", repr(account.get_balance_qa()))
sys.path.append( os.path.abspath(os.path.join(os.path.dirname(__file__), "../lib"))) from pprint import pprint from pyzil.crypto import zilkey from pyzil.zilliqa import chain from pyzil.account import Account from pyzil.contract import Contract from pyzil.zilliqa.api import ZilliqaAPI chain.set_active_chain(chain.TestNet) # user account account = Account( private_key= "919457fa2d81c0b7f1f1918683b1ff6b459c444aefec494c92f34d746ebb6b73") balance = account.get_balance() print("{}: {}".format(account, balance)) contract_addr = "zil1cfq4we3nmf2t7687qjvdwlz89qw2gzy700qwff" contract = Contract.load_from_address(contract_addr) contract.account = account def new_swap_request_test(swap_chain, initial_money, swap_money, target_addr, swap_chain_initial_addr, swap_chain_target_addr): resp = contract.call(method="request_swap", params=[ Contract.value_dict("swap_chain", "String", swap_chain),
def generate_wallet(): account = Account.generate() #print(account.bech32_address) return account.bech32_address, account.public_key, account.private_key
def test_load_mykey_txt(self): account = Account.from_mykey_txt(path_join("crypto", "mykey.txt")) assert account and account.address == "967e40168af66f441b73c0146e26069bfc3accc7" account = Account.from_mykey_txt(path_join("crypto", "mykey2.txt")) assert account and account.address == "e2406d084955e2d2ba8e8eaf7fe1c6a3e9ab3ea9"