def opt_in(algodclient, receiver, receiver_sk, asset_id): params = algod_client.suggested_params() # comment these two lines if you want to use suggested params params.fee = 1000 params.flat_fee = True account_info = algod_client.account_info(receiver) 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=receiver, sp=params, receiver=receiver, amt=0, index=asset_id) stxn = txn.sign(receiver_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, receiver, asset_id)
def optin(params_dict): algod_client, params = algod_connect(params_dict) print( '\n=====================================OPT-IN ASSET=====================================' ) print('asset_id:', params_dict['asset']) account_info = algod_client.account_info(params_dict['account']) holding = None idx = 0 # Verify if the account have an asset with the id: params_dict['asset'] for my_account_info in account_info['assets']: scrutinized_asset = account_info['assets'][idx] idx += 1 if scrutinized_asset['asset-id'] == params_dict['asset']: holding = True break # If the account is not holding the asset, optin the asset for this account if not holding: txn = AssetTransferTxn(sender=params_dict['account'], sp=params, receiver=params_dict['account'], amt=0, index=params_dict['asset']) private_key = mnemonic.to_private_key(params_dict['mnemonic']) stxn = txn.sign(private_key) txid = algod_client.send_transaction(stxn) print('Transaction ID: ', txid) wait_for_confirmation(algod_client, txid) print_asset_holding(algod_client, params_dict['account'], params_dict['asset'])
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 asset_transfer(sender, private_key, receiver, amount, index): """Function for asset transfer""" params = ALGODCLIENT.suggested_params() txn = AssetTransferTxn(sender, params, receiver, amount, index) signed_tx = txn.sign(private_key) ALGODCLIENT.send_transaction(signed_tx) return True
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 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 transfer_nft_to_user(asset_id, address): mypic_private_key = get_private_key_from_mnemonic(word_mnemonic) params = algod_client.suggested_params() params.fee = 1000 params.flat_fee = True txn = AssetTransferTxn(sender=ADDRESS_ALGO_OURSELF, sp=params, receiver=address, amt=1, index=asset_id) stxn = txn.sign(mypic_private_key) tx_id = algod_client.send_transaction(stxn) return tx_id
def resolve(self, bankrIdentifier, skey): # Check if Leafbank holding Bankers' asset prior to opt-in assetId = getAssetIdv2(transaction_executor) account_info_pk = algo_client.account_info(bankrIdentifier) holding = None idx = 0 print(account_info_pk) for assetinfo in account_info_pk['assets']: scrutinized_asset = assetinfo[idx] idx = idx + 1 if assetId == scrutinized_asset['asset-id']: holding = True msg = "This address has opted in for ISA, ID {}".format(assetId) logging.info("Message: {}".format(msg)) logging.captureWarnings(True) break if not holding: # Use the AssetTransferTxn class to transfer assets and opt-in txn = AssetTransferTxn( sender=bankrIdentifier, sp=params, receiver=bankrIdentifier, amt=0, index=assetId ) # Sign the transaction # Firstly, convert mnemonics to private key--. sk = mnemonic.to_private_key(seed) sendTrxn = txn.sign(sk) # Submit transaction to the network txid = algo_client.send_transaction(sendTrxn, headers={'content-type': 'application/x-binary'}) message = "Transaction was signed with: {}.".format(txid) wait = wait_for_confirmation(txid) time.sleep(2) hasOptedIn = bool(wait is not None) if hasOptedIn: self.hasResolve = True print(assetId) # Now check the asset holding for that account. # This should now show a holding with 0 balance. assetHolding = print_asset_holding(bankrIdentifier, assetId) logging.info("...##Asset Transfer... \nLeaf Bank address: {}.\nMessage: {}\nHas Opted in: {}\nOperation: {}\nHoldings: {}\n".format( bankrIdentifier, message, hasOptedIn, Bankers.resolve.__name__, assetHolding )) return hasOptedIn
def transfer_nft_to_user(algod_client, asset_id, mypic_public_key, mypic_private_key, user_public_key): params = algod_client.suggested_params() # comment these two lines if you want to use suggested params params.fee = 1000 params.flat_fee = True txn = AssetTransferTxn( sender=mypic_public_key, sp=params, receiver=user_public_key, amt=1, index=asset_id) stxn = txn.sign(mypic_private_key) txid = algod_client.send_transaction(stxn) return txid
def optin(update, context, recipient, sk): """ Checks if user already optin for an ASA, subscribes users if condition is false. :param update: :param context: :param recipient: public key of subscriber :param sk: Signature of subscriber :return: true if success. """ algod_client = connect(update, context) params = algod_client.suggested_params() # Check if recipient holding DMT2 asset prior to opt-in print(algod_client.account_info(recipient)) account_info_pk = algod_client.account_info(recipient) print(account_info_pk) holding = None # idx = 0 for assetinfo in account_info_pk['assets']: scrutinized_asset = assetinfo['asset-id'] # idx = idx + 1 if asset_id == scrutinized_asset: holding = True msg = "This address has opted in for DMT2, ID {}".format(asset_id) logging.info("Message: {}".format(msg)) logging.captureWarnings(True) break if not holding: # Use the AssetTransferTxn class to transfer assets and opt-in txn = AssetTransferTxn(sender=recipient, sp=params, receiver=recipient, amt=0, index=asset_id) # Sign the transaction # Firstly, convert mnemonics to private key. # For tutorial purpose, we will focus on using private key # sk = mnemonic.to_private_key(seed) sendTrxn = txn.sign(sk) # Submit transaction to the network txid = algod_client.send_transaction(sendTrxn) message = "Transaction was signed with: {}.".format(txid) wait = wait_for_confirmation(update, context, algod_client, txid) time.sleep(2) hasOptedIn = bool(wait is not None) if hasOptedIn: update.message.reply_text(f"Opt in success\n{message}") return hasOptedIn
def singleTransfer(pk, receiver, asset_id): txn = AssetTransferTxn(sender=pk, sp=params, receiver=receiver, amt=1, index=asset_id) return txn
def optinDocument(algod_client, pk, asset_id): account_info = algod_client.account_info(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 print(holding) break #print(holding) if not holding: # Use the AssetTransferTxn class to transfer assets and opt-in try: txn = AssetTransferTxn(sender=pk, sp=params, receiver=pk, amt=0, index=asset_id) print("yes") except: print("aaa") return txn return None
def opt_in_asset(asset_id): mn = 'tattoo market oven bench betray double tuna box sand lottery champion spend melt virus motor label bacon wine rescue custom cannon pen merry absorb endorse' public_key = get_public_key_from_mnemonic(mn) print(public_key) private_key = get_private_key_from_mnemonic(mn) params = algod_client.suggested_params() params.fee = 1000 params.flat_fee = True txn = AssetTransferTxn(sender=ADDRESS_ALGO_OURSELF, sp=params, receiver=public_key, amt=0, index=asset_id) stxn = txn.sign(private_key) tx_id = algod_client.send_transaction(stxn) wait_for_confirmation(tx_id) print("Asset ", asset_id, " opted in for ACCOUNT ", public_key)
def transfer(update, context, receiver, amount): """ Transfer a custom asset from default account A to account B (Any) :param update: Default telegram argument :param context: Same as update :param sender: Sender of this transaction :param receiver: The beneficiary of the asset in transit :param amount: Amount in custom asset other than ALGO :return: """ global saleable params = algod_client.suggested_params() params.fee = 1000 params.flat_fee = True print(auth) try: assert saleable >= amount, response_end( update, context, "Sales for the period is exhausted") txn = AssetTransferTxn( sender=to, # asset_manage_authorized, sp=params, receiver=receiver, amt=int(amount), index=asset_id ) # Sign the transaction sk = mnemonic.to_private_key(auth) signedTrxn = txn.sign(sk) # Submit transaction to the network tx_id = algod_client.send_transaction(signedTrxn) message = "Successful! \nTransaction hash: {}.".format(tx_id) wait_for_confirmation(update, context, algod_client, tx_id) logging.info( "...##Asset Transfer... \nReceiving account: {}.\nMessage: {}\nOperation: {}\nTxn Hash: {}" .format(receiver, message, transfer.__name__, tx_id)) update.message.reply_text(message, reply_markup=markup2) saleable -= amount # Erase the key soon as you're done with it. context.user_data.clear() except Exception as err: print(err) return markup2
def transfer_assets(sender, receiver, amount, asset=settings.ALGO_ASSET, close_assets_to=None): _params = params() atxn = AssetTransferTxn( sender.address, _params, receiver.address, int(amount * 1000000), asset, close_assets_to=close_assets_to.address if close_assets_to else None) if sender.type == accounts.models.Account.SMART_CONTRACT_ACCOUNT: signed_atxn = sender.smart_contract.sign(atxn) else: signed_atxn = atxn.sign(sender.private_key) fee = (_params.min_fee if _params.fee == 0 else _params.fee) / 1000000 return CLIENT.send_transaction(signed_atxn), fee
def opt_in_asset(algod_client, sender, asset_id): """ @params{algod_client} - AlgodClient instance created by calling algod.AlgodClient @params{sender} - a dictionary containing the public/private key of the holder - { 'public_key': string, 'private_key': string } @params{asset_id} - int asset id Opts in an asset with the asset id. @returns { 'status': boolean, 'txid': string 'info': json string containing the transaction information if status is True else a string of error message } """ params = algod_client.suggested_params() params.flat_fee = True params.fee = 1000 account_info = algod_client.account_info(sender['public_key']) hold = False for scrutinized_asset in account_info['assets']: if scrutinized_asset['asset-id'] == asset_id: hold = True break if not hold: unsigned_txn = AssetTransferTxn(sender=sender['public_key'], sp=params, receiver=sender['public_key'], amt=0, index=asset_id) signed_txn = unsigned_txn.sign(sender['private_key']) txid = algod_client.send_transaction(signed_txn) print('Pending transaction with id: {}'.format(txid)) try: confirmed_txn = wait_for_confirmation(algod_client, txid) except Exception as err: print(err) return { 'status': False, 'txid': txid, 'info': getattr(err, 'message', str(err)) } return { 'status': True, 'txid': txid, 'info': json.dumps(confirmed_txn) } return { 'status': True, 'txid': '', 'info': '' }
def opt_in_asset(algod_client, asset_id, public_key, private_key): params = algod_client.suggested_params() # comment these two lines if you want to use suggested params params.fee = 1000 params.flat_fee = True # Use the AssetTransferTxn class to transfer assets and opt-in txn = AssetTransferTxn( sender=public_key, sp=params, receiver=public_key, amt=0, index=asset_id) stxn = txn.sign(private_key) txid = algod_client.send_transaction(stxn) # 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, public_key, asset_id) print("Asset ",asset_id," opted in for ACCOUNT ",public_key,"\n")
def transfer_asset_holding(algodclient, account, account_sk, 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 txn = AssetTransferTxn( sender=account, #accounts[1]['pk'], sp=params, receiver=receiver, #accounts[3]["pk"], amt=1, 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) # The balance should now be 10. print_asset_holding(algod_client, receiver, asset_id) return stxn
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 transferAssets(algod_client, alice, bob, asset_id): print("--------------------------------------------") print("Transfering Alice's token to Bob......") params = algod_client.suggested_params() # comment these two lines if you want to use suggested params # params.fee = 1000 # params.flat_fee = True txn = AssetTransferTxn(sender=alice['pk'], sp=params, receiver=bob["pk"], amt=100, index=asset_id) stxn = txn.sign(alice['sk']) txid = algod_client.send_transaction(stxn) print(txid) # Wait for the transaction to be confirmed confirmed_txn = wait_for_confirmation(algod_client, txid, 4) print("TXID: ", txid) print("Result confirmed in round: {}".format( confirmed_txn['confirmed-round'])) # The balance should now be 10. print_asset_holding(algod_client, bob['pk'], asset_id)
def transfer_asset(algod_client, sender, receiver, asset_id, sign=True): """ @params{algod_client} - AlgodClient instance created by calling algod.AlgodClient @params{sender} - a dictionary containing the public/private key of the holder - { 'public_key': string, 'private_key': string } @params{receiver} - a string of the public key (account address) of the receiver @params{asset_id} - int asset id @params{sign} OPTIONAL - boolean whether or not to sign and send the transaction Transfer 1 asset (NFT) from sender to receiver. @returns { 'status': boolean, 'txid': string 'info': json string containing the transaction information if status is True else a string of error message } if sign else { 'sender': a dictionary containing the public/private key of the holder, 'txn': unsigned transaction } """ params = algod_client.suggested_params() params.flat_fee = True params.fee = 1000 unsigned_txn = AssetTransferTxn(sender=sender['public_key'], sp=params, receiver=receiver, amt=1, index=asset_id) if not sign: return { 'sender': sender, 'txn': unsigned_txn } signed_txn = unsigned_txn.sign(sender['private_key']) txid = algod_client.send_transaction(signed_txn) print('Pending transaction with id: {}'.format(txid)) try: confirmed_txn = wait_for_confirmation(algod_client, txid) except Exception as err: print(err) return { 'status': False, 'txid': txid, 'info': getattr(err, 'message', str(err)) } return { 'status': True, 'txid': txid, 'info': json.dumps(confirmed_txn) }
def optIn(algod_client, bob, asset_id): print("--------------------------------------------") print("Opt-in for Alice's token......") # Check if asset_id is in Bob'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 = 1000 # params.flat_fee = True account_info = algod_client.account_info(bob['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=bob['pk'], sp=params, receiver=bob["pk"], amt=0, index=asset_id) stxn = txn.sign(bob['sk']) txid = algod_client.send_transaction(stxn) print(txid) # Wait for the transaction to be confirmed confirmed_txn = wait_for_confirmation(algod_client, txid, 4) print("TXID: ", txid) print("Result confirmed in round: {}".format( confirmed_txn['confirmed-round'])) # Now check the asset holding for that account. # This should now show a holding with a balance of 0. print_asset_holding(algod_client, bob['pk'], asset_id)
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 transfer_asset_holding_return_txn(algodclient, account, account_sk, 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 txn = AssetTransferTxn( sender=account, #accounts[1]['pk'], sp=params, receiver=receiver, #accounts[3]["pk"], amt=1, index=asset_id) return txn
def transfer(asset_id, sender_account_id, receiver_account_id): print( '\n=====================================ASSET TRANSFER=====================================' ) print('asset_id:', asset_id) # Transfert une valeur de 10 actifs du compte sender_account_id au compte receiver_account_id txn = AssetTransferTxn(sender=accounts_dict[sender_account_id]['pk'], sp=params, receiver=accounts_dict[receiver_account_id]['pk'], amt=10, index=asset_id) stxn = txn.sign(accounts_dict[sender_account_id]['sk']) txid = algod_client.send_transaction(stxn) print('Transaction ID: ', txid) wait_for_confirmation(algod_client, txid) # txid_list.append(txid) # Attend la confirmation le la liste de toutes les transactions précédentes # wait_for_confirmation_list(algod_client, txid_list) print_asset_holding(algod_client, accounts_dict[receiver_account_id]['pk'], asset_id)
def revoke(asset_id, sender_account_id, receiver_account_id, target_account_id): print( '\n=====================================REVOKE ASSET=====================================' ) print('asset_id:', asset_id) print('\n--- Before revoke') print('\nAccount', target_account_id) print_asset_holding(algod_client, accounts_dict[target_account_id]['pk'], asset_id) print('\nAccount', receiver_account_id) print_asset_holding(algod_client, accounts_dict[receiver_account_id]['pk'], asset_id) txn = AssetTransferTxn( sender=accounts_dict[sender_account_id]['pk'], sp=params, receiver=accounts_dict[receiver_account_id]['pk'], index=asset_id, amt=10, revocation_target=accounts_dict[target_account_id]['pk']) stxn = txn.sign(accounts_dict[sender_account_id]['sk']) txid = algod_client.send_transaction(stxn) print('Transaction ID:', txid) wait_for_confirmation(algod_client, txid) print('\n--- After revoke') print('\nAccount', target_account_id) print_asset_holding(algod_client, accounts_dict[target_account_id]['pk'], asset_id) print('\nAccount', receiver_account_id) print_asset_holding(algod_client, accounts_dict[receiver_account_id]['pk'], asset_id)
def prepare_transfer_assets(sender, receiver, amount, asset=settings.ALGO_ASSET, close_assets_to=None): _params = params() atxn = AssetTransferTxn( sender.address, _params, receiver.address, int(amount * 1000000), asset, close_assets_to=close_assets_to.address if close_assets_to else None) fee = (_params.min_fee if _params.fee == 0 else _params.fee) / 1000000 return atxn, fee
def optin(passphrase=None): """ Creates an unsigned opt-in transaction for the specified asset id and address. Uses current network params. """ params = client.suggested_params() txn = AssetTransferTxn(sender=receiver_address, sp=params, receiver=receiver_address, amt=0, index=asset_id) if passphrase: txinfo = sign_and_send(txn, passphrase, client) print("Opted in to asset ID: {}".format(asset_id)) else: write_to_file([txns], "optin.txn")
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