def group_transactions() : # recover a account passphrase1 = <25-word-passphrase> pk_account_a = mnemonic.to_private_key(passphrase1) account_a = account.address_from_private_key(pk_account_a) # recover b account passphrase2 = <25-word-passphrase> pk_account_b = mnemonic.to_private_key(passphrase2) account_b = account.address_from_private_key(pk_account_b) # recover c account passphrase3 = <25-word-passphrase> pk_account_c = mnemonic.to_private_key(passphrase3) account_c = account.address_from_private_key(pk_account_c) # connect to node acl = connect_to_network() # get suggested parameters params = acl.suggested_params() gen = params["genesisID"] gh = params["genesishashb64"] last_round = params["lastRound"] fee = params["fee"] amount = 1000 # create transaction1 txn1 = transaction.PaymentTxn(account_a, fee, last_round, last_round+100, gh, account_c, amount) # create transaction2 txn2 = transaction.PaymentTxn(account_b, fee, last_round, last_round+100, gh, account_a, amount) # get group id and assign it to transactions gid = transaction.calculate_group_id([txn1, txn2]) txn1.group = gid txn2.group = gid # sign transaction1 stxn1 = txn1.sign(pk_account_a) # sign transaction2 stxn2 = txn2.sign(pk_account_b) signedGroup = [] signedGroup.append(stxn1) signedGroup.append(stxn2) # send them over network sent = acl.send_transactions(signedGroup) # print txid print(sent) # wait for confirmation wait_for_confirmation( acl, sent)
def fund_contract(context): context.txn = transaction.PaymentTxn(context.accounts[0], context.params, context.template.get_address(), context.fund_amt) context.txn = context.wallet.sign_transaction(context.txn) context.acl.send_transaction(context.txn) context.acl.status_after_block(context.acl.status()["lastRound"] + 3)
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 unsigned_send(algod_client, addr_sender, addr_receiver, microalgo_amount, validity_range=1000): """HELP unsigned_send: (AlgodClient, str, str, int, int) - Returns an unsigned PaymentTxn. """ assert type(microalgo_amount) == int and validity_range <= 1000 # Get network suggested params for transactions. params = algod_client.suggested_params() first_valid = params.first last_valid = first_valid + validity_range gh = params.gh min_fee = params.min_fee assert min_fee <= 1000 data = { "sender": addr_sender, "receiver": addr_receiver, "fee": min_fee, "first": first_valid, "last": last_valid, "gh": gh, "amt": int(microalgo_amount), "flat_fee": True, } return transaction.PaymentTxn(**data)
def send(self) -> "WithdrawTransaction": """ Send the transaction with the parameters given during initialization of the class Gets the redis tx id to preserve creation order (TODO : create the transaction with the send time and update it when confirmed with confirmation time) """ params = self.params txn = transaction.PaymentTxn(self.sender.wallet.public_key, params.min_fee, params.first, params.last, params.gh, self.destination, algos_to_microalgos(self.amount), note=str.encode(self.message), close_remainder_to=None if not self.close_account else self.destination, flat_fee=True) signed_txn = txn.sign(self.sender.wallet.private_key) algod.send_transaction(signed_txn) self.time = time_ns() * 1e-6 self.tx_id = signed_txn.transaction.get_txid() self.redis_tx_id = redis.incr("transaction-id") console.log(f"Withdrawal #{self.redis_tx_id} sent by {self.sender.name}")
def send(algod_client, sender, addr_receiver, microalgo_amount, validity_range=1000): """HELP send: (AlgodClient, dict, str, int, int) - Executes a PaymentTxn. """ assert type(microalgo_amount) == int and validity_range <= 1000 # Get network suggested params for transactions. params = algod_client.suggested_params() first_valid = params.first last_valid = first_valid + validity_range gh = params.gh min_fee = params.min_fee assert min_fee <= 1000 data = { "sender": sender['pk'], "fee": min_fee, "first": first_valid, "last": last_valid, "gh": gh, "receiver": addr_receiver, "amt": int(microalgo_amount), "flat_fee": True } txn = transaction.PaymentTxn(**data) stxn = txn.sign(sender['sk']) txid = algod_client.send_transaction(stxn) print("Transaction ID:", txid) wait_for_tx_confirmation(algod_client, txid)
def unsigned_closeto(algod_client, sender, closeto, validity_range=1000): """HELP unsigned_closeto: (AlgodClient, dict, str, int) - Returns an unsigned PaymentTxn with close-to account. """ # Get network suggested params for transactions. assert validity_range <= 1000 params = algod_client.suggested_params() first_valid = params.first last_valid = first_valid + validity_range gh = params.gh min_fee = params.min_fee assert min_fee <= 1000 data = { "sender": sender, "receiver": closeto, "fee": min_fee, "first": first_valid, "last": last_valid, "gh": gh, "amt": 0, "flat_fee": True, "close_remainder_to": closeto } return transaction.PaymentTxn(**data)
def create_msigpaytxn(context): context.txn = transaction.PaymentTxn(context.msig.address(), context.fee, context.fv, context.lv, context.gh, context.to, context.amt, context.close, context.note, context.gen) context.mtx = transaction.MultisigTransaction(context.txn, context.msig)
def send_tokens(receiver_pk, tx_amount): params = acl.suggested_params() gen_hash = params.gh first_valid_round = params.first tx_fee = params.min_fee last_valid_round = params.last #Your code here #generate an account mnemonic_secret = 'ship floor pattern transfer fiscal diamond maid raise never debate lemon brown siren upset gun sibling lend write cloth success glove shrug cattle ability ivory' sk = mnemonic.to_private_key(mnemonic_secret) pk = mnemonic.to_public_key(mnemonic_secret) print("my public key = ", pk) account_info = acl.account_info(pk) #prepare and sign the transaction tx = transaction.PaymentTxn(pk, tx_fee, first_valid_round, last_valid_round, gen_hash, receiver_pk, tx_amount) signed_tx = tx.sign(sk) #send the signed transaction tx_confirm = acl.send_transaction(signed_tx) #acl.status_after_block(first_valid_round+2) txid = signed_tx.transaction.get_txid() wait_for_confirmation(acl, txid) sender_pk = pk return sender_pk, txid
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 send(self) -> "TipTransaction": """ Perform checks to make sure that the transaction can be done before creating it and sending it Returns: Transaction: returns itself if the transaction was successfully None otherwise """ params = self.params txn = transaction.PaymentTxn(self.sender.wallet.public_key, params.min_fee, params.first, params.last, params.gh, self.receiver.wallet.public_key, algos_to_microalgos(self.amount), note=str.encode(self.message), flat_fee=True) signed_txn = txn.sign(self.sender.wallet.private_key) algod.send_transaction(signed_txn) self.time = time_ns() * 1e-6 self.tx_id = signed_txn.transaction.get_txid() self.redis_tx_id = redis.incr("transaction-id") console.log(f"Transaction #{self.redis_tx_id} sent by {self.sender.name} to {self.receiver.name}")
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 execute(self, address, station, temperature): program = base64.b64decode( "ASAG0A8BAAWo7Y0CUCYCIPQv9Dp6BUP5IWgVnUMxQ41GHJYlTMUn5MaVgxmacIXBIHiNgRcdCvcgzeloO+LUHFaqn/aCtb6wV9B8WJqe5FcWMQEiDDEQIxIQMQgkEhAxCSgSMQcyAxIQLRclEhAxAiEEDhAuFyEFDhAxCSkSMQcyAxIQMQIhBA0uFyEFDREQERA=" ) lsig = transaction.LogicSig(program, args=[[station], [temperature]]) sender = lsig.address() # get suggested parameters params = self.algod.suggested_params() gh = params["genesishashb64"] last_round = params["lastRound"] fee = params["fee"] txn = transaction.PaymentTxn( sender, fee, last_round, last_round + 1000, gh, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ", 0, close_remainder_to=address) # note, transaction is signed by logic only (no delegation) # that means sender address must match to program hash lstx = transaction.LogicSigTransaction(txn, lsig) assert lstx.verify() # send them over network return self.algod.send_transaction( lstx, headers={'content-type': 'application/x-binary'})
def track(self, station: int, temperature: int): """ posts the tracking information to the blockchain :param station: :param temperature: :return: """ # get suggested parameters params = self.algod.suggested_params() gen = params["genesisID"] gh = params["genesishashb64"] last_round = params["lastRound"] fee = params["fee"] note = {'s': station, 't': temperature} # create the transaction txn = transaction.PaymentTxn(account.address_from_private_key(self.sk), fee, last_round, last_round + 1000, gh, self.namespace_address, 0, note=json.dumps(note).encode()) # sign it stx = txn.sign(self.sk) # send it return self.algod.send_transaction( stx, headers={'content-type': 'application/x-binary'})
def default_txn(context, amt, note): params = context.acl.suggested_params() context.last_round = params["lastRound"] if note == "none": note = None else: note = base64.b64decode(note) context.txn = transaction.PaymentTxn(context.accounts[0], params["fee"], context.last_round, context.last_round+1000, params["genesishashb64"], context.accounts[1], int(amt), note=note, gen=params["genesisID"]) context.pk = context.accounts[0]
def store_purchase(event, user): note_field_bytes = json.dumps(user).encode() al = algod.AlgodClient(al_token, al_address) params = al.suggested_params() gh = "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=" txn = transaction.PaymentTxn(event["address"], 0, params.get("lastRound"), params.get("lastRound")+1000, gh, dapp["address"], 1, note=note_field_bytes) txn = txn.sign(event["private_key"]) return al.send_raw_transaction(txn)
def scenario3(): """ Alice transfers all her algos to Bob. """ amount = 1 fee = 1000 data = (alice, fee, first_valid, last_valid, genesis_hash, bob, amount) data_add = {"gen": genesis_id, "flat_fee": True, "close_remainder_to": bob} tx = transaction.PaymentTxn(*data, **data_add) return tx
def algorandSequence(): algod_address = "https://testnet-algorand.api.purestake.io/ps2" algod_token = "" headers = { "X-API-Key": "zLAOcinLq31BhPezSnHQL3NF7qBwHtku6XwN8igq", } algod_client = algod.AlgodClient(algod_token, algod_address, headers) status = algod_client.status() print(json.dumps(status, indent=4)) passphrase = "thunder fun scout myself talk repeat hurry miracle puppy run vocal vicious shove fever idea lens above diesel action pulp before cigar horror above mass" private_key = mnemonic.to_private_key(passphrase) my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) account_info = algod_client.account_info(my_address) print("Account balance: {} microAlgos".format(account_info.get('amount'))) params = algod_client.suggested_params() note = "Hello World".encode() receiver = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A" data = { "sender": my_address, "receiver": receiver, "fee": params.get('minFee'), "flat_fee": True, "amt": 20, "first": params.get('lastRound'), "last": params.get('lastRound') + 1000, "note": note, "gen": params.get('genesisID'), "gh": params.get('genesishashb64') } txn = transaction.PaymentTxn(**data) signed_txn = txn.sign(private_key) txid = signed_txn.transaction.get_txid() print("Signed transaction with txID: {}".format(txid)) algod_client.send_transaction( signed_txn, headers={'content-type': 'application/x-binary'}) wait_for_confirmation(algod_client, txid) try: confirmed_txn = algod_client.transaction_info(my_address, txid) except Exception as err: print(err) print("Transaction information: {}".format( json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format( base64.b64decode(confirmed_txn.get('noteb64')).decode()))
def group_transactions(): # recover a account passphrase1 = os.getenv("MNEMONIC1") pk_account_a = mnemonic.to_private_key(passphrase1) account_a = account.address_from_private_key(pk_account_a) # recover b account account_b = "4O6BRAPVLX5ID23AZWV33TICD35TI6JWOHXVLPGO4VRJATO6MZZQRKC7RI" # connect to node acl = connect_to_network() # get suggested parameters params = acl.suggested_params() gen = params["genesisID"] gh = params["genesishashb64"] last_round = params["lastRound"] fee = params["fee"] asset_index = 14035004 # create transaction1 txn1 = transaction.PaymentTxn(account_a, fee, last_round, last_round + 100, gh, account_b, 42000000) # create transaction2 txn2 = transaction.AssetTransferTxn(account_b, fee, last_round, last_round + 100, gh, account_a, 1, asset_index) # get group id and assign it to transactions gid = transaction.calculate_group_id([txn1, txn2]) txn1.group = gid txn2.group = gid # sign transaction1 stxn1 = txn1.sign(pk_account_a) # sign transaction2 with open("buildweb3/step5.lsig", "rb") as f: lsig = encoding.future_msgpack_decode(base64.b64encode(f.read())) stxn2 = transaction.LogicSigTransaction(txn2, lsig) signedGroup = [] signedGroup.append(stxn1) signedGroup.append(stxn2) # send them over network sent = acl.send_transactions(signedGroup) # print txid print(sent) # wait for confirmation wait_for_confirmation(acl, sent)
def test_errors(self): # get random private key private_key_1, account_1 = account.generate_account() private_key_2, account_2 = account.generate_account() private_key_3, account_3 = account.generate_account() # create transaction gh = "JgsgCaCTqIaLeVhyL6XlRu3n7Rfk2FxMeK+wRSaQ7dI=" txn = transaction.PaymentTxn(account_2, 3, 1234, 1334, gh, account_2, 1000) # create multisig address with invalid version msig = transaction.Multisig(2, 2, [account_1, account_2]) self.assertRaises(error.UnknownMsigVersionError, msig.validate) # change it to have invalid threshold msig.version = 1 msig.threshold = 3 self.assertRaises(error.InvalidThresholdError, msig.validate) # try to sign multisig transaction msig.threshold = 2 mtx = transaction.MultisigTransaction(txn, msig) self.assertRaises(error.BadTxnSenderError, mtx.sign, private_key_1) # change sender address to be correct txn.sender = msig.address() mtx = transaction.MultisigTransaction(txn, msig) # try to sign with incorrect private key self.assertRaises(error.InvalidSecretKeyError, mtx.sign, private_key_3) # create another multisig with different address msig_2 = transaction.Multisig(1, 2, [account_2, account_3]) # try to merge with different addresses mtx_2 = transaction.MultisigTransaction(txn, msig_2) self.assertRaises(error.MergeKeysMismatchError, transaction.MultisigTransaction.merge, [mtx, mtx_2]) # create another multisig with same address msig_3 = msig_2.get_multisig_account() # add mismatched signatures msig_2.subsigs[0].signature = "sig2" msig_3.subsigs[0].signature = "sig3" # try to merge self.assertRaises(error.DuplicateSigMismatchError, transaction.MultisigTransaction.merge, [ transaction.MultisigTransaction(txn, msig_2), transaction.MultisigTransaction(txn, msig_3) ])
def create_paytxn_flat_fee(context): context.txn = transaction.PaymentTxn(context.pk, context.fee, context.fv, context.lv, context.gh, context.to, context.amt, context.close, context.note, context.gen, flat_fee=True)
def test_min_txn_fee(self): address = "7ZUECA7HFLZTXENRV24SHLU4AVPUTMTTDUFUBNBD64C73F3UHRTHAIOF6Q" gh = "JgsgCaCTqIaLeVhyL6XlRu3n7Rfk2FxMeK+wRSaQ7dI=" txn = transaction.PaymentTxn(address, 0, 1, 100, gh, address, 1000, note=b'\x00') self.assertEqual(constants.min_txn_fee, txn.fee)
def genTxns(): yield transaction.PaymentTxn( sender="YK54TGVZ37C7P76GKLXTY2LAH2522VD3U2434HRKE7NMXA65VHJVLFVOE4", receiver="RNZZNMS5L35EF6IQHH24ISSYQIKTUTWKGCB4Q5PBYYSTVB5EYDQRVYWMLE", fee=0.001, flat_fee=True, amt=1000000, first=5667360, last=5668360, note="Hello World".encode(), gen="testnet-v1.0", gh="SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=")
def scenario1(): """ Alice sends 100 Algos to Bob with flat fee. """ amount = 100000000 fee = 1000 data = (alice, fee, first_valid, last_valid, genesis_hash, bob, amount) data_add = {"gen": genesis_id, "flat_fee": True} tx = transaction.PaymentTxn(*data, **data_add) return tx
def scenario2(): """ Alice sends 100 Algos to Bob with suggested fee and a 1 KB note. """ amount = 100000000 note = b''.join(b'a' for item in range(1000)) data = (alice, fee_per_byte, first_valid, last_valid, genesis_hash, bob, amount) data_add = {"gen": genesis_id, "note": note} tx = transaction.PaymentTxn(*data, **data_add) return tx
def default_txn(context, amt, note): params = context.acl.suggested_params() context.last_round = params.first if note == "none": note = None else: note = base64.b64decode(note) context.txn = transaction.PaymentTxn(context.accounts[0], params, context.accounts[1], int(amt), note=note) context.pk = context.accounts[0]
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 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 create_transaction(privateKey, my_address, receiver, amount): txn = { "sender": my_address, "receiver": receiver, "fee": params.get('minFee'), "flat_fee": True, "amt": amount, "first": params.get('lastRound'), "last": params.get('lastRound') + 1000, "note": note, "gen": params.get('genesisID'), "gh": params.get('genesishashb64') } return transaction.PaymentTxn(**txn)