def closs_asset(self,program,asset_id,receiver):
first, last, gen, gh, min_fee = self.get_params()
lsig = LogicSig(program)
txn = AssetTransferTxn(
sender = lsig.address(),
fee=min_fee,
first=first,
last=last,
gh=gh,
receiver=None,
amt=0,
index=asset_id,
flat_fee=True,
closs_assets_to=receiver)
return txn
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 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 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 compile(self):
def _logic(secret, facililator_address, investor_address, deadline):
is_beneficiary_reward = And(
Ed25519Verify(Bytes(secret), Arg(0), Addr(facililator_address)), #Check secret
# Txn.first_valid() < Int(deadline), # Reward could be claimed only if deadline hasn't been met
Txn.type_enum() == TxnType.AssetTransfer, # Rewards only in asset (USDC)
Txn.xfer_asset() == Int(settings.ALGO_ASSET), # USDC
Txn.asset_close_to() == Global.zero_address(),
Txn.rekey_to() == Global.zero_address())
is_investor_transfer_back = And(
Txn.rekey_to() == Global.zero_address(),
Txn.first_valid() >= Int(deadline), # Investor can transfer back after deadline
Or(And(Txn.close_remainder_to() == Addr(investor_address),
Txn.receiver() == Addr(investor_address)),
And(Txn.asset_close_to() == Addr(investor_address),
Txn.asset_receiver() == Addr(investor_address))))
is_opt_in = And(Txn.type_enum() == TxnType.AssetTransfer,
Txn.xfer_asset() == Int(settings.ALGO_ASSET),
Txn.asset_amount() == Int(0),
Txn.asset_close_to() == Global.zero_address(),
Txn.rekey_to() == Global.zero_address(),
Txn.close_remainder_to() == Global.zero_address())
return Or(is_beneficiary_reward, is_investor_transfer_back, is_opt_in)
source_teal = compileTeal(
_logic(
self.secret,
self.project.owner.account.address,
self.investment.investor.account.address,
utils.date_time_to_blocks(self.investment.end)),
Mode.Signature)
compile_reply = utils.compile(source_teal)
self.program = compile_reply['result']
self.save()
return LogicSig(base64.decodebytes(self.program.encode())).address()
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 an algod client
algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
algod_address = "http://localhost:4001"
# algod_token = "algod-token" < PLACEHOLDER >
# algod_address = "algod-address" < PLACEHOLDER >
# receiver = "receiver-address" < PLACEHOLDER >
algod_client = algod.AlgodClient(algod_token, algod_address)
# create logic sig
# program = b"hex-encoded-program"
# b"\x01\x20\x01\x00\x22 is `int 0`
# see more info here: https://developer.algorand.org/docs/features/asc1/sdks/#accessing-teal-program-from-sdks
program = b"\x01\x20\x01\x00\x22"
# program = b"hex-encoded-program"
lsig = LogicSig(program)
# string parameter
# arg_str = "my string"
# arg1 = arg_str.encode()
# lsig = transaction.LogicSig(program, args=[arg1])
# integer parameter
# arg1 = (123).to_bytes(8, 'big')
# lsig = transaction.LogicSig(program, args=[arg1])
sender = lsig.address()
#Recover the account that is wanting to delegate signature
passphrase = "canal enact luggage spring similar zoo couple stomach shoe laptop middle wonder eager monitor weather number heavy skirt siren purity spell maze warfare ability ten"
# passphrase = "25-word-mnemonic<PLACEHOLDER>"
sk = mnemonic.to_private_key(passphrase)
addr = account.address_from_private_key(sk)
programstr = response['result']
t = programstr.encode()
program = base64.decodebytes(t)
print(program)
# string parameter
# arg_str = "<my string>"
# arg1 = arg_str.encode()
# lsig = transaction.LogicSig(program, args=[arg1])
# see more info here: https://developer.algorand.org/docs/features/asc1/sdks/#accessing-teal-program-from-sdks
# 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)
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
# Create arg to pass
# string parameter
# arg_str = "<my string>"
# arg1 = arg_str.encode()
# lsig = transaction.LogicSig(program, args=[arg1])
# integer parameter
# arg1 = (123).to_bytes(8, 'big')
# lsig = transaction.LogicSig(program, args=[arg1])
# see more info here: https://developer.algorand.org/docs/features/asc1/sdks/#accessing-teal-program-from-sdks
# if TEAL program requires an arg,
# if not, omit args param on LogicSig
# lsig = LogicSig(program)
arg1 = (123).to_bytes(8, 'big')
lsig = LogicSig(program, args=[arg1])
# Recover the account that is wanting to delegate signature
passphrase = "<25-word-mnemonic>"
sk = mnemonic.to_private_key(passphrase)
addr = account.address_from_private_key(sk)
print("Address of Sender/Delegator: " + addr)
# Sign the logic signature with an account sk
lsig.sign(sk)
# 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 an algod client
algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
algod_address = "http://localhost:4001"
# algod_token = "algod-token" < PLACEHOLDER >
# algod_address = "algod-address" < PLACEHOLDER >
# receiver = "receiver-address" < PLACEHOLDER >
algod_client = algod.AlgodClient(algod_token, algod_address)
# create logic sig
# program = b"hex-encoded-program"
# b"\x01\x20\x01\x00\x22 is `int 0`
# see more info here: https://developer.algorand.org/docs/features/asc1/sdks/#accessing-teal-program-from-sdks
program = b"\x01\x20\x01\x00\x22"
lsig = LogicSig(program)
# string parameter
# arg_str = "my string"
# arg1 = arg_str.encode()
# lsig = transaction.LogicSig(program, args=[arg1])
# integer parameter
# arg1 = (123).to_bytes(8, 'big')
# lsig = transaction.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