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 check_enc(context): dir_path = os.path.dirname(os.path.realpath(__file__)) dir_path = os.path.dirname(os.path.dirname(dir_path)) new = transaction.retrieve_from_file(dir_path + "/temp/raw" + context.num + ".tx") old = transaction.retrieve_from_file(dir_path + "/temp/old" + context.num + ".tx") assert encoding.msgpack_encode(new[0]) == encoding.msgpack_encode(old[0])
def test_transaction_group(self): # get the default wallet wallets = self.kcl.list_wallets() wallet_id = None for w in wallets: if w["name"] == wallet_name: wallet_id = w["id"] # get a new handle for the wallet handle = self.kcl.init_wallet_handle(wallet_id, wallet_pswd) # get private key private_key_0 = self.kcl.export_key(handle, wallet_pswd, self.account_0) # 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, self.account_0, 1000, gen=gen) # calculate group id gid = transaction.calculate_group_id([txn]) txn.group = gid # sign using kmd stxn1 = self.kcl.sign_transaction(handle, wallet_pswd, txn) # sign using transaction call stxn2 = txn.sign(private_key_0) # check that they are the same self.assertEqual(encoding.msgpack_encode(stxn1), encoding.msgpack_encode(stxn2)) try: send = self.acl.send_transactions([stxn1]) self.assertEqual(send, txn.get_txid()) except error.AlgodHTTPError as ex: self.assertIn( "TransactionPool.Remember: transaction groups not supported", str(ex))
def test_serialize_zero_amt(self): address = "7ZUECA7HFLZTXENRV24SHLU4AVPUTMTTDUFUBNBD64C73F3UHRTHAIOF6Q" gh = "JgsgCaCTqIaLeVhyL6XlRu3n7Rfk2FxMeK+wRSaQ7dI=" txn = transaction.PaymentTxn(address, 3, 1, 100, gh, address, 0, note=bytes([1, 32, 200])) enc = encoding.msgpack_encode(txn) re_enc = encoding.msgpack_encode(encoding.msgpack_decode(enc)) self.assertEqual(enc, re_enc)
def test_serialize_gen(self): address = "7ZUECA7HFLZTXENRV24SHLU4AVPUTMTTDUFUBNBD64C73F3UHRTHAIOF6Q" gh = "JgsgCaCTqIaLeVhyL6XlRu3n7Rfk2FxMeK+wRSaQ7dI=" txn = transaction.PaymentTxn(address, 3, 1, 100, gh, address, 1000, gen="testnet-v1.0", close_remainder_to=address) enc = encoding.msgpack_encode(txn) re_enc = encoding.msgpack_encode(encoding.msgpack_decode(enc)) self.assertEqual(enc, re_enc)
def test_sign(self): mn = ("advice pudding treat near rule blouse same whisper inner " + "electric quit surface sunny dismiss leader blood seat " + "clown cost exist hospital century reform able sponsor") gh = "JgsgCaCTqIaLeVhyL6XlRu3n7Rfk2FxMeK+wRSaQ7dI=" address = "PNWOET7LLOWMBMLE4KOCELCX6X3D3Q4H2Q4QJASYIEOF7YIPPQBG3YQ5YI" close = "IDUTJEUIEVSMXTU4LGTJWZ2UE2E6TIODUKU6UW3FU3UKIQQ77RLUBBBFLA" sk = mnemonic.to_private_key(mn) pk = account.address_from_private_key(sk) txn = transaction.PaymentTxn(pk, 4, 12466, 13466, gh, address, 1000, note=base64.b64decode("6gAVR0Nsv5Y="), gen="devnet-v33.0", close_remainder_to=close) stx = txn.sign(sk) golden = ("gqNzaWfEQPhUAZ3xkDDcc8FvOVo6UinzmKBCqs0woYSfodlmBMfQvGbeU" + "x3Srxy3dyJDzv7rLm26BRv9FnL2/AuT7NYfiAWjdHhui6NhbXTNA+ilY2" + "xvc2XEIEDpNJKIJWTLzpxZpptnVCaJ6aHDoqnqW2Wm6KRCH/xXo2ZlZc0" + "EmKJmds0wsqNnZW6sZGV2bmV0LXYzMy4womdoxCAmCyAJoJOohot5WHIv" + "peVG7eftF+TYXEx4r7BFJpDt0qJsds00mqRub3RlxAjqABVHQ2y/lqNyY" + "3bEIHts4k/rW6zAsWTinCIsV/X2PcOH1DkEglhBHF/hD3wCo3NuZMQg5/" + "D4TQaBHfnzHI2HixFV9GcdUaGFwgCQhmf0SVhwaKGkdHlwZaNwYXk=") self.assertEqual(golden, encoding.msgpack_encode(stx)) txid_golden = "5FJDJD5LMZC3EHUYYJNH5I23U4X6H2KXABNDGPIL557ZMJ33GZHQ" self.assertEqual(txn.get_txid(), txid_golden)
def test_payment_txn(self): paytxn = ("iaNhbXTOAAGGoKNmZWXNA+iiZnbNcq2jZ2Vuq25ldHdvcmstdjM4omdo" + "xCBN/+nfiNPXLbuigk8M/TXsMUfMK7dV//xB1wkoOhNu9qJsds1zEaNy" + "Y3bEIAZ2cvp4J0OiBy5eAHIX/njaRko955rEdN4AUNEl4rxTo3NuZMQg" + "GC5kQiOIPooA8mrvoHRyFtk27F/PPN08bAufGhnp0BGkdHlwZaNwYXk=") self.assertEqual( paytxn, encoding.msgpack_encode(encoding.msgpack_decode(paytxn)))
def write_multisig_signed_transaction_to_file(): algod_client = connect_to_network() # Change these values with mnemonics # mnemonic1 = "PASTE phrase for account 1" # mnemonic2 = "PASTE phrase for account 2" # mnemonic3 = "PASTE phrase for account 3" mnemonic1 = "patrol target joy dial ethics flip usual fatigue bulb security prosper brand coast arch casino burger inch cricket scissors shoe evolve eternal calm absorb school" mnemonic2 = "genius inside turtle lock alone blame parent civil depend dinosaur tag fiction fun skill chief use damp daughter expose pioneer today weasel box about silly" mnemonic3 = "off canyon mystery cable pluck emotion manual legal journey grit lunch include friend social monkey approve lava steel school mango auto cactus huge ability basket" # For ease of reference, add account public and private keys to # an accounts dict. private_key_1 = mnemonic.to_private_key(mnemonic1) account_1 = mnemonic.to_public_key(mnemonic1) private_key_2 = mnemonic.to_private_key(mnemonic2) account_2 = mnemonic.to_public_key(mnemonic2) private_key_3 = mnemonic.to_private_key(mnemonic3) account_3 = mnemonic.to_public_key(mnemonic3) # create a multisig account version = 1 # multisig version threshold = 2 # how many signatures are necessary msig = Multisig(version, threshold, [account_1, account_2]) print("Multisig Address: ", msig.address()) print( "Please go to: https://bank.testnet.algorand.network/ to fund multisig account.", msig.address()) # input("Please go to: https://bank.testnet.algorand.network/ to fund multisig account." + '\n' + "Press Enter to continue...") # get suggested parameters params = algod_client.suggested_params() # comment out the next two (2) lines to use suggested fees # params.flat_fee = True # params.fee = 1000 # create a transaction sender = msig.address() recipient = account_3 amount = 10000 note = "Hello Multisig".encode() txn = PaymentTxn(sender, params, recipient, amount, None, note, None) # create a SignedTransaction object mtx = MultisigTransaction(txn, msig) # sign the transaction mtx.sign(private_key_1) mtx.sign(private_key_2) # print encoded transaction print(encoding.msgpack_encode(mtx)) # write to file dir_path = os.path.dirname(os.path.realpath(__file__)) transaction.write_to_file([mtx], dir_path + "/signed.mtx") print("Signed mtx file saved!")
def test_bid(self): bid = ("gqFigqNiaWSGo2FpZAGjYXVjxCCokNFWl9DCqHrP9trjPICAMGOaRoX/OR+" + "M6tHWhfUBkKZiaWRkZXLEIP1rCXe2x5+exPBfU3CZwGPMY8mzwvglET+Qtg" + "fCPdCmo2N1cs8AAADN9kTOAKJpZM5JeDcCpXByaWNlzQMgo3NpZ8RAiR06J" + "4suAixy13BKHlw4VrORKzLT5CJr9n3YSj0Ao6byV23JHGU0yPf7u9/o4ECw" + "4Xy9hc9pWopLW97xKXRfA6F0oWI=") self.assertEqual(bid, encoding.msgpack_encode(encoding.msgpack_decode(bid)))
def write_drr(res, contents): dir_path = os.path.dirname(os.path.realpath(__file__)) path = os.path.join(dir_path, res) data = encoding.msgpack_encode(contents) data = base64.b64decode(data) with open(path, "wb") as fout: fout.write(data) return
def test_signed_txn(self): stxn = ("gqNzaWfEQGdpjnStb70k2iXzOlu+RSMgCYLe25wkUfbgRsXs7jx6rbW61i" + "vCs6/zGs3gZAZf4L2XAQak7OjMh3lw9MTCIQijdHhuiaNhbXTOAAGGoKNm" + "ZWXNA+iiZnbNcl+jZ2Vuq25ldHdvcmstdjM4omdoxCBN/+nfiNPXLbuigk" + "8M/TXsMUfMK7dV//xB1wkoOhNu9qJsds1yw6NyY3bEIPRUuVDPVUFC7Jk3" + "+xDjHJfwWFDp+Wjy+Hx3cwL9ncVYo3NuZMQgGC5kQiOIPooA8mrvoHRyFt" + "k27F/PPN08bAufGhnp0BGkdHlwZaNwYXk=") self.assertEqual( stxn, encoding.msgpack_encode(encoding.msgpack_decode(stxn)))
def test_keyreg_txn(self): keyregtxn = ("jKNmZWXNA+iiZnbNcoqjZ2Vuq25ldHdvcmstdjM4omdoxCBN/+nfi" + "NPXLbuigk8M/TXsMUfMK7dV//xB1wkoOhNu9qJsds1y7qZzZWxrZX" + "nEIBguZEIjiD6KAPJq76B0chbZNuxfzzzdPGwLnxoZ6dARo3NuZMQ" + "gGC5kQiOIPooA8mrvoHRyFtk27F/PPN08bAufGhnp0BGkdHlwZaZr" + "ZXlyZWendm90ZWZzdM1yiqZ2b3Rla2TNMDmndm90ZWtlecQgGC5kQ" + "iOIPooA8mrvoHRyFtk27F/PPN08bAufGhnp0BGndm90ZWxzdM1y7g==") self.assertEqual( keyregtxn, encoding.msgpack_encode(encoding.msgpack_decode(keyregtxn)))
def test_assetconfig_txn(self): actxn = ("iKRhcGFyhKFjxCAJ+9J2LAj4bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh" + "/aFmxCAJ+9J2LAj4bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aFtxCAJ" + "+9J2LAj4bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aFyxCAJ+9J2LAj4" + "bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aRjYWlkgqFjxCAJ+9J2LAj4" + "bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aFpzQTSo2ZlZc0OzqJmds4A" + "BOwPomdoxCBIY7UYpLPITsgQ8i1PEIHLD3HwWaesIN7GL39w5Qk6IqJs" + "ds4ABO/3o3NuZMQgCfvSdiwI+Gxa5r9t16epAd5mdddQ4H6MXHaYZH22" + "4f2kdHlwZaRhY2Zn") self.assertEqual( actxn, encoding.msgpack_encode(encoding.msgpack_decode(actxn)))
def test_serialize_txgroup(self): address = "7ZUECA7HFLZTXENRV24SHLU4AVPUTMTTDUFUBNBD64C73F3UHRTHAIOF6Q" gh = "JgsgCaCTqIaLeVhyL6XlRu3n7Rfk2FxMeK+wRSaQ7dI=" txn = transaction.PaymentTxn(address, 3, 1, 100, gh, address, 1000, gen="testnet-v1.0", close_remainder_to=address) txid = txn.get_txid().encode() txid = base64.decodebytes(txid) txgroup = transaction.TxGroup([txid]) enc = encoding.msgpack_encode(txgroup) re_enc = encoding.msgpack_encode(encoding.msgpack_decode(enc)) self.assertEqual(enc, re_enc) txgroup = transaction.TxGroup([txid] * 11) enc = encoding.msgpack_encode(txgroup) re_enc = encoding.msgpack_encode(encoding.msgpack_decode(enc)) self.assertEqual(enc, re_enc) # check group field serialization gid = transaction.calculate_group_id([txn, txn]) txn.group = gid enc = encoding.msgpack_encode(txn) re_enc = encoding.msgpack_encode(encoding.msgpack_decode(enc)) self.assertEqual(enc, re_enc)
def test_multisig_txn(self): msigtxn = ("gqRtc2lng6ZzdWJzaWeSgqJwa8Qg1ke3gkLuR0MUN/Ku0oyiRVIm9P1" + "QFDaiEhT5vtfLmd+hc8RAIEbfnhccjWfYQFQp/P4aJjATFdgaDDpnhy" + "JF0tU/37CO5I5hhoCvUCRH/A/6X94Ewz9YEtk5dANEGKQW+/WyAIKic" + "GvEIKgAZfZ4iDC+UY/P5F3tgs5rqeyYt08LT0c/D78u0V7KoXPEQCxU" + "kQgTVC9lLpKVzcZGKesSCQcZL9UjXTzrteADicvcca7KT3WP0crGgAf" + "J3a17Na5cykJzFEn7pq2SHgwD/QujdGhyAqF2AaN0eG6Jo2FtdM0D6K" + "NmZWXNA+iiZnbNexSjZ2Vuq25ldHdvcmstdjM4omdoxCBN/+nfiNPXL" + "buigk8M/TXsMUfMK7dV//xB1wkoOhNu9qJsds17eKNyY3bEIBguZEIj" + "iD6KAPJq76B0chbZNuxfzzzdPGwLnxoZ6dARo3NuZMQgpuIJvJzW8E4" + "uxsQGCW0S3n1u340PbHTB2zhtXo/AiI6kdHlwZaNwYXk=") self.assertEqual( msigtxn, encoding.msgpack_encode(encoding.msgpack_decode(msigtxn)))
def test_auction(self): # get the default wallet wallets = self.kcl.list_wallets() wallet_id = None for w in wallets: if w["name"] == wallet_name: wallet_id = w["id"] # get a new handle for the wallet handle = self.kcl.init_wallet_handle(wallet_id, wallet_pswd) # generate account with kmd account_1 = self.kcl.generate_key(handle, False) # get suggested parameters and fee params = self.acl.suggested_params() gen = params["genesisID"] gh = params["genesishashb64"] last_round = params["lastRound"] fee = params["fee"] # get self.account_0 private key private_key_0 = self.kcl.export_key(handle, wallet_pswd, self.account_0) # create bid bid = auction.Bid(self.account_0, 10000, 260, "bid_id", account_1, "auc_id") sb = bid.sign(private_key_0) nf = auction.NoteField(sb, constants.note_field_type_bid) # create transaction txn = transaction.PaymentTxn(self.account_0, fee, last_round, last_round + 100, gh, account_1, 100000, note=base64.b64decode( encoding.msgpack_encode(nf)), gen=gen) # sign transaction with account signed_account = txn.sign(private_key_0) # send transaction send = self.acl.send_transaction(signed_account) self.assertEqual(send, txn.get_txid()) del_1 = self.kcl.delete_key(handle, wallet_pswd, account_1) self.assertTrue(del_1)
def read_multisig_unsigned_transaction_from_file(): algod_client = connect_to_network() # Change these values with mnemonics # mnemonic1 = "PASTE phrase for account 1" # mnemonic2 = "PASTE phrase for account 2" # mnemonic3 = "PASTE phrase for account 3" mnemonic1 = "patrol target joy dial ethics flip usual fatigue bulb security prosper brand coast arch casino burger inch cricket scissors shoe evolve eternal calm absorb school" mnemonic2 = "genius inside turtle lock alone blame parent civil depend dinosaur tag fiction fun skill chief use damp daughter expose pioneer today weasel box about silly" mnemonic3 = "off canyon mystery cable pluck emotion manual legal journey grit lunch include friend social monkey approve lava steel school mango auto cactus huge ability basket" # For ease of reference, add account public and private keys to # an accounts dict. private_key_1 = mnemonic.to_private_key(mnemonic1) account_1 = mnemonic.to_public_key(mnemonic1) private_key_2 = mnemonic.to_private_key(mnemonic2) account_2 = mnemonic.to_public_key(mnemonic2) private_key_3 = mnemonic.to_private_key(mnemonic3) account_3 = mnemonic.to_public_key(mnemonic3) print("Account 1 address: {}".format(account_1)) print("Account 2 address: {}".format(account_2)) print("Account 3 address: {}".format(account_3)) # read from file dir_path = os.path.dirname(os.path.realpath(__file__)) msigs = transaction.retrieve_from_file(dir_path + "/unsigned.mtx") mtx = msigs[0] # sign the transaction mtx.sign(private_key_1) mtx.sign(private_key_2) # send the transaction txid = algod_client.send_raw_transaction(encoding.msgpack_encode(mtx)) # wait for confirmation try: confirmed_txn = wait_for_confirmation(algod_client, txid, 4) print("TXID: ", txid) print("Result confirmed in round: {}".format( confirmed_txn['confirmed-round'])) print("Transaction information: {}".format( json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format( base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode())) except Exception as err: print(err)
def save_dryrun_request(name_or_fp, req): """Helper function to save dryrun request Args: name_or_fp (str, file-like): filename or fp to save the request to req (DryrunRequest): dryrun request object to save """ need_close = False if isinstance(name_or_fp, str): fp = open(name_or_fp, "wb") need_close = True else: fp = name_or_fp data = msgpack_encode(req) data = base64.b64decode(data) fp.write(data) if need_close: fp.close()
def read_multisig_signed_transaction_from_file(): algod_client = connect_to_network() # read from file dir_path = os.path.dirname(os.path.realpath(__file__)) msigs = transaction.retrieve_from_file(dir_path + "/signed.mtx") mtx = msigs[0] try: # send the transaction txid = algod_client.send_raw_transaction( encoding.msgpack_encode(mtx)) # wait for confirmation confirmed_txn = wait_for_confirmation(algod_client, txid, 4) print("Transaction information: {}".format( json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format(base64.b64decode( confirmed_txn["txn"]["txn"]["note"]).decode())) except Exception as err: print(err)
def test_sign(self): msig = transaction.Multisig(1, 2, [ "DN7MBMCL5JQ3PFUQS7TMX5AH4EEKOBJVDUF4TCV6WERATKFLQF4MQUPZTA", "BFRTECKTOOE7A5LHCF3TTEOH2A7BW46IYT2SX5VP6ANKEXHZYJY77SJTVM", "47YPQTIGQEO7T4Y4RWDYWEKV6RTR2UNBQXBABEEGM72ESWDQNCQ52OPASU" ]) mn = ("advice pudding treat near rule blouse same whisper inner " + "electric quit surface sunny dismiss leader blood seat clown " + "cost exist hospital century reform able sponsor") sk = mnemonic.to_private_key(mn) rcv = "PNWOET7LLOWMBMLE4KOCELCX6X3D3Q4H2Q4QJASYIEOF7YIPPQBG3YQ5YI" gh = "JgsgCaCTqIaLeVhyL6XlRu3n7Rfk2FxMeK+wRSaQ7dI=" close = "IDUTJEUIEVSMXTU4LGTJWZ2UE2E6TIODUKU6UW3FU3UKIQQ77RLUBBBFLA" txn = transaction.PaymentTxn(msig.address(), 4, 12466, 13466, gh, rcv, 1000, note=base64.b64decode("X4Bl4wQ9rCo="), gen="devnet-v33.0", close_remainder_to=close) mtx = transaction.MultisigTransaction(txn, msig) mtx.sign(sk) golden = ("gqRtc2lng6ZzdWJzaWeTgaJwa8QgG37AsEvqYbeWkJfmy/QH4QinBTUdC" + "8mKvrEiCairgXiBonBrxCAJYzIJU3OJ8HVnEXc5kcfQPhtzyMT1K/av8B" + "qiXPnCcYKicGvEIOfw+E0GgR358xyNh4sRVfRnHVGhhcIAkIZn9ElYcGi" + "hoXPEQF6nXZ7CgInd1h7NVspIPFZNhkPL+vGFpTNwH3Eh9gwPM8pf1EPT" + "HfPvjf14sS7xN7mTK+wrz7Odhp4rdWBNUASjdGhyAqF2AaN0eG6Lo2Ftd" + "M0D6KVjbG9zZcQgQOk0koglZMvOnFmmm2dUJonpocOiqepbZabopEIf/F" + "ejZmVlzQSYomZ2zTCyo2dlbqxkZXZuZXQtdjMzLjCiZ2jEICYLIAmgk6i" + "Gi3lYci+l5Ubt5+0X5NhcTHivsEUmkO3Somx2zTSapG5vdGXECF+AZeME" + "Pawqo3JjdsQge2ziT+tbrMCxZOKcIixX9fY9w4fUOQSCWEEcX+EPfAKjc" + "25kxCCNkrSJkAFzoE36Q1mjZmpq/OosQqBd2cH3PuulR4A36aR0eXBlo3" + "BheQ==") self.assertEqual(golden, encoding.msgpack_encode(mtx)) txid_golden = "TDIO6RJWJIVDDJZELMSX5CPJW7MUNM3QR4YAHYAKHF3W2CFRTI7A" self.assertEqual(txn.get_txid(), txid_golden)
def test_serialize_assetconfig(self): address = "BH55E5RMBD4GYWXGX5W5PJ5JAHPGM5OXKDQH5DC4O2MGI7NW4H6VOE4CP4" gh = "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=" txn = transaction.AssetConfigTxn(address, 10, 322575, 323575, gh, address, 1234, manager=address, reserve=address, freeze=address, clawback=address) golden = ("iKRhcGFyhKFjxCAJ+9J2LAj4bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh" + "/aFmxCAJ+9J2LAj4bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aFtxCAJ" + "+9J2LAj4bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aFyxCAJ+9J2LAj4" + "bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aRjYWlkgqFjxCAJ+9J2LAj4" + "bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aFpzQTSo2ZlZc0OzqJmds4A" + "BOwPomdoxCBIY7UYpLPITsgQ8i1PEIHLD3HwWaesIN7GL39w5Qk6IqJs" + "ds4ABO/3o3NuZMQgCfvSdiwI+Gxa5r9t16epAd5mdddQ4H6MXHaYZH22" + "4f2kdHlwZaRhY2Zn") self.assertEqual(encoding.msgpack_encode(txn), golden)
def enc_dec_bid(context): context.bid = encoding.msgpack_decode(encoding.msgpack_encode(context.bid))
def sign_msig_both_equal(context): assert encoding.msgpack_encode(context.mtx) == encoding.msgpack_encode( context.mtx_kmd)
def msig_eq(context): assert encoding.msgpack_encode(context.msig) == encoding.msgpack_encode( context.exp)
def equal_msig_golden(context, golden): if not encoding.msgpack_encode(context.mtx) == golden: print(encoding.msgpack_encode(context.mtx)) print(golden) assert encoding.msgpack_encode(context.mtx) == golden
def equal_golden(context, golden): assert encoding.msgpack_encode(context.stx) == golden
def match_setup(algod_client, dealer_passphrase, addr_opponent, match_hours_timeout, microalgo_bet_amount, asa_pieces_total, asa_pieces_max_remove): """HELP match_setup: (AlgodClient, str, str, float, int, int, int) - Sets up a new AlgoNim match. """ # AlgoNim Players # Palyer 1 (Dealer) - Match Set Up costs about: 0.8 ALGO dealer = { 'pk': mnemonic.to_public_key(dealer_passphrase), 'sk': mnemonic.to_private_key(dealer_passphrase) } # Player 2 (Opponent) - Must Opt-In AlgoNim ASAs to play the match opponent = {'pk': addr_opponent} print(" ") print(" _ __ ____ _____ _ ") print(" / \ [ | |_ \|_ _| (_) ") print(" / _ \ | | .--./) .--. | \ | | __ _ .--..--. ") print(" / ___ \ | | / /'`\;/ .'`\ \ | |\ \| | [ | [ `.-. .-. | ") print(" _/ / \ \_ | | \ \._//| \__. |_| |_\ |_ | | | | | | | | ") print("|____| |____|[___].',__` '.__.'|_____|\____|[___][___||__||__]") print(" ( ( __)) ") print(" by cusma") print(" ") print(" Welcome to AlgoNim, the first crypto-mini-game on Algorand! ") # Asset Create: AlgoNim ASA Pieces print("") print("Dealer creating AlgoNim ASA Piece for this match...") asa_pieces_id = asa_pieces_create(algod_client, dealer, asa_pieces_total) # Asset Create: AlgoNim ASA Turn print("") print("Dealer creating AlgoNim ASA Turn for this match...") asa_turn_id = asa_turn_create(algod_client, dealer) # TEAL: AlgoNim ASC1 Sink print("") print("Dealer writing AlgoNim ASC1 Sink TEAL for this match...") asc1_sink_source = asc1_sink_teal(asa_pieces_total, asa_pieces_id, dealer['pk'], opponent['pk']) asc1_sink_compiled = algod_client.compile(asc1_sink_source) sink_lsig = transaction.LogicSig( base64.decodebytes(asc1_sink_compiled['result'].encode())) addr_sink = asc1_sink_compiled['hash'] # Initialize AlgoNim ASC1 Sink Account with ALGO print("") print("Initializing Sink Account...") send(algod_client, dealer, addr_sink, 300000) # AlgoNim ASC1 Sink Account Opt-In print("") print("Sink Account AlgoNim ASA Piece Opt-In...") sink_opt_in_txn = unsigned_asset_send(algod_client, addr_sink, addr_sink, asa_pieces_id, 0) sink_opt_in_lstxn = transaction.LogicSigTransaction( sink_opt_in_txn, sink_lsig) txid = algod_client.send_transactions([sink_opt_in_lstxn]) print("Transaction ID:", txid) wait_for_tx_confirmation(algod_client, txid) # TEAL: AlgoNim ASC1 Game Table print("") print("Dealer writing AlgoNim ASC1 Game Table TEAL for this match...") asc1_game_table_source = asc1_game_table_teal(asa_pieces_total, asa_pieces_id, asa_pieces_max_remove, asa_turn_id, dealer['pk'], opponent['pk'], addr_sink) asc1_game_table_compiled = algod_client.compile(asc1_game_table_source) game_table_lsig = transaction.LogicSig( base64.decodebytes(asc1_game_table_compiled['result'].encode())) addr_game_table = asc1_game_table_compiled['hash'] # Initialize AlgoNim ASC1 Game Table Account with ALGO print("") print("Initializing Game Table Account...") send(algod_client, dealer, addr_game_table, 300000) # Dealer Sets Up the Game Table with AlgoNim ASA Pieces print("") print("Dealer distributing ASA Pieces on the Game Table...") gt_opt_in_txn = unsigned_asset_send(algod_client, addr_game_table, addr_game_table, asa_pieces_id, 0) deal_pieces_txn = unsigned_asset_send(algod_client, dealer['pk'], addr_game_table, asa_pieces_id, asa_pieces_total) # Dealer Gorup Transaction dealer_gid = transaction.calculate_group_id( [gt_opt_in_txn, deal_pieces_txn]) gt_opt_in_txn.group = dealer_gid deal_pieces_txn.group = dealer_gid gt_opt_in_lstxn = transaction.LogicSigTransaction(gt_opt_in_txn, game_table_lsig) deal_pieces_stxn = deal_pieces_txn.sign(dealer['sk']) dealer_sgtxn = [gt_opt_in_lstxn, deal_pieces_stxn] txid = algod_client.send_transactions(dealer_sgtxn) print("Transaction ID: ", txid) wait_for_tx_confirmation(algod_client, txid) # TEAL: AlgoNim ASC1 Bet Escrow print("") print("Dealer writing AlgoNim ASC1 Bet Escrow TEAL for Palyer 1...") asc1_dealer_bet_escrow_source, dealer_bet_escrow_expiry_block = asc1_bet_escrow_teal( algod_client, asa_pieces_total, asa_pieces_id, asa_turn_id, dealer['pk'], opponent['pk'], addr_sink, addr_game_table, match_hours_timeout) asc1_dealer_bet_escrow_compiled = algod_client.compile( asc1_dealer_bet_escrow_source) dealer_bet_escrow_lsig = transaction.LogicSig( base64.decodebytes(asc1_dealer_bet_escrow_compiled['result'].encode())) addr_dealer_bet_escrow = asc1_dealer_bet_escrow_compiled['hash'] print("") print("Dealer writing AlgoNim ASC1 Bet Escrow TEAL for Palyer 2...") asc1_opponent_bet_escrow_source, opponent_bet_escrow_expiry_block = asc1_bet_escrow_teal( algod_client, asa_pieces_total, asa_pieces_id, asa_turn_id, opponent['pk'], dealer['pk'], addr_sink, addr_game_table, match_hours_timeout) asc1_opponent_bet_escrow_compiled = algod_client.compile( asc1_opponent_bet_escrow_source) opponent_bet_escrow_lsig = transaction.LogicSig( base64.decodebytes( asc1_opponent_bet_escrow_compiled['result'].encode())) addr_opponent_bet_escrow = asc1_opponent_bet_escrow_compiled['hash'] # Initialize AlgoNim ASC1 Escrows with 0.1 ALGO print("") print("Initializing Bet Escrow Accounts...") send(algod_client, dealer, addr_dealer_bet_escrow, 100000) print("") send(algod_client, dealer, addr_opponent_bet_escrow, 100000) # Creating Bet Atomic Transfer to be signed by the Opponent dealer_bet_stxn, opponent_bet_txn = bet_atomic_transfer( algod_client, dealer, opponent['pk'], addr_dealer_bet_escrow, addr_opponent_bet_escrow, microalgo_bet_amount) match_data = {} match_data['dealer'] = dealer['pk'] match_data['opponent'] = opponent['pk'] match_data['asa_pieces_id'] = asa_pieces_id match_data['asa_pieces_max_remove'] = asa_pieces_max_remove match_data['asa_turn_id'] = asa_turn_id match_data['sink'] = addr_sink match_data['sink_lsig'] = encoding.msgpack_encode(sink_lsig) match_data['game_table'] = addr_game_table match_data['game_table_lsig'] = encoding.msgpack_encode(game_table_lsig) match_data['dealer_bet_escrow'] = addr_dealer_bet_escrow match_data['dealer_bet_escrow_lsig'] = encoding.msgpack_encode( dealer_bet_escrow_lsig) match_data['opponent_bet_escrow'] = addr_opponent_bet_escrow match_data['opponent_bet_escrow_lsig'] = encoding.msgpack_encode( opponent_bet_escrow_lsig) match_data['dealer_bet_stxn'] = encoding.msgpack_encode(dealer_bet_stxn) match_data['opponent_bet_txn'] = encoding.msgpack_encode(opponent_bet_txn) match_data['microalgo_bet_amount'] = microalgo_bet_amount match_data['match_hours_timeout'] = match_hours_timeout match_data['dealer_bet_escrow_expiry'] = dealer_bet_escrow_expiry_block match_data['opponent_bet_escrow_expiry'] = opponent_bet_escrow_expiry_block match_data_bytes = msgpack.packb(match_data) match_data_fname = 'algonim.match' with open(match_data_fname, "wb") as f: f.write(match_data_bytes) f.close() print(" ") print(" _ _ ") print(" /\/\ __ _| |_ ___| |__ _ ") print(" / \ / _` | __/ __| '_ \ (_)") print("/ /\/\ \ (_| | || (__| | | | _ ") print("\/ \/\__,_|\__\___|_| |_| (_)") print(" ") print("MATCH DURATION:\t\t", match_data['match_hours_timeout'] * 60, "min") print("PIECES ON GAME TABLE:\t", asa_pieces_total, "\n") print("RULES:") print("1. Players on each turn must remove at least 1 ASA Piece") print("2. Players on each turn must remove at most", match_data['asa_pieces_max_remove'], "ASA Piece") print("3. Who removes the last ASA Piece form the Game Table wins the " + "match!\n") print("Player 1 - Dealer:\t" + match_data['dealer']) print("Player 2 - Opponent:\t" + match_data['opponent'], "\n") print("AlgoNim ASA Pieces ID:\t", match_data['asa_pieces_id']) print("AlgoNim ASA Turn ID:\t", match_data['asa_turn_id'], "\n") print("AlgoNim Sink Account:\t\t\t" + match_data['sink']) print("AlgoNim Game Table Account:\t\t" + match_data['game_table']) print("AlgoNim Bet Escrow Player 1 Account:\t" + match_data['dealer_bet_escrow']) print("AlgoNim Bet Escrow Player 2 Account:\t" + match_data['opponent_bet_escrow']) print("\nSend 'algonim.match' file to your opponent join the match!\n") print("May the best win!\n")
# get the mnemonic for address_1 mn = mnemonic.from_private_key(private_key_1) print("Mnemonic for the first account: " + mn + "\n") # get suggested parameters sp = acl.suggested_params() # get last block info block_info = acl.block_info(sp.first) print("Block", sp.first, "info:", json.dumps(block_info, indent=2), "\n") # create a transaction amount = 100000 txn = transaction.PaymentTxn(existing_account, sp, address_1, amount) print("Encoded transaction:", encoding.msgpack_encode(txn), "\n") # sign transaction with kmd signed_with_kmd = kcl.sign_transaction(existing_handle, existing_wallet_pswd, txn) # get the private key for the existing account private_key = kcl.export_key(existing_handle, existing_wallet_pswd, existing_account) # sign transaction offline signed_offline = txn.sign(private_key) print("Signature: " + signed_offline.signature + "\n") # check that they're the same if signed_offline.dictify() == signed_with_kmd.dictify():
"Please go to: https://bank.testnet.algorand.network/ to fund your multisig account." + '\n' + "Press Enter to continue...") # get suggested parameters params = acl.suggested_params() gen = params["genesisID"] gh = params["genesishashb64"] last_round = params["lastRound"] fee = params["fee"] # create a transaction sender = msig.address() recipient = "4CXXFP3SJJW63HGEQD4OPSDPPIYDW7BXCVP4DQZG7T33Z3BXTOA4UMEDM4" amount = 10000 txn = transaction.PaymentTxn(sender, fee, last_round, last_round + 100, gh, recipient, amount) # create a SignedTransaction object mtx = transaction.MultisigTransaction(txn, msig) # sign the transaction mtx.sign(private_key_1) mtx.sign(private_key_2) # print encoded transaction print(encoding.msgpack_encode(mtx)) # send the transaction transaction_id = acl.send_raw_transaction(encoding.msgpack_encode(mtx)) print("\nTransaction was sent!") print("Transaction ID: " + transaction_id + "\n")