def set_home_domain(tokencode, home_domain, issuer_secret, network): try: issuer_keypair = stellar_sdk.Keypair.from_secret(issuer_secret) except Ed25519SecretSeedInvalidError: raise click.BadOptionUsage('--issuer_secret', 'Invalid issuer secret') issuer_address = issuer_keypair.public_key print( 'Setting the homedomain for {tokencode}:{issuer} to {homedomain} on the {network} network' .format(tokencode=tokencode, issuer=issuer_address, homedomain=home_domain, network=network)) horizon_server = stellar_sdk.Server( ) if network == 'test' else stellar_sdk.Server(PUBLIC_HORIZON_SERVER) base_fee = horizon_server.fetch_base_fee() issuer_account = horizon_server.load_account(issuer_address) transaction = stellar_sdk.transaction_builder.TransactionBuilder( issuer_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE if network == 'test' else stellar_sdk.Network.PUBLIC_NETWORK_PASSPHRASE, base_fee=base_fee).append_set_options_op( home_domain=home_domain).build() transaction.sign(issuer_keypair) response = horizon_server.submit_transaction(transaction) print(response)
def add_tft_trustline(source_kp, network): horizon_server = stellar_sdk.Server( ) if network == "test" else stellar_sdk.Server(PUBLIC_HORIZON_SERVER) base_fee = horizon_server.fetch_base_fee() source_account = horizon_server.load_account(source_kp.public_key) transaction = (stellar_sdk.transaction_builder.TransactionBuilder( source_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE if network == "test" else stellar_sdk.Network.PUBLIC_NETWORK_PASSPHRASE, base_fee=base_fee, ).append_change_trust_op("TFT", TFT_ISSUERS[network]).build()) transaction.sign(source_kp) horizon_server.submit_transaction(transaction)
def activate_account(address, activator_secret, network): activator_keypair = stellar_sdk.Keypair.from_secret(activator_secret) horizon_server = stellar_sdk.Server( ) if network == "test" else stellar_sdk.Server(PUBLIC_HORIZON_SERVER) base_fee = horizon_server.fetch_base_fee() activator_account = horizon_server.load_account( activator_keypair.public_key) transaction = (stellar_sdk.transaction_builder.TransactionBuilder( activator_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE if network == "test" else stellar_sdk.Network.PUBLIC_NETWORK_PASSPHRASE, base_fee=base_fee, ).append_create_account_op(address, "5").build()) transaction.sign(activator_keypair) horizon_server.submit_transaction(transaction)
def create_buy_order(buying_account_secret, amount, network): buying_asset_code = "TFT" buying_asset_issuer = ASSET_ISSUERS[network][buying_asset_code] selling_asset_code = "BTC" selling_asset_issuer = ASSET_ISSUERS[network][selling_asset_code] price = "0.0000019" buying_kp = Keypair.from_secret(buying_account_secret) horizon_server = stellar_sdk.Server(_HORIZON_NETWORKS[network]) source_account = horizon_server.load_account(buying_kp.public_key) transaction = ( stellar_sdk.TransactionBuilder( source_account=source_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE if network == "test" else stellar_sdk.Network.PUBLIC_NETWORK_PASSPHRASE, base_fee=0, ) .append_manage_buy_offer_op( selling_code=selling_asset_code, selling_issuer=selling_asset_issuer, buying_code=buying_asset_code, buying_issuer=buying_asset_issuer, amount=amount, price=price, ) .set_timeout(60) .build() ) transaction.sign(buying_kp) return transaction
def send_locked_funds(from_secret, destination, asset, amount): from_kp = stellar_sdk.Keypair.from_secret(from_secret) split_asset = asset.split(":", 1) asset_code = split_asset[0] asset_issuer = split_asset[1] print( "Sending {amount} {asset} from {from_address} to {destination}".format( amount=amount, asset=asset, from_address=from_kp.public_key, destination=destination)) print("Creating escrow account") escrow_kp = create_keypair() # minimum account balance as described at https://www.stellar.org/developers/guides/concepts/fees.html#minimum-account-balance horizon_server = stellar_sdk.Server() base_fee = horizon_server.fetch_base_fee() base_reserve = 0.5 minimum_account_balance = (2 + 1 + 3) * base_reserve # 1 trustline and 3 signers required_XLM = minimum_account_balance + base_fee * 0.0000001 * 3 activate_account(escrow_kp.public_key, from_kp, math.ceil(required_XLM)) add_trustline(escrow_kp.secret, asset_code, asset_issuer) preauth_tx = create_preauth_transaction(escrow_kp) preauth_tx_hash = preauth_tx.hash() set_account_signers(escrow_kp.public_key, destination, preauth_tx_hash, escrow_kp) print("Unlock Transaction:") print(preauth_tx.to_xdr()) send_asset_to_account(escrow_kp.public_key, asset, amount, from_kp.public_key, (from_secret, ))
def verify(activationaccount,network): horizon_server=stellar_sdk.Server("https://horizon-testnet.stellar.org" if network=="test" else "https://horizon.stellar.org") accounts_endpoint=horizon_server.operations().for_account(activationaccount) accounts_endpoint.limit(50) old_cursor = "old" new_cursor = "" number_of_vesting_accounts=0 vesting_accounts={} invalid_vesting_accounts=[] while new_cursor != old_cursor: old_cursor = new_cursor accounts_endpoint.cursor(new_cursor) response = accounts_endpoint.call() next_link = response["_links"]["next"]["href"] next_link_query = parse.urlsplit(next_link).query new_cursor = parse.parse_qs(next_link_query, keep_blank_values=True)["cursor"][0] for operation in response["_embedded"]["records"]: if operation["type"]!="create_account" or operation["source_account"]!=activationaccount: continue vesting_account_id=operation["account"] owner_account_id=get_owner_address(horizon_server,vesting_account_id) if not owner_account_id: invalid_vesting_accounts.append(vesting_account_id) continue print(f"Created vesting account {vesting_account_id} for owner {owner_account_id}") number_of_vesting_accounts+=1 accounts_for_owner=vesting_accounts.get(owner_account_id,[]) accounts_for_owner.append(vesting_account_id) vesting_accounts[owner_account_id]=accounts_for_owner print(f"{number_of_vesting_accounts} vesting accounts have been created for {len(vesting_accounts.keys())} owner accounts") if len(invalid_vesting_accounts)>0: print("Invalid vesting accounts:") print("\n".join(invalid_vesting_accounts))
def list_issued(): horizon_server = stellar_sdk.Server("https://horizon.stellar.org") tx_endpoint = horizon_server.transactions() tx_endpoint.limit = 50 for tokencode, issuer in ISSUERS.items(): tx_endpoint.for_account(issuer) tx_endpoint.include_failed(False) old_cursor = "old" new_cursor = "" while old_cursor != new_cursor: old_cursor = new_cursor tx_endpoint.cursor(new_cursor) response = tx_endpoint.call() next_link = response["_links"]["next"]["href"] next_link_query = parse.urlsplit(next_link).query new_cursor = parse.parse_qs(next_link_query)["cursor"][0] response_transactions = response["_embedded"]["records"] for response_transaction in response_transactions: if response_transaction["memo_type"] != "hash": continue memo = binascii.hexlify(base64.b64decode(response_transaction["memo"])).decode("utf-8") env = stellar_sdk.transaction_envelope.TransactionEnvelope.from_xdr( response_transaction["envelope_xdr"], stellar_sdk.Network.PUBLIC_NETWORK_PASSPHRASE ) paymentoperation = env.transaction.operations[0] print( f"{memo} {paymentoperation.amount} {tokencode} {paymentoperation.destination} {response_transaction['id']}" )
def activate_account(source_keypair, new_account_kp, fullassetcode): split_asset = fullassetcode.split(":", 1) asset_code = split_asset[0] asset_issuer = split_asset[1] new_account_address = new_account_kp.public_key horizon_server = stellar_sdk.Server() source_account = horizon_server.load_account(source_keypair.public_key) base_fee = horizon_server.fetch_base_fee() transaction = (stellar_sdk.TransactionBuilder( source_account=source_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE, base_fee=base_fee, ).append_begin_sponsoring_future_reserves_op( new_account_address).append_create_account_op( destination=new_account_address, starting_balance="0").append_change_trust_op( asset_issuer=asset_issuer, asset_code=asset_code, source=new_account_address). append_end_sponsoring_future_reserves_op( new_account_address).set_timeout(60).build()) transaction.sign(source_keypair) transaction.sign(new_account_kp) horizon_server.submit_transaction(transaction)
def createpayment_transaction(accountsecret, destination, feedestination, fee, asset, amount, network): network_passphrase = (stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE if network == "test" else stellar_sdk.Network.PUBLIC_NETWORK_PASSPHRASE) horizon_server = stellar_sdk.Server( "https://horizon-testnet.stellar.org" if network == "test" else "https://horizon.stellar.org") keypair = Keypair.from_secret(accountsecret) from_address = keypair.public_key split_asset = asset.split(":", 1) asset_code = split_asset[0] asset_issuer = split_asset[1] source_account = horizon_server.load_account(from_address) txe = (stellar_sdk.TransactionBuilder( source_account=source_account, network_passphrase=network_passphrase, base_fee=0).append_payment_op( destination, amount, asset_code=asset_code, asset_issuer=asset_issuer).append_payment_op( feedestination, fee, asset_code=asset_code, asset_issuer=asset_issuer).set_timeout(60 * 3).build()) txe.sign(keypair) print(txe.to_xdr())
def send_asset_to_account(destination, asset, amount, from_secret, funder_secret): split_asset = asset.split(':', 1) asset_code = split_asset[0] asset_issuer = split_asset[1] #Create keypairs from the secrets from_kp = stellar_sdk.Keypair.from_secret(from_secret) funder_kp = stellar_sdk.Keypair.from_secret(funder_secret) #load the funder account horizon_server = stellar_sdk.Server() funder_account = horizon_server.load_account(funder_kp.public_key) # Create the transaction transaction = TransactionBuilder(funder_account).append_payment_op( destination, amount, asset_code, asset_issuer, source=from_kp.public_key).build() transaction.sign(from_kp) transaction.sign(funder_kp) response = horizon_server.submit_transaction(transaction) print(response) print( 'Sent {amount} {asset} from {from_address} to {destination} funded by {funder_address}' .format(amount=amount, asset=asset, from_address=from_kp.public_key, destination=destination, funder_address=funder_kp.public_key))
def create_escrow_account(activationaccountsecret, owneraddress, cosignersfile, fullassetcode): splitassetcode = fullassetcode.split(":") asset_code = splitassetcode[0] asset_issuer = splitassetcode[1] activation_kp = Keypair.from_secret(activationaccountsecret) horizon_server = stellar_sdk.Server() activation_account = horizon_server.load_account(activation_kp.public_key) new_escrow_account = create_account() escrow_address = new_escrow_account["address"] vesting_kp = Keypair.from_secret(new_escrow_account["secret"]) txb = (TransactionBuilder( activation_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE ).append_create_account_op(escrow_address, starting_balance="7.6").append_change_trust_op( asset_code, asset_issuer, source=escrow_address)) tx = txb.build() tx.sign(activation_kp) tx.sign(vesting_kp) horizon_server.submit_transaction(tx) vesting_account = horizon_server.load_account(escrow_address) txb = (TransactionBuilder( vesting_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE). append_ed25519_public_key_signer(owneraddress, weight=5, source=escrow_address)) cosigners = json.load(cosignersfile) for cosigner in cosigners: txb.append_ed25519_public_key_signer(cosigner["address"], weight=1, source=escrow_address) txb.append_manage_data_op(DATA_ENTRY_KEY, "here comes the formula or reference", source=escrow_address) recovery_transaction = create_recovery_transaction( escrow_address, asset_code, asset_issuer, activation_kp.public_key) txb.append_pre_auth_tx_signer(recovery_transaction.hash(), weight=10, source=escrow_address) txb.append_set_options_op(master_weight=0, low_threshold=10, med_threshold=10, high_threshold=10, source=escrow_address) tx = txb.build() tx.sign(vesting_kp) horizon_server.submit_transaction(tx) print(f"Created escrow account {escrow_address}") print(f"Recovery transaction:\n{recovery_transaction.to_xdr()}")
def create_preauth_transaction(escrow_kp): unlock_time = int(time.time()) + 60 * 10 # 10 minutes from now horizon_server = stellar_sdk.Server() escrow_account = horizon_server.load_account(escrow_kp.public_key) escrow_account.increment_sequence_number() tx = (TransactionBuilder(escrow_account).append_set_options_op( master_weight=0, low_threshold=1, med_threshold=1, high_threshold=1).add_time_bounds(unlock_time, 0).build()) tx.sign(escrow_kp) return tx
def set_home_domain(tokencode, home_domain, issuer_secret, network): try: issuer_keypair = stellar_sdk.Keypair.from_secret(issuer_secret) except Ed25519SecretSeedInvalidError: raise click.BadOptionUsage("--issuer_secret", "Invalid issuer secret") issuer_address = issuer_keypair.public_key horizon_server = stellar_sdk.Server( ) if network == "test" else stellar_sdk.Server(PUBLIC_HORIZON_SERVER) base_fee = horizon_server.fetch_base_fee() issuer_account = horizon_server.load_account(issuer_address) transaction = (stellar_sdk.transaction_builder.TransactionBuilder( issuer_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE if network == "test" else stellar_sdk.Network.PUBLIC_NETWORK_PASSPHRASE, base_fee=base_fee, ).append_set_options_op(home_domain=home_domain).build()) transaction.sign(issuer_keypair) horizon_server.submit_transaction(transaction)
def sign_and_submit(transaction, secret): # Create keypairs from the secrets kp = stellar_sdk.Keypair.from_secret(secret) horizon_server = stellar_sdk.Server() txe = stellar_sdk.TransactionEnvelope.from_xdr( transaction, stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE) txe.sign(kp) response = horizon_server.submit_transaction(txe) print(response)
def add_trustline(secret_key, asset_code, asset_issuer): kp = stellar_sdk.Keypair.from_secret(secret_key) horizon_server = stellar_sdk.Server() account = horizon_server.load_account(kp.public_key) transaction = TransactionBuilder(account).append_change_trust_op(asset_code, asset_issuer).build() transaction.sign(kp) response = horizon_server.submit_transaction(transaction) print(response) print( "Added trustline to {asset_code}:{asset_issuer} for account {address}".format( asset_code=asset_code, asset_issuer=asset_issuer, address=kp.public_key ) )
def monitor(activationaccount, network): horizon_server = stellar_sdk.Server( "https://horizon-testnet.stellar.org" if network == "test" else "https://horizon.stellar.org" ) accounts_endpoint = horizon_server.accounts().account_id(activationaccount) response = accounts_endpoint.call() xlm_balance = [float(balance["balance"]) for balance in response["balances"] if balance["asset_type"] == "native"][ 0 ] sponsored_balance = response["num_sponsoring"] * 0.5 print(f"{activationaccount} holds {xlm_balance} XLM of which {xlm_balance-sponsored_balance} is free")
def send_asset_to_account(destination, asset, amount, source, signer): split_asset = asset.split(':', 1) asset_code = split_asset[0] asset_issuer = split_asset[1] horizon_server = stellar_sdk.Server() source_account = horizon_server.load_account(source) transaction = TransactionBuilder(source_account).append_payment_op( destination, amount, asset_code, asset_issuer).build() for sk in signer: kp = stellar_sdk.Keypair.from_secret(sk) transaction.sign(kp) response = horizon_server.submit_transaction(transaction) print(response) print('Sent {amount} {asset} to {destination}'.format( amount=amount, asset=asset, destination=destination))
def add_trustline( accountsecret: str, fullassetcode: str = "TFT:GA47YZA3PKFUZMPLQ3B5F2E3CJIB57TGGU7SPCQT2WAEYKN766PWIMB3"): splitassetcode = fullassetcode.split(":") # Create keypair from the secret kp = stellar_sdk.Keypair.from_secret(accountsecret) horizon_server = stellar_sdk.Server() account = horizon_server.load_account(kp.public_key) txbuilder = TransactionBuilder(account) txbuilder.append_change_trust_op(splitassetcode[0], splitassetcode[1]) txe = txbuilder.build() txe.sign(kp) horizon_server.submit_transaction(txe)
def transfer(accountsecret, fullassetcode, destination, amount): split_asset = fullassetcode.split(":", 1) asset_code = split_asset[0] asset_issuer = split_asset[1] # Create keypair from the secret kp = stellar_sdk.Keypair.from_secret(accountsecret) horizon_server = stellar_sdk.Server() account = horizon_server.load_account(kp.public_key) txbuilder = TransactionBuilder(account) txbuilder.append_payment_op(destination, amount, asset_code, asset_issuer) txe = txbuilder.build() txe.sign(kp) horizon_server.submit_transaction(txe)
def create_recovery_transaction( vesting_address, asset_code: str, asset_issuer: str, activation_account: str) -> stellar_sdk.TransactionEnvelope: horizon_server = stellar_sdk.Server() source_account = horizon_server.load_account(vesting_address) source_account.sequence += 1 txe = (TransactionBuilder( source_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE). append_change_trust_op( asset_code=asset_code, asset_issuer=asset_issuer, limit="0").append_manage_data_op( DATA_ENTRY_KEY, None).append_account_merge_op(activation_account).build()) return txe
def end_sponsorship(activatorsecret, sponsoredaccount): activator_kp = Keypair.from_secret(activatorsecret) horizon_server = stellar_sdk.Server() source_account = horizon_server.load_account(activator_kp.public_key) base_fee = horizon_server.fetch_base_fee() transaction = (stellar_sdk.TransactionBuilder( source_account=source_account, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE, base_fee=base_fee, ).append_revoke_account_sponsorship_op(sponsoredaccount).build()) transaction.sign(activator_kp) horizon_server.submit_transaction(transaction) print(f"Stopped sponsoring account {sponsoredaccount }")
def fee_bump(funding_account_secret, buy_transaction: stellar_sdk.TransactionEnvelope, network): funding_kp = Keypair.from_secret(funding_account_secret) horizon_server = stellar_sdk.Server(_HORIZON_NETWORKS[network]) base_fee = horizon_server.fetch_base_fee() fb_txe = stellar_sdk.TransactionBuilder.build_fee_bump_transaction( fee_source=funding_kp.public_key, base_fee=base_fee, inner_transaction_envelope=buy_transaction, network_passphrase=stellar_sdk.Network.TESTNET_NETWORK_PASSPHRASE if network == "test" else stellar_sdk.Network.PUBLIC_NETWORK_PASSPHRASE, ) fb_txe.sign(funding_kp) response = horizon_server.submit_transaction(fb_txe) print(f"Submittted fee bumped transaction {response['hash']}")
def find_escrow_accounts(receiver, asset): stellar_asset = asset_from_full_string(asset) horizon_server = stellar_sdk.Server() accounts_endpoint = horizon_server.accounts() accounts_endpoint.signer(receiver) old_cursor = "old" new_cursor = "" while new_cursor != old_cursor: old_cursor = new_cursor accounts_endpoint.cursor(new_cursor) response = accounts_endpoint.call() next_link = response["_links"]["next"]["href"] next_link_query = parse.urlsplit(next_link).query new_cursor = parse.parse_qs(next_link_query)["cursor"][0] accounts = response["_embedded"]["records"] for account in accounts: account_id = account["account_id"] if account_id == receiver: continue # Do not take the receiver's account balances = account["balances"] asset_balances = [ balance for balance in balances if balance["asset_type"] == stellar_asset.guess_asset_type() and balance["asset_code"] == stellar_asset.code and balance["asset_issuer"] == stellar_asset.issuer ] asset_balance = decimal.Decimal(0) for balance in asset_balances: asset_balance += decimal.Decimal(balance["balance"]) if asset_balance == decimal.Decimal(): continue # 0 so skip all_signers = account["signers"] preauth_signers = [ signer["key"] for signer in all_signers if signer["type"] == "preauth_tx" ] # TODO check the tresholds and signers # TODO if we can merge, the amount is unlocked ( if len(preauth_signers))==0 print( "Account {account} with {asset_balance} {asset_code} has unlocktransaction hashes {unlockhashes}" .format( account=account_id, asset_balance=asset_balance, asset_code=stellar_asset.code, unlockhashes=preauth_signers, ))
def get_escrowaccount_unlocktime(address): horizon_server = stellar_sdk.Server("https://horizon.stellar.org") accounts_endpoint = horizon_server.accounts() accounts_endpoint.account_id(address) response = accounts_endpoint.call() preauth_signer = [signer["key"] for signer in response["signers"] if signer["type"] == "preauth_tx"][0] resp = requests.post( "https://tokenservices.threefold.io/threefoldfoundation/unlock_service/get_unlockhash_transaction", json={"args": {"unlockhash": preauth_signer}}, ) resp.raise_for_status() txe = stellar_sdk.TransactionEnvelope.from_xdr( resp.json()["transaction_xdr"], stellar_sdk.Network.PUBLIC_NETWORK_PASSPHRASE ) tx = txe.transaction if tx.time_bounds is not None: return tx.time_bounds.min_time
def export(network): issuances = [] horizon_server = stellar_sdk.Server(_HORIZON_NETWORKS[network]) for token in ("TFT", "TFTA"): issuer = _ASSET_ISUERS[network][token] endpoint = horizon_server.operations().for_account(issuer) endpoint.limit(100) old_cursor = "old" new_cursor = "" while new_cursor != old_cursor: old_cursor = new_cursor endpoint.cursor(new_cursor) response = endpoint.call() next_link = response["_links"]["next"]["href"] next_link_query = parse.urlsplit(next_link).query new_cursor = parse.parse_qs(next_link_query, keep_blank_values=True)["cursor"][0] for operation in response["_embedded"]["records"]: if ("asset_code" not in operation) or operation["asset_code"] != token: continue amount = float(operation["amount"]) if operation["to"] == issuer: amount *= -1 issued_at = dateutil.parser.parse(operation["created_at"]) issuances.append({"token": token, "amount": amount, "issued_at": issued_at}) def sort_key(a): return a["issued_at"] issuances.sort(key=sort_key) total_tft = 0.0 total_tfta = 0.0 for issuance in issuances: amount_tft = 0 amount_tfta = 0 if issuance["token"] == "TFT": amount_tft = issuance["amount"] total_tft += amount_tft else: amount_tfta = issuance["amount"] total_tfta += amount_tfta print( f"{issuance['issued_at']:%Y/%m/%d},{amount_tft},{amount_tfta},{total_tft},{total_tfta},{total_tft+total_tfta}" )
def set_account_signers(address, public_key_signer, preauth_tx_hash, signer_kp): horizon_server = stellar_sdk.Server() account = horizon_server.load_account(address) tx = (TransactionBuilder(account).append_pre_auth_tx_signer( preauth_tx_hash, 1).append_ed25519_public_key_signer( public_key_signer, 1).append_set_options_op(master_weight=1, low_threshold=2, med_threshold=2, high_threshold=2).build()) tx.sign(signer_kp) response = horizon_server.submit_transaction(tx) print(response) print( "Set the signers of {address} to {pk_signer} and {preauth_hash_signer}" .format(address=address, pk_signer=public_key_signer, preauth_hash_signer=preauth_tx_hash))
def validate(transaction_hash, network): horizon_server = stellar_sdk.Server(_HORIZON_NETWORKS[network]) tokendestructions = [] issuer = _ASSET_ISUERS[network]["TFTA"] try: response = horizon_server.payments().for_transaction(transaction_hash).limit(100).call() payments = response["_embedded"]["records"] for payment in payments: if payment["to"] != _ASSET_ISUERS[network]["TFTA"]: continue if payment["type"] != "payment": continue if payment["asset_type"] == "native": continue if payment["asset_code"] != "TFTA" or payment["asset_issuer"] != issuer: continue amount = payment["amount"] sender = payment["from"] tokendestructions.append(TokenDestruction("TFTA", issuer, amount, sender)) except stellar_sdk.exceptions.BadRequestError as e: if not "invalid_field" in e.extras: raise e return tokendestructions
def update_foundation_wallets_data(): redis = j.clients.redis.get("redis_instance") foundation_wallets = _get_foundation_wallets() horizon_server = stellar_sdk.Server("https://horizon.stellar.org") for category in foundation_wallets: for foundation_wallet in category["wallets"]: endpoint = horizon_server.accounts().account_id( foundation_wallet["address"]) account_data = endpoint.call() tftbalances = [ balance["balance"] for balance in account_data["balances"] if balance.get("asset_code") == "TFT" and balance.get("asset_issuer") == TFT_ISSUER ] foundation_wallet["TFT"] = tftbalances[0] if tftbalances else "0.0" foundation_wallet["signers"] = [ signer["key"] for signer in account_data["signers"] ] required_signatures = account_data["thresholds"]["med_threshold"] foundation_wallet[ "required_signatures"] = required_signatures if required_signatures != 0 else 1 res = j.data.serializers.json.dumps(foundation_wallets) redis.set(f"foundationaccounts-detailed", res) return res
def _get_horizon_server(network: str): server_url = _HORIZON_NETWORKS[network] return stellar_sdk.Server(horizon_url=server_url)
def _get_horizon_server(self): return stellar_sdk.Server(horizon_url=_HORIZON_NETWORKS[self._get_network()])