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