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 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 get_accounts(network):
if (network == "Testnet"):
# SQEZQ2G5KAI4GM3LM6VRDTTLWQO6JDOSZHNG4Q5BJ4FZ34GVNTBZWFBURU
passphrase = "hotel wide vital oak frost example stove coast hero toward win tail climb hero reveal army hole old habit parade cereal such nephew absent inhale"
private_key = mnemonic.to_private_key(passphrase)
my_address = mnemonic.to_public_key(passphrase)
print("My address: {}".format(my_address))
return [(my_address, private_key)]
else:
kmd = KMDClient(KMD_TOKEN, KMD_ADDRESS)
wallets = kmd.list_wallets()
walletID = None
for wallet in wallets:
if wallet["name"] == KMD_WALLET_NAME:
walletID = wallet["id"]
break
if walletID is None:
raise Exception("Wallet not found: {}".format(KMD_WALLET_NAME))
walletHandle = kmd.init_wallet_handle(walletID, KMD_WALLET_PASSWORD)
try:
addresses = kmd.list_keys(walletHandle)
privateKeys = [
kmd.export_key(walletHandle, KMD_WALLET_PASSWORD, addr)
for addr in addresses
]
kmdAccounts = [(addresses[i], privateKeys[i])
for i in range(len(privateKeys))]
finally:
kmd.release_wallet_handle(walletHandle)
return kmdAccounts
def claim_interest(programstr, escrow_id, passphrase, amt, coupon, payment_id,
interest_id, par_id, first_block, last_block,
algod_client: algod_client()):
add = mnemonic.to_public_key(passphrase)
key = mnemonic.to_private_key(passphrase)
sp = algod_client.suggested_params()
sp.first = first_block
sp.last = last_block
sp.flat_fee = True
sp.fee = 1000
print("--------------------------------------------")
print("Bundling interest claim and submitting......")
txn1 = AssetTransferTxn(add, sp, escrow_id, amt, interest_id)
txn2 = AssetTransferTxn(add, sp, add, amt, par_id)
txn3 = AssetTransferTxn(escrow_id, sp, add, amt * coupon, payment_id)
t = programstr.encode()
program = base64.decodebytes(t)
arg = (4).to_bytes(8, 'big')
lsig = LogicSig(program, args=[arg])
grp_id = calculate_group_id([txn1, txn2, txn3])
txn1.group = grp_id
txn2.group = grp_id
txn3.group = grp_id
stxn1 = txn1.sign(key)
stxn2 = txn2.sign(key)
stxn3 = LogicSigTransaction(txn3, lsig)
signed_group = [stxn1, stxn2, stxn3]
tx_id = algod_client.send_transactions(signed_group)
wait_for_confirmation(algod_client, tx_id, 200)
print("Successfully committed transaction!")
print("--------------------------------------------")
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 distribute_dividends(asset_info):
print("Distributing dividends for: ", asset_info['bond_name'])
params = algod_client.suggested_params()
purchases = [purchase for purchase in db.transaction.find({})
if purchase['asset_id'] == asset_info['asset_id'] and purchase['action'] == 'BUY']
for purchase in purchases:
user_id = purchase['user_id']
user = db.user.find_one({'_id': user_id})
user_mnemonic = user['mnemonic']
user_pk = mnemonic.to_public_key(user_mnemonic)
amount = int(asset_info["coupon_rate"])/100*int(asset_info["face_value"]) *\
(int(purchase['tokens'])/asset_info['issue_size']) # Fraction of real estate owned
##
txn = AssetTransferTxn(
sender=accounts[1]['pk'],
sp=params,
receiver=user_pk,
amt=int(amount),
index=USDT_asset_id)
stxn = txn.sign(accounts[1]['sk'])
txid = algod_client.send_transaction(stxn)
print(txid)
# Wait for the transaction to be confirmed
wait_for_confirmation(algod_client, txid)
# The balance should now be 10.
print_asset_holding(algod_client, user_pk, USDT_asset_id)
# Save Dividend Transaction
db_dividend_tx = db.dividends.insert_one({
'user_id': user_mnemonic,
'amount': amount,
'asset_id': asset_info['asset_id']
})
def write_signed_transaction_to_file():
algod_client = connect_to_network()
passphrase = "price clap dilemma swim genius fame lucky crack torch hunt maid palace ladder unlock symptom rubber scale load acoustic drop oval cabbage review abstract embark"
# generate a public/private key pair
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')))
# build transaction
params = algod_client.suggested_params()
# comment out the next two (2) lines to use suggested fees
# params.flat_fee = True
# params.fee = 1000
receiver = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A"
note = "Hello World".encode()
unsigned_txn = PaymentTxn(
my_address, params, receiver, 100000, None, note)
# sign transaction
signed_txn = unsigned_txn.sign(mnemonic.to_private_key(passphrase))
# write to file
dir_path = os.path.dirname(os.path.realpath(__file__))
transaction.write_to_file([signed_txn], dir_path + "/signed.txn")
def read_unsigned_transaction_from_file():
algod_client = connect_to_network()
passphrase = "price clap dilemma swim genius fame lucky crack torch hunt maid palace ladder unlock symptom rubber scale load acoustic drop oval cabbage review abstract embark"
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')))
dir_path = os.path.dirname(os.path.realpath(__file__))
txns = transaction.retrieve_from_file(dir_path + "/unsigned.txn")
# sign and submit transaction
txn = txns[0]
signed_txn = txn.sign(mnemonic.to_private_key(passphrase))
txid = signed_txn.transaction.get_txid()
print("Signed transaction with txID: {}".format(txid))
try:
txid = algod_client.send_transaction(signed_txn)
# wait for confirmation
confirmed_txn = wait_for_confirmation(algod_client, txid, 4)
print("TXID: ", txid)
print("Result confirmed in round: {}".format(confirmed_txn['confirmed-round']))
except Exception as err:
print(err)
return
print("Transaction information: {}".format(
json.dumps(confirmed_txn, indent=4)))
print("Decoded note: {}".format(base64.b64decode(
confirmed_txn["txn"]["txn"]["note"]).decode()))
def send_note():
algod_address = "https://testnet-algorand.api.purestake.io/ps2"
algod_token = "WgL4G2ZZf22GsqUIKHvCY9BSJyXQzZS8aTIpnMnp"
headers = {
"X-API-Key": algod_token,
}
algod_client = algod.AlgodClient(algod_token, algod_address, headers)
# In addition to setting up the client and transaction
# See GitHub for wait_for_confirmation() definition
# get suggested parameters from Algod
params = algod_client.suggested_params()
gen = params.gen
gh = params.gh
first_valid_round = params.first
last_valid_round = params.last
fee = params.min_fee
send_amount = 1
passphrase = "giraffe push drop glove cave cancel around roof talk example surprise atom foil outside anger right pistol stadium agent scheme patient script enrich able green"
private_key = mnemonic.to_private_key(passphrase)
my_address = mnemonic.to_public_key(passphrase)
print("My address: {}".format(my_address))
params = algod_client.suggested_params()
print(params)
# comment out the next two (2) lines to use suggested fees
params.flat_fee = True
params.fee = 1000
note = 'd8fc8839456e636d5cd3cb7e8642ce5a4d2b3a53bc02690d2b2ea0b0639c57eb'.encode(
) #content should be the hash
receiver = "GOXL7P62EJNZF6B2ISN3EHT3NX6NWD4HQ77ER7WJRQRO5YGHNGT3RGL5LA"
unsigned_txn = PaymentTxn(my_address, params, receiver, 1000000, None,
note)
# sign transaction
signed_txn = unsigned_txn.sign(private_key)
# send transaction
txid = algod_client.send_transaction(signed_txn)
print("Send transaction with txID: {}".format(txid))
# wait for confirmation
try:
confirmed_txn = wait_for_confirmation(algod_client, txid, 4)
except Exception as err:
print(err)
return
print(
"txID: {}".format(txid), " confirmed in round: {}".format(
confirmed_txn.get("confirmed-round", 0)))
print("Transaction information: {}".format(
json.dumps(confirmed_txn, indent=2)))
print("Decoded note: {}".format(
base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode()))
def replenish_account(passphrase, escrow_id, amt, payment_id, algod_client):
add = mnemonic.to_public_key(passphrase)
key = mnemonic.to_private_key(passphrase)
sp = algod_client.suggested_params()
sp.flat_fee = True
sp.fee = 1000
txn = AssetTransferTxn(add, sp, escrow_id, amt, payment_id)
stxn = txn.sign(key)
tx_id = algod_client.send_transaction(stxn)
wait_for_confirmation(algod_client, tx_id, 10)
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 p2p_order(buyer, seller, order_details):
params = algod_client.suggested_params()
buyer_pk = mnemonic.to_public_key(buyer)
buyer_sk = mnemonic.to_private_key(buyer)
seller_pk = mnemonic.to_public_key(seller)
seller_sk = mnemonic.to_private_key(seller)
# activate buyer's account
print("Activating Buyer's account")
activate_account(order_details['asset_id'], buyer)
# Token transaction
print("\n Executing Token Transaction")
token_txn = AssetTransferTxn(
sender=seller_pk,
sp=params,
receiver=buyer_pk,
amt=int(order_details['token_amount']),
index=order_details['asset_id'])
token_stxn = token_txn.sign(seller_sk)
token_txid = algod_client.send_transaction(token_stxn)
print(token_txid)
wait_for_confirmation(algod_client, token_txid)
print_asset_holding(algod_client, buyer_pk, order_details['asset_id'])
# Activating USDT for seller
print("Activating USDT for Seller")
activate_account(USDT_asset_id, seller)
# USDT Transaction
print("\n USDT Transaction")
usdt_txn = AssetTransferTxn(
sender=buyer_pk,
sp=params,
receiver=seller_pk,
amt=int(order_details['usdt_amount']),
index=USDT_asset_id)
usdt_stxn = usdt_txn.sign(buyer_sk)
usdt_txid = algod_client.send_transaction(usdt_stxn)
print(usdt_txid)
wait_for_confirmation(algod_client, usdt_txid)
print_asset_holding(algod_client, seller_pk, USDT_asset_id)
def transferDocument(algod_client, loc_id, bol_id, seller_pk, buyer_mnemonic,
carrier_mnemonic):
buyer_sk = mnemonic.to_private_key(buyer_mnemonic)
buyer_pk = mnemonic.to_public_key(buyer_mnemonic)
carrier_sk = mnemonic.to_private_key(carrier_mnemonic)
carrier_sk = mnemonic.to_pubic_key(carrier_mnemonic)
txn1 = singleTransfer(buyer_pk, seller_pk, loc_id) #some params
txn2 = singleTransfer(carrier_sk, buyer_pk, bol_id) #some params
atomicTransfer(algod_client, txn1, txn2, buyer_sk,
carrier_sk) #some params
return None
def asset_transaction(passphrase, amt, rcv, asset_id, algod_client) -> dict:
params = algod_client.suggested_params()
add = mnemonic.to_public_key(passphrase)
key = mnemonic.to_private_key(passphrase)
params.flat_fee = True
params.fee = 1000
unsigned_txn = AssetTransferTxn(add, params, rcv, amt, asset_id)
signed = unsigned_txn.sign(key)
txid = algod_client.send_transaction(signed)
pmtx = wait_for_confirmation(algod_client, txid, 4)
return pmtx
def get_wallet_key_pairs(passphrase):
"""
@params{passphrase} - 25-word mnemonic string
Returns a dictionary containing the public key (account address) and private key of the wallet.
@returns {
'public_key': string,
'private_key': string
}
"""
return {
'public_key': mnemonic.to_public_key(passphrase),
'private_key': mnemonic.to_private_key(passphrase)
}
def createAsset(algod_client, passphrase, html, doc_id, doc_name):
# CREATE ASSET
# Get network params for transactions before every transaction.
params = algod_client.suggested_params()
# comment these two lines if you want to use suggested params
params.fee = 1000
params.flat_fee = True
# Account 1 creates an asset called latinum and
# sets Account 2 as the manager, reserve, freeze, and clawback address.
# Asset Creation transaction
account_pk = mnemonic.to_public_key(passphrase)
account_sk = mnemonic.to_private_key(passphrase)
txn = AssetConfigTxn(sender=account_pk,
sp=params,
total=1,
default_frozen=False,
unit_name=doc_id,
asset_name=doc_name,
manager=account_pk,
reserve=account_pk,
freeze=account_pk,
clawback=account_pk,
url=html,
decimals=0)
# Sign with secret key of creator
stxn = txn.sign(account_sk)
# Send the transaction to the network and retrieve the txid.
txid = algod_client.send_transaction(stxn)
print(txid)
# Retrieve the asset ID of the newly created asset by first
# ensuring that the creation transaction was confirmed,
# then grabbing the asset id from the transaction.
# Wait for the transaction to be confirmed
wait_for_confirmation(algod_client, txid)
try:
# Pull account info for the creator
# account_info = algod_client.account_info(accounts[1]['pk'])
# get asset_id from tx
# Get the new asset's information from the creator account
ptx = algod_client.pending_transaction_info(txid)
asset_id = ptx["asset-index"]
print_created_asset(algod_client, account_pk, asset_id)
print_asset_holding(algod_client, account_pk, asset_id)
except Exception as e:
print(e)
def send_note():
# Use sandbox or your address and token
algod_address = "<your-algod-node-and-port>"
algod_token = "<your-api-token>"
algod_client = algod.AlgodClient(algod_token, algod_address)
algod_address = "http://localhost:4001"
algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
algod_client = algod.AlgodClient(algod_token, algod_address)
#passphrase = "<your-25-word-mnemonic>"
passphrase = "price clap dilemma swim genius fame lucky crack torch hunt maid palace ladder unlock symptom rubber scale load acoustic drop oval cabbage review abstract embark"
private_key = mnemonic.to_private_key(passphrase)
my_address = mnemonic.to_public_key(passphrase)
print("My address: {}".format(my_address))
params = algod_client.suggested_params()
# comment out the next two (2) lines to use suggested fees
# params.flat_fee = True
# params.fee = 1000
note = '{"firstName":"JohnChris", "lastName":"Doe"}'.encode()
# note = 'JohnChris'.encode()
receiver = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A"
unsigned_txn = PaymentTxn(my_address, params, receiver, 100000, None, note)
# sign transaction
signed_txn = unsigned_txn.sign(private_key)
# wait for confirmation
try:
# send transaction
txid = algod_client.send_transaction(signed_txn)
print("Send transaction with txID: {}".format(txid))
confirmed_txn = wait_for_confirmation(algod_client, txid, 4)
except Exception as err:
print(err)
return
print(
"txID: {}".format(txid), " confirmed in round: {}".format(
confirmed_txn.get("confirmed-round", 0)))
print("Transaction information: {}".format(
json.dumps(confirmed_txn, indent=2)))
print("Decoded note: {}".format(
base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode()))
person_dict = json.loads(
base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode())
print("First Name = {}".format(person_dict['firstName']))
def gettingStartedExample():
algod_address = <algod-address>
algod_token = <algod-token>
algod_client = algod.AlgodClient(algod_token, algod_address)
passphrase = <25-word-mnemonic>
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": 1000000,
"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)
# wait for confirmation
wait_for_confirmation( algod_client, txid)
# Read the transction
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 claim_fund(programstr, passphrase, escrow_id, amt, payment_id, first_block,
last_block, algod_client: algod_client()):
add = mnemonic.to_public_key(passphrase)
key = mnemonic.to_private_key(passphrase)
sp = algod_client.suggested_params()
sp.first = first_block
sp.last = last_block
sp.flat_fee = True
sp.fee = 1000
txn = AssetTransferTxn(escrow_id, sp, add, amt, payment_id)
t = programstr.encode()
program = base64.decodebytes(t)
arg = (3).to_bytes(8, 'big')
lsig = LogicSig(program, args=[arg])
stxn = LogicSigTransaction(txn, lsig)
tx_id = algod_client.send_transaction(stxn)
wait_for_confirmation(algod_client, tx_id, 10)
def transfer_asset_holding_return_txn(algodclient, passphrase, receiver,
asset_id):
# transfer asset of 10 from account 1 to account 3
params = algod_client.suggested_params()
# comment these two lines if you want to use suggested params
params.fee = 1000
params.flat_fee = True
account_pk = mnemonic.to_public_key(passphrase)
account_sk = mnemonic.to_private_key(passphrase)
txn = AssetTransferTxn(sender=account_pk,
sp=params,
receiver=receiver,
amt=1,
index=asset_id)
return txn
def create_fund_accounts():
# For ease of reference, add account public and private keys to an accounts dict.
print("--------------------------------------------")
print("Creating Alice and Bob's accounts...")
mnemonics = []
mnemonics.append(create_account())
mnemonics.append(create_account(False))
accounts = {}
counter = 0
for m in mnemonics:
accounts[counter] = {}
accounts[counter]['pk'] = mnemonic.to_public_key(m)
accounts[counter]['sk'] = mnemonic.to_private_key(m)
counter += 1
return accounts
def purchase_bond(programstr, escrow_id, passphrase, amt, payment_id, par,
interest_id, par_id, total_payments,
algod_client: algod_client(), first_block, last_block):
add = mnemonic.to_public_key(passphrase)
key = mnemonic.to_private_key(passphrase)
sp = algod_client.suggested_params()
sp.first = first_block
sp.last = last_block
sp.flat_fee = True
sp.fee = 1000
print("--------------------------------------------")
print("Opt-in the buyer account for interest and par token......")
txn0_1 = AssetTransferTxn(add, sp, add, 0, interest_id)
txn0_2 = AssetTransferTxn(add, sp, add, 0, par_id)
sign0_1 = txn0_1.sign(key)
sign0_2 = txn0_2.sign(key)
txn0_1_id = algod_client.send_transaction(sign0_1)
wait_for_confirmation(algod_client, txn0_1_id, 5)
print("Successfully opt-in")
print("--------------------------------------------")
print("--------------------------------------------")
print("Bundling purchase transactions and submitting......")
txn0_2_id = algod_client.send_transaction(sign0_2)
wait_for_confirmation(algod_client, txn0_2_id, 5)
txn1 = AssetTransferTxn(add, sp, escrow_id, amt * par, payment_id)
txn2 = AssetTransferTxn(escrow_id, sp, add, amt, par_id)
txn3 = AssetTransferTxn(escrow_id, sp, add, amt * total_payments,
interest_id)
t = programstr.encode()
program = base64.decodebytes(t)
arg = (3).to_bytes(8, 'big')
lsig = LogicSig(program, args=[arg])
grp_id = calculate_group_id([txn1, txn2, txn3])
txn1.group = grp_id
txn2.group = grp_id
txn3.group = grp_id
stxn1 = txn1.sign(key)
stxn2 = LogicSigTransaction(txn2, lsig)
stxn3 = LogicSigTransaction(txn3, lsig)
signed_group = [stxn1, stxn2, stxn3]
tx_id = algod_client.send_transactions(signed_group)
wait_for_confirmation(algod_client, tx_id, 200)
print("Successfulley commited transaction!")
print("--------------------------------------------")
def __init__(self):
self.algod_address = "https://testnet-algorand.api.purestake.io/ps2"
self.algod_token = "zLAOcinLq31BhPezSnHQL3NF7qBwHtku6XwN8igq"
headers = {
"X-Api-key": self.algod_token,
# "X-Algo-API-Token": "asdf"
}
passphrase = "wedding shine wash pet apple force car taxi illegal scrap walnut virtual champion display glimpse barrel pioneer chat finish twenty increase hope patrol about stage"
self.private_key = mnemonic.to_private_key(passphrase)
self.my_address = mnemonic.to_public_key(passphrase)
print("My address: {}".format(self.my_address))
self.algod_client = algod.AlgodClient(self.algod_token, self.algod_address, headers)
self.status = self.algod_client.status()
# print(json.dumps(self.status, indent=4))
self.account_info = self.algod_client.account_info(self.my_address)
print("Account balance: {} microAlgos".format(self.account_info.get('amount')))
def send_note():
algod_address = "http://localhost:4001"
algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
algod_client = algod.AlgodClient(algod_token, algod_address)
passphrase = ""
private_key = mnemonic.to_private_key(passphrase)
my_address = mnemonic.to_public_key(passphrase)
print(f'My address: {my_address}')
params = algod_client.suggested_params()
# comment out the next two (2) lines to use suggested fees
params.flat_fee = True
params.fee = 1000
json_note = parse_into_json()
note = json_note.encode()
receiver = ""
unsigned_txn = PaymentTxn(my_address, params, receiver, 100000, None, note)
# sign transaction
signed_txn = unsigned_txn.sign(private_key)
# sign transaction
signed_txn = unsigned_txn.sign(private_key)
# send transaction
txid = algod_client.send_transaction(signed_txn)
print("Send transaction with txID: {}".format(txid))
# wait for confirmation
try:
confirmed_txn = wait_for_confirmation(algod_client, txid, 4)
except Exception as err:
print(err)
return
print(
"txID: {}".format(txid), "confirmed in round: {}".format(
confirmed_txn.get("confirmed-round", 0)))
print("Transaction information: {}".format(
json.dumps(confirmed_txn, indent=2)))
print("Decoded note: {}".format(
base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode()))
def getting_started_example():
algod_address = "http://localhost:4001"
algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
algod_client = algod.AlgodClient(algod_token, algod_address)
passphrase = "price clap dilemma swim genius fame lucky crack torch hunt maid palace ladder unlock symptom rubber scale load acoustic drop oval cabbage review abstract embark"
# generate a public/private key pair
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')))
# build transaction
params = algod_client.suggested_params()
# comment out the next two (2) lines to use suggested fees
params.flat_fee = True
params.fee = 1000
receiver = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A"
note = "Hello World".encode()
unsigned_txn = PaymentTxn(my_address, params, receiver, 1000000, None,
note)
# sign transaction
signed_txn = unsigned_txn.sign(mnemonic.to_private_key(passphrase))
txid = algod_client.send_transaction(signed_txn)
print("Signed transaction with txID: {}".format(txid))
# wait for confirmation
try:
confirmed_txn = wait_for_confirmation(algod_client, txid, 4)
except Exception as err:
print(err)
return
print("Transaction information: {}".format(
json.dumps(confirmed_txn, indent=4)))
print("Decoded note: {}".format(
base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode()))
def activate_account(asset_id, user_memonic):
# Check if asset_id is in account 3's asset holdings prior
# to opt-in
params = algod_client.suggested_params()
# comment these two lines if you want to use suggested params
params.fee = 0
params.flat_fee = False
params.min_fee = 0
account = {
'pk': mnemonic.to_public_key(user_memonic),
'sk': mnemonic.to_private_key(user_memonic)
}
account_info = algod_client.account_info(account['pk'])
holding = None
idx = 0
for my_account_info in account_info['assets']:
scrutinized_asset = account_info['assets'][idx]
idx = idx + 1
if (scrutinized_asset['asset-id'] == asset_id):
holding = True
break
if not holding:
# Use the AssetTransferTxn class to transfer assets and opt-in
txn = AssetTransferTxn(
sender=account['pk'],
sp=params,
receiver=account["pk"],
amt=0,
index=asset_id)
stxn = txn.sign(account['sk'])
txid = algod_client.send_transaction(stxn)
print(txid)
# Wait for the transaction to be confirmed
wait_for_confirmation(algod_client, txid)
# Now check the asset holding for that account.
# This should now show a holding with a balance of 0.
print_asset_holding(algod_client, account['pk'], asset_id)
def getting_started_example():
algod_address = "http://localhost:4001"
algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
algod_client = algod.AlgodClient(algod_token, algod_address)
passphrase = "Your 25-word mnemonic generated and displayed above"
# generate a public/private key pair
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')))
# build transaction
params = algod_client.suggested_params()
# comment out the next two (2) lines to use suggested fees
params.flat_fee = True
params.fee = 1000
receiver = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A"
note = "Hello World".encode()
unsigned_txn = PaymentTxn(my_address, params, receiver, 1000000, None, note)
# sign transaction
signed_txn = unsigned_txn.sign(mnemonic.to_private_key(passphrase))
txid = algod_client.send_transaction(signed_txn)
print("Signed transaction with txID: {}".format(txid))
# wait for confirmation
wait_for_confirmation(algod_client, txid)
# read transction
try:
confirmed_txn = algod_client.pending_transaction_info(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["txn"]["txn"]["note"]).decode()))
def claim_par(programstr, escrow_id, passphrase, amt, par, payment_id, par_id,
first_block, last_block, algod_client):
add = mnemonic.to_public_key(passphrase)
key = mnemonic.to_private_key(passphrase)
sp = algod_client.suggested_params()
sp.first = first_block
sp.last = last_block
sp.flat_fee = True
sp.fee = 1000
txn1 = AssetTransferTxn(add, sp, escrow_id, amt, par_id)
txn2 = AssetTransferTxn(escrow_id, sp, add, amt * par, payment_id)
t = programstr.encode()
program = base64.decodebytes(t)
arg = (5).to_bytes(8, 'big')
lsig = LogicSig(program, args=[arg])
grp_id = calculate_group_id([txn1, txn2])
txn1.group = grp_id
txn2.group = grp_id
stxn1 = txn1.sign(key)
stxn2 = LogicSigTransaction(txn2, lsig)
signed_group = [stxn1, stxn2]
tx_id = algod_client.send_transactions(signed_group)
wait_for_confirmation(algod_client, tx_id, 10)
def transfer_asset(asset_id, user_memonic, amount):
account = {
'pk': mnemonic.to_public_key(user_memonic),
'sk': mnemonic.to_private_key(user_memonic)
}
# transfer asset of 10 from account 1 to account 3
params = algod_client.suggested_params()
# comment these two lines if you want to use suggested params
params.fee = 1
params.flat_fee = True
txn = AssetTransferTxn(
sender=accounts[1]['pk'],
sp=params,
receiver=account["pk"],
amt=int(amount),
index=asset_id)
stxn = txn.sign(accounts[1]['sk'])
txid = algod_client.send_transaction(stxn)
print(txid)
# Wait for the transaction to be confirmed
wait_for_confirmation(algod_client, txid)
# The balance should now be 10.
print_asset_holding(algod_client, account['pk'], asset_id)
def par_token_issuance(algod_client, passphrase, proj_name, vol,
url) -> (int, int):
"""
Issues Token for Par Value Payment
returns an AssetConfigTxn()
"""
# sets basic transaction parameter
params = algod_client.suggested_params()
params.fee = 1000
params.flat_fee = True
address = mnemonic.to_public_key(passphrase)
key = mnemonic.to_private_key(passphrase)
# configure asset basics
txn = AssetConfigTxn(sender=address,
sp=params,
total=vol,
default_frozen=False,
unit_name=proj_name[0] + "PC",
asset_name=proj_name + "Par",
manager=address,
reserve=address,
freeze=address,
clawback=address,
url=url,
decimals=0)
signed = txn.sign(key)
txid = algod_client.send_transaction(signed)
wait_for_confirmation(algod_client, txid, 4)
try:
ptx = algod_client.pending_transaction_info(txid)
asset_id = ptx["asset-index"]
return txid, asset_id
except Exception as e:
print(e)
