def wallet_info(context):
context.wallet_name = "unencrypted-default-wallet"
context.wallet_pswd = ""
context.wallet = wallet.Wallet(context.wallet_name, context.wallet_pswd,
context.kcl)
context.wallet_id = context.wallet.id
context.accounts = context.wallet.list_keys()
def test_file_read_write(self):
# get suggested parameters and fee
params = self.acl.suggested_params()
gh = params["genesishashb64"]
last_round = params["lastRound"]
fee = params["fee"]
# create transaction
txn = transaction.PaymentTxn(self.account_0, fee, last_round,
last_round + 100, gh, self.account_0,
1000)
# get private key
w = wallet.Wallet(wallet_name, wallet_pswd, self.kcl)
private_key = w.export_key(self.account_0)
# sign transaction
stx = txn.sign(private_key)
# write to file
dir_path = os.path.dirname(os.path.realpath(__file__))
transaction.write_to_file([txn, stx], dir_path + "/raw.tx")
# read from file
txns = transaction.retrieve_from_file(dir_path + "/raw.tx")
# check that the transactions are still the same
self.assertEqual(encoding.msgpack_encode(txn),
encoding.msgpack_encode(txns[0]))
self.assertEqual(encoding.msgpack_encode(stx),
encoding.msgpack_encode(txns[1]))
# delete the file
os.remove("raw.tx")
def test_file_read_write(self):
# get suggested parameters and fee
gh = self.acl.versions()['genesis_hash_b64']
rnd = int(self.acl.status()['lastRound'])
sp = transaction.SuggestedParams(0, rnd, rnd + 100, gh)
# create transaction
txn = transaction.PaymentTxn(self.account_0, sp, self.account_0, 1000)
# get private key
w = wallet.Wallet(wallet_name, wallet_pswd, self.kcl)
private_key = w.export_key(self.account_0)
# sign transaction
stx = txn.sign(private_key)
# write to file
dir_path = os.path.dirname(os.path.realpath(__file__))
transaction.write_to_file([txn, stx], dir_path + "/raw.tx")
# read from file
txns = transaction.retrieve_from_file(dir_path + "/raw.tx")
# check that the transactions are still the same
self.assertEqual(encoding.msgpack_encode(txn),
encoding.msgpack_encode(txns[0]))
self.assertEqual(encoding.msgpack_encode(stx),
encoding.msgpack_encode(txns[1]))
# delete the file
os.remove("raw.tx")
def setUpClass(cls):
cls.acl = algod.AlgodClient(params.algod_token, params.algod_address)
cls.kcl = kmd.KMDClient(params.kmd_token, params.kmd_address)
w = wallet.Wallet(wallet_name, wallet_pswd, cls.kcl)
keys = w.list_keys()
max_balance = 0
cls.account_0 = ""
for k in keys:
account_info = cls.acl.account_info(k)
if account_info["amount"] > max_balance:
max_balance = account_info["amount"]
cls.account_0 = k
def get_private_key_from_mnemonic(mn):
private_key = mnemonic.to_private_key(mn)
return private_key
algod_address = sys.argv[1]
algod_token = sys.argv[2]
kmd_address = sys.argv[3]
kmd_token = sys.argv[4]
wallet_name = sys.argv[5]
wallet_pwd = sys.argv[6]
kmd = kmd.KMDClient(kmd_token, kmd_address)
wallet = wallet.Wallet(wallet_name, wallet_pwd, kmd)
client = algod.AlgodClient(algod_token, algod_address)
# define creator
creator = sys.argv[7]
creator_private_key = wallet.export_key(creator)
# get node suggested parameters
params = client.suggested_params()
# comment out the next two (2) lines to use suggested fees
params.flat_fee = True
params.fee = int(sys.argv[8])
# create unsigned transaction
approval_program = compile_program(client, sys.argv[9])
clear_program = compile_program(client, sys.argv[10])
def test_wallet(self):
# initialize wallet
w = wallet.Wallet(wallet_name, wallet_pswd, self.kcl)
# get master derivation key
mdk = w.export_master_derivation_key()
# get mnemonic
mn = w.get_mnemonic()
# make sure mnemonic can be converted back to mdk
self.assertEqual(mdk, mnemonic.to_master_derivation_key(mn))
# generate account with account and check if it's valid
private_key_1, account_1 = account.generate_account()
# import generated account
import_key = w.import_key(private_key_1)
self.assertEqual(import_key, account_1)
# check that the account is in the wallet
keys = w.list_keys()
self.assertIn(account_1, keys)
# generate account with kmd
account_2 = w.generate_key()
private_key_2 = w.export_key(account_2)
# get suggested parameters and fee
params = self.acl.suggested_params()
gen = params["genesisID"]
gh = params["genesishashb64"]
last_round = params["lastRound"]
fee = params["fee"]
# create transaction
txn = transaction.PaymentTxn(self.account_0,
fee,
last_round,
last_round + 100,
gh,
account_1,
100000,
gen=gen)
# sign transaction with wallet
signed_kmd = w.sign_transaction(txn)
# get self.account_0 private key
private_key_0 = w.export_key(self.account_0)
# sign transaction with account
signed_account = txn.sign(private_key_0)
# check that signing both ways results in the same thing
self.assertEqual(encoding.msgpack_encode(signed_account),
encoding.msgpack_encode(signed_kmd))
# create multisig account and transaction
msig = transaction.Multisig(1, 2, [account_1, account_2])
txn = transaction.PaymentTxn(msig.address(),
fee,
last_round,
last_round + 100,
gh,
self.account_0,
1000,
gen=gen)
# import multisig account
msig_address = w.import_multisig(msig)
# check that the multisig account is listed
msigs = w.list_multisig()
self.assertIn(msig_address, msigs)
# export multisig account
exported = w.export_multisig(msig_address)
self.assertEqual(len(exported.subsigs), 2)
# create multisig transaction
mtx = transaction.MultisigTransaction(txn, msig)
# sign the multisig using kmd
msig_1 = w.sign_multisig_transaction(account_1, mtx)
signed_kmd = w.sign_multisig_transaction(account_2, msig_1)
# sign the multisig offline
mtx1 = transaction.MultisigTransaction(txn, msig)
mtx1.sign(private_key_1)
mtx2 = transaction.MultisigTransaction(txn, msig)
mtx2.sign(private_key_2)
signed_account = transaction.MultisigTransaction.merge([mtx1, mtx2])
# check that they are the same
self.assertEqual(encoding.msgpack_encode(signed_account),
encoding.msgpack_encode(signed_kmd))
# delete accounts
del_1 = w.delete_key(account_1)
del_2 = w.delete_key(account_2)
del_3 = w.delete_multisig(msig_address)
self.assertTrue(del_1)
self.assertTrue(del_2)
self.assertTrue(del_3)
# test renaming the wallet
w.rename(wallet_name + "1")
self.assertEqual(wallet_name + "1", w.info()["wallet"]["name"])
w.rename(wallet_name)
self.assertEqual(wallet_name, w.info()["wallet"]["name"])
# test releasing the handle
w.release_handle()
self.assertRaises(error.KMDHTTPError, self.kcl.get_wallet, w.handle)
# test handle automation
w.info()
