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 sign(self, transaction):
decoded_program = base64.decodebytes(self.program.encode())
arg1 = logic.teal_sign_from_program(
self.project.owner.account.private_key,
self.secret.encode(),
decoded_program)
lsig = LogicSig(decoded_program, args=[arg1])
return LogicSigTransaction(transaction, lsig)
def sc_opt_in(self,sc_addr,sc_lsig,asset_id):
txn = self.sc_opt_in_asset(sc_addr,asset_id)
gid = transaction.calculate_group_id([txn])
txn.group = gid
lstx = LogicSigTransaction(txn, sc_lsig)
signedGroup = []
signedGroup.append(lstx)
tx_id = self.algod_client.send_transactions(signedGroup)
self.wait_for_confirmation(tx_id)
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 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 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)
# Create arg to pass if TEAL program requires an arg
# if not, omit args param
arg1 = (123).to_bytes(8, 'big')
lsig = LogicSig(program, args=[arg1])
sender = lsig.address()
# 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
# Build transaction
amount = 10000
closeremainderto = None
# Create a transaction
txn = PaymentTxn(sender, params, receiver, amount, closeremainderto)
# Create the LogicSigTransaction with contract account LogicSig
lstx = LogicSigTransaction(txn, lsig)
# transaction.write_to_file([lstx], "simple.stxn")
# Send raw LogicSigTransaction to network
txid = algod_client.send_transaction(lstx)
print("Transaction ID: " + txid)
wait_for_confirmation(algod_client, txid)
except Exception as e:
print(e)
def main_pub(passphrase, proj_name, vol, url, par, coupon, payment_id, closure,
start_round, period, total_payments, span, hold_up, client):
# ensuring that buyer will be able to claim coupon on start_round
add = mnemonic.to_public_key(passphrase)
key = mnemonic.to_private_key(passphrase)
print("Checking configurations......")
print("--------------------------------------------")
cl = client
if start_round % period != 0:
start_round = (start_round + period) - (start_round % period)
print("Start round for interest payment refactored to {}".format(
start_round))
end_round = start_round + (total_payments - 1) * period
print("--------------------------------------------")
# issuance of tokens
print("Issuing tokens......")
print("--------------------------------------------")
try:
interest_txid, interest_id = interest_token_issuance(
cl, passphrase, proj_name, vol, url, total_payments)
par_txid, par_id = par_token_issuance(cl, passphrase, proj_name, vol,
url)
except Exception as e:
print("Issuance failed :{}".format(e))
return
print("Issued tokens successfully")
print("Interest token id: {}, recorded in {}".format(
interest_id, interest_txid))
print("Par token id: {}, recorded in {}".format(par_id, par_txid))
print("--------------------------------------------")
# creating escrow account
print("--------------------------------------------")
print("Creating escrow account......")
try:
escrow_result, escrow_id = create_escrow(add, proj_name, interest_id,
par_id, payment_id, closure,
start_round, end_round, par,
coupon, total_payments,
period, span, hold_up, cl)
except Exception as e:
print("Escrow account creation failed :{}".format(e))
return
print("Created escrow account successfully")
print("Escrow account result :{}".format(escrow_result))
print("Escrow account public address: {}".format(escrow_id))
print("--------------------------------------------")
# activating escrow account
print("--------------------------------------------")
print("Activating escrow account......")
try:
txn = payment_transaction(passphrase, 1000000, escrow_id, cl)
except Exception as e:
print("Activation failed :{}".format(e))
return
print("Activated successfully")
print(txn)
print("--------------------------------------------")
# opt-in the escrow account for interest token
print("--------------------------------------------")
print("Opt-in for interest token......")
try:
program_str = escrow_result.encode()
program = base64.decodebytes(program_str)
arg1 = (0).to_bytes(8, 'big')
lsig = LogicSig(program, [arg1])
sp = cl.suggested_params()
atn = AssetTransferTxn(lsig.address(), sp, lsig.address(), 0,
interest_id)
lstx = LogicSigTransaction(atn, lsig)
txid = cl.send_transaction(lstx)
msg = wait_for_confirmation(cl, txid, 5)
except Exception as e:
print("Opt-in interest token failed :{}".format(e))
return
print("Opt-in interest token success!")
print(msg)
print("--------------------------------------------")
# opt-in the escrow account for par token
print("--------------------------------------------")
print("Opt-in for par token......")
try:
program_str = escrow_result.encode()
program = base64.decodebytes(program_str)
arg1 = (1).to_bytes(8, 'big')
lsig = LogicSig(program, [arg1])
sp = cl.suggested_params()
atn = AssetTransferTxn(lsig.address(), sp, lsig.address(), 0, par_id)
lstx = LogicSigTransaction(atn, lsig)
txid = cl.send_transaction(lstx)
msg = wait_for_confirmation(cl, txid, 5)
except Exception as e:
print("Opt-in par token failed :{}".format(e))
return
print("Opt-in par token success!")
print(msg)
print("--------------------------------------------")
# opt-in the escrow account for payment token
print("--------------------------------------------")
print("Opt-in for payment token......")
try:
program_str = escrow_result.encode()
program = base64.decodebytes(program_str)
arg1 = (6).to_bytes(8, 'big')
lsig = LogicSig(program, [arg1])
sp = cl.suggested_params()
atn = AssetTransferTxn(lsig.address(), sp, lsig.address(), 0,
payment_id)
lstx = LogicSigTransaction(atn, lsig)
txid = cl.send_transaction(lstx)
msg = wait_for_confirmation(cl, txid, 5)
except Exception as e:
print("Opt-in payment token failed :{}".format(e))
return
print("Opt-in payment token success!")
print(msg)
print("--------------------------------------------")
# transferring the interest tokens to escrow account
print("--------------------------------------------")
print("Transfer interest token to escrow account......")
try:
atn = asset_transaction(passphrase, vol * total_payments, escrow_id,
interest_id, cl)
except Exception as e:
print("Transferred interest token failed :{}".format(e))
return
print("Transferred interest token successfully")
print(atn)
print("--------------------------------------------")
# transferring the par tokens to escrow account
print("--------------------------------------------")
print("Transfer par token to escrow account......")
try:
atn = asset_transaction(passphrase, vol, escrow_id, par_id, cl)
except Exception as e:
print("Transferred par token failed :{}".format(e))
return
print("Transferred par token successfully")
print(atn)
print("--------------------------------------------")
print("Setup-complete!")
return interest_id, par_id, escrow_result, escrow_id
accountA = info[2].split(': ')[1]
accountA = { 'pk': mnemonic.to_public_key(accountA), 'sk': mnemonic.to_private_key(accountA) }
other = '4O6BRAPVLX5ID23AZWV33TICD35TI6JWOHXVLPGO4VRJATO6MZZQRKC7RI'
asset_id = 14035004
params = algod_client.suggested_params()
params.fee = 1000
params.flat_fee = True
txn1 = PaymentTxn(accountA['pk'], params, other, 42 * 1000000)
txn2 = AssetTransferTxn(other, params, accountA['pk'], 1, asset_id)
print(f'First transaction ID: {txn1.get_txid()}')
print(f'Second transaction ID: {txn2.get_txid()}')
gid = calculate_group_id([txn1, txn2])
txn1.group = txn2.group = gid
print(f'Group ID of the two transactions: {gid}')
stxn1 = txn1.sign(accountA['sk'])
with open('../step5.lsig', 'rb') as fd:
lsig = encoding.future_msgpack_decode(base64.b64encode(fd.read()))
stxn2 = LogicSigTransaction(txn2, lsig)
print(f'First signed transaction ID: {stxn1.get_txid()}')
print(f'Second signed transaction ID: {stxn2.get_txid()}')
txid = algod_client.send_transactions([stxn1, stxn2])
print(f'Send transaction with txID: {txid}')
confirmed_txn = wait_for_confirmation(algod_client, txid)
print(json.dumps(confirmed_txn, indent=4))
with handle(client=kmd_client, wallet_id=wallet_id,
wallet_password="") as h:
signed_txn = h.client.sign_transaction(h.token, h.wallet_password, txn)
txn_id = algod_client.send_transaction(signed_txn)
wait_for_confirmation(algod_client, txn_id)
print()
print_status(title="balances after contract funded")
# create lsig and close contract
lsig = LogicSigAccount(
program=contract_bytes,
args=[bytes(passphrase, encoding="utf8")],
)
txn = PaymentTxn(amt=0,
sender=contract,
sp=sp(),
receiver=bob,
close_remainder_to=bob)
lsig_txn = LogicSigTransaction(transaction=txn, lsig=lsig)
txn_id = algod_client.send_transaction(lsig_txn)
wait_for_confirmation(algod_client, txn_id)
print()
print_status(title="balances after contract is closed")