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_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 _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 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_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_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 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 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 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_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 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 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 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 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 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 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_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 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 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()))
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"]
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 test_pyzil(**kwargs):
from pyzil.account import Account
acc = Account(
public_key=
'039fbf7df13d0b6798fa16a79daabb97d4424062d2f8bd4e9a7c7851e732a25e1d')
print(acc.bech32_address)
def get_chain_nonce(sender_pubkey):
acc = Account(public_key=sender_pubkey)
return acc.get_nonce()
TestNet = BlockChain("https://dev-api.zilliqa.com/",
version=21823489,
network_id=333)
MainNet = BlockChain("https://api.zilliqa.com/", version=65537, network_id=1)
LocalNet = BlockChain("http://localhost:4201", version=131073, network_id=2)
if "__main__" == __name__:
LocalNet = BlockChain("http://localhost:4201",
version=131073,
network_id=2)
chain.set_active_chain(LocalNet)
account = Account(address="0x8a17d9a236c7b6314892276877cb4462b0c2ab53")
balance = account.get_balance()
print("{}: {}".format(account, balance))
"""Convert 20 bytes address to bech32 address."""
print(TestNet.api.GetBlockchainInfo())
# load account from private key
# private key is required to send ZILs
account = Account(
private_key=
"8062536DED35314B4F9029CE98B5244B062452A8DE2545F49DBDF4D3713A9C20")
balance2 = account.get_balance()
print("Account balance: {}".format(balance2))
# to_addr must be bech32 address or 20 bytes checksum address
to_addr = "0x8a17d9a236c7b6314892276877cb4462b0c2ab53"
if not zilkey.is_valid_address(to_addr):
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=
"dc15707f4bf08367c89eae066daaa0a2335799fcd75dfb2c4ba514c55bc6e317")
# tora swap contract address
contract_addr = "zil1cfq4we3nmf2t7687qjvdwlz89qw2gzy700qwff"
def __has_txn(api, block_num):
block_info = api.GetTxBlock(block_num)
if block_info["header"]["NumTxns"] == 0:
return False
else:
return True
def __get_swap_request_event(account_addr, api, block_num):
from pprint import pprint
from pyzil.zilliqa import chain
from pyzil.account import Account
from pyzil.contract import Contract
chain.set_active_chain(chain.TestNet)
account = Account(private_key="c4e0d95cc91d4cd72c68c9cf58eec49eb9e5c2cbc63fec61e7bef5e7555de0f0")
print(account)
contract_addr = "zil13mf5zaahphzxk228u0kadk09z6plf8cuppv0df"
contract = Contract.load_from_address(contract_addr)
contract.account = account
resp = contract.call(method="getHello", params=[])
pprint(resp)
pprint(contract.last_receipt)
resp = contract.call(method="setHello", params=[Contract.value_dict("msg", "String", "hi contract.")])
pprint(resp)
pprint(contract.last_receipt)
resp = contract.call(method="getHello", params=[])
pprint(resp)
pprint(contract.last_receipt)
# see more examples in test_contract.py
