popov/gogo2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

token info name and cache

Browse Source
This commit is contained in:
Dobromir Popov 2024-10-08 17:40:33 +03:00
parent 6f262078fc
commit 7bb73ae3b0
2 changed files with 114 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

172
crypto/sol/app.py
View File

@ -153,7 +153,11 @@ TOKEN_ADDRESSES = {
} }
TOKENS_INFO = {} TOKENS_INFO = {}
try:
with open('./logs/token_info.json', 'r') as f:
TOKENS_INFO = json.load(f)
except Exception as e:
logging.error(f"Error loading token info: {str(e)}")
# # # # # # # # # # TELEGRAM # # # # # # # # # # # # # # # # # # # # TELEGRAM # # # # # # # # # #
async def send_telegram_message(message): async def send_telegram_message(message):
@ -329,11 +333,11 @@ async def get_token_name(mint_address):
TOKENS_INFO[mint_address]['decimals'] = account_data_info['decimals'] TOKENS_INFO[mint_address]['decimals'] = account_data_info['decimals']
else: else:
TOKENS_INFO[mint_address] = {'decimals': account_data_info['decimals']} TOKENS_INFO[mint_address] = {'decimals': account_data_info['decimals']}
token_address = Pubkey.from_string(mint_address) # token_address = Pubkey.from_string(mint_address)
# token = Token(solana_client, token_address, TOKEN_PROGRAM_ID, Keypair()) # # token = Token(solana_client, token_address, TOKEN_PROGRAM_ID, Keypair())
token = AsyncToken(solana_client, token_address, TOKEN_PROGRAM_ID, Keypair()) # token = AsyncToken(solana_client, token_address, TOKEN_PROGRAM_ID, Keypair())
tokenInfo = await token.get_mint_info() # tokenInfo = await token.get_mint_info()
token_info = await solana_client.get_account_info_json_parsed(Pubkey.from_string(mint_address)) # token_info = await solana_client.get_account_info_json_parsed(Pubkey.from_string(mint_address))
# if token_info.value and 'symbol' in token_info.value: # if token_info.value and 'symbol' in token_info.value:
# return token_info.value['symbol'] # return token_info.value['symbol']
metadata = await get_token_metadata(mint_address) metadata = await get_token_metadata(mint_address)
@ -452,7 +456,7 @@ async def get_token_metadata(mint_address):
async def get_wallet_balances(wallet_address): async def get_wallet_balances(wallet_address):
balances = {} balances = {}
logging.info(f"Getting balances for wallet: {wallet_address}") logging.info(f"Getting balances for wallet: {wallet_address}")
global TOKENS_INFO
try: try:
response = await solana_client.get_token_accounts_by_owner_json_parsed( response = await solana_client.get_token_accounts_by_owner_json_parsed(
Pubkey.from_string(wallet_address), Pubkey.from_string(wallet_address),
@ -464,25 +468,37 @@ async def get_wallet_balances(wallet_address):
if response.value: if response.value:
for account in response.value: for account in response.value:
parsed_data = account.account.data.parsed try:
if isinstance(parsed_data, dict) and 'info' in parsed_data: parsed_data = account.account.data.parsed
info = parsed_data['info'] if isinstance(parsed_data, dict) and 'info' in parsed_data:
if isinstance(info, dict) and 'mint' in info and 'tokenAmount' in info: info = parsed_data['info']
mint = info['mint'] if isinstance(info, dict) and 'mint' in info and 'tokenAmount' in info:
#amount = float(info['tokenAmount']['amount']) / (10 ** info['tokenAmount']['decimals']) mint = info['mint']
amount = float(info['tokenAmount']['amount'])/10**info['tokenAmount']['decimals'] decimals = info['tokenAmount']['decimals']
decimals = info['tokenAmount']['decimals'] amount = float(info['tokenAmount']['amount'])/10**decimals
if amount > 0: if amount > 0:
token_name = await get_token_name(mint) or 'Unknown' if mint in TOKENS_INFO:
balances[mint] = { token_name = TOKENS_INFO[mint].get('symbol')
'name': token_name, else:
'address': mint, token_name = await get_token_name(mint) or 'N/A'
'amount': amount, # sleep for 1 second to avoid rate limiting
'decimals': decimals await asyncio.sleep(2)
}
TOKENS_INFO[mint]['holdedAmount'] = amount
TOKENS_INFO[mint]['decimals'] = decimals
balances[mint] = {
'name': token_name,
'address': mint,
'amount': amount,
'decimals': decimals
}
# sleep for 1 second to avoid rate limiting
logging.debug(f"Balance for {token_name} ({mint}): {amount}") logging.debug(f"Balance for {token_name} ({mint}): {amount}")
else: else:
logging.warning(f"Unexpected data format for account: {account}") logging.warning(f"Unexpected data format for account: {account}")
except Exception as e:
logging.error(f"Error parsing account data: {str(e)}")
sol_balance = await solana_client.get_balance(Pubkey.from_string(wallet_address)) sol_balance = await solana_client.get_balance(Pubkey.from_string(wallet_address))
if sol_balance.value is not None: if sol_balance.value is not None:
@ -496,7 +512,7 @@ async def get_wallet_balances(wallet_address):
except Exception as e: except Exception as e:
logging.error(f"Error getting wallet balances: {str(e)}") logging.error(f"Error getting wallet balances: {str(e)}")
logging.info(f"Found {len(response.value)} ({len(balances)} non zero) token accounts for wallet: {wallet_address}")
return balances return balances
async def convert_balances_to_currency(balances , sol_price): async def convert_balances_to_currency(balances , sol_price):
@ -735,6 +751,7 @@ async def solana_jsonrpc(method, params = None, jsonParsed = True):
async def list_initial_wallet_states(): async def list_initial_wallet_states():
global TOKEN_ADDRESSES, FOLLOWED_WALLET_VALUE, YOUR_WALLET_VALUE, TOKEN_PRICES global TOKEN_ADDRESSES, FOLLOWED_WALLET_VALUE, YOUR_WALLET_VALUE, TOKEN_PRICES
global TOKENS_INFO # new
followed_wallet_balances = await get_wallet_balances(FOLLOWED_WALLET) followed_wallet_balances = await get_wallet_balances(FOLLOWED_WALLET)
your_wallet_balances = await get_wallet_balances(YOUR_WALLET) your_wallet_balances = await get_wallet_balances(YOUR_WALLET)
@ -746,6 +763,7 @@ async def list_initial_wallet_states():
followed_converted_balances = await convert_balances_to_currency(followed_wallet_balances, sol_price) followed_converted_balances = await convert_balances_to_currency(followed_wallet_balances, sol_price)
your_converted_balances = await convert_balances_to_currency(your_wallet_balances, sol_price) your_converted_balances = await convert_balances_to_currency(your_wallet_balances, sol_price)
TOKEN_ADDRESSES = { TOKEN_ADDRESSES = {
address: info for address, address: info for address,
info in {**followed_converted_balances, **your_converted_balances}.items() if info['value'] is not None and info['value'] > 0 info in {**followed_converted_balances, **your_converted_balances}.items() if info['value'] is not None and info['value'] > 0
@ -756,14 +774,14 @@ async def list_initial_wallet_states():
FOLLOWED_WALLET_VALUE = 0 FOLLOWED_WALLET_VALUE = 0
for address, info in followed_converted_balances.items(): for address, info in followed_converted_balances.items():
if info['value'] is not None and info['value'] > 0: if info['value'] is not None and info['value'] > 0:
followed_wallet_state.append(f"{info['name']} ({address}): {info['value']:.2f} {DISPLAY_CURRENCY}") followed_wallet_state.append(f"{info['name']}: {info['value']:.2f} {DISPLAY_CURRENCY}")
FOLLOWED_WALLET_VALUE += info['value'] FOLLOWED_WALLET_VALUE += info['value']
your_wallet_state = [] your_wallet_state = []
YOUR_WALLET_VALUE = 0 YOUR_WALLET_VALUE = 0
for address, info in your_converted_balances.items(): for address, info in your_converted_balances.items():
if info['value'] is not None and info['value'] > 0: if info['value'] is not None and info['value'] > 0:
your_wallet_state.append(f"{info['name']} ({address}): {info['value']:.2f} {DISPLAY_CURRENCY}") your_wallet_state.append(f"{info['name']}: {info['value']:.2f} {DISPLAY_CURRENCY}")
YOUR_WALLET_VALUE += info['value'] YOUR_WALLET_VALUE += info['value']
message = ( message = (
@ -780,8 +798,13 @@ async def list_initial_wallet_states():
logging.info(message) logging.info(message)
await send_telegram_message(message) await send_telegram_message(message)
# save token info to file
with open('./logs/token_info.json', 'w') as f:
json.dump(TOKENS_INFO, f, indent=2)
async def get_transaction_details_with_retry(transaction_id, retry_delay = 10, max_retries = 10):
async def get_transaction_details_with_retry(transaction_id, retry_delay = 5, max_retries = 20):
# wait for the transaction to be confirmed # wait for the transaction to be confirmed
# await async_client.wait_for_confirmation(Signature.from_string(transaction_id)) # await async_client.wait_for_confirmation(Signature.from_string(transaction_id))
# qwery every 5 seconds for the transaction details untill not None or 30 seconds # qwery every 5 seconds for the transaction details untill not None or 30 seconds
@ -877,27 +900,37 @@ async def process_log(log_result):
# GET DETAILS FROM TRANSACTION IF NOT FOUND IN LOGS # GET DETAILS FROM TRANSACTION IF NOT FOUND IN LOGS
if tr_details["token_in"] is None or tr_details["token_out"] is None or tr_details["amount_in"] == 0 or tr_details["amount_out"] == 0: try:
logging.warning("Incomplete swap details found in logs. Getting details from transaction") if tr_details["token_in"] is None or tr_details["token_out"] is None or tr_details["amount_in"] == 0 or tr_details["amount_out"] == 0:
tr_details = await get_transaction_details_info(tx_signature_str, logs) logging.warning("Incomplete swap details found in logs. Getting details from transaction")
# onlt needed if no details got tr_details = await get_transaction_details_info(tx_signature_str, logs)
if before_source_balance > 0 and source_token_change > 0: # onlt needed if no details got
tr_details["percentage_swapped"] = (source_token_change / before_source_balance) * 100 if before_source_balance > 0 and source_token_change > 0:
#dirty fix for percentage > 100 (decimals 9 but expecting 6) tr_details["percentage_swapped"] = (source_token_change / before_source_balance) * 100
if tr_details["percentage_swapped"] > 100: #dirty fix for percentage > 100 (decimals 9 but expecting 6)
tr_details["percentage_swapped"] = tr_details["percentage_swapped"] / 1000 if tr_details["percentage_swapped"] > 100:
tr_details["percentage_swapped"] = tr_details["percentage_swapped"] / 1000
try:
tr_details["symbol_in"] = TOKENS_INFO[tr_details["token_in"]].get('symbol') or await get_token_name(tr_details["token_in"])
tr_details["symbol_out"] = TOKENS_INFO[tr_details["token_out"]].get('symbol') or await get_token_name(tr_details["token_out"])
tr_details['amount_in_USD'] = tr_details['amount_in'] * TOKEN_PRICES.get(tr_details['token_in'], 0)
tr_details['amount_out_USD'] = tr_details['amount_out'] * TOKEN_PRICES.get(tr_details['token_out'], 0)
except Exception as e:
logging.error(f"Error fetching token prices: {e}")
message_text = ( message_text = (
f"<b>Swap detected:</b>\n" f"<b>Swap detected:</b>\n"
f"Token In: {tr_details['token_in']}\n" f"Token In: {tr_details['symbol_in']}\n"
f"Token Out: {tr_details['token_out']}\n" f"Token Out: {tr_details['symbol_out']}\n"
f"Amount In USD: {tr_details['amount_in_USD']}\n" f"Amount In USD: {tr_details['amount_out_USD']:.2f}\n"
f"Percentage Swapped: {tr_details['percentage_swapped']:.2f}%" f"Percentage Swapped: {tr_details['percentage_swapped']:.2f}%"
) )
await send_telegram_message(message_text)
await send_telegram_message(message_text) await follow_move(tr_details)
await follow_move(tr_details) except Exception as e:
logging.error(f"Error aquiring log details and following: {e}")
return
except Exception as e: except Exception as e:
logging.error(f"Error processing log: {e}") logging.error(f"Error processing log: {e}")
@ -923,6 +956,12 @@ async def get_transaction_details_info(tx_signature_str: str, logs: List[str]) -
# Fetch token prices # Fetch token prices
token_prices = await get_token_prices([tr_info['token_in'], tr_info['token_out']]) token_prices = await get_token_prices([tr_info['token_in'], tr_info['token_out']])
for token, price in token_prices.items():
if price is None:
if token in TOKENS_INFO:
TOKENS_INFO[token]['price'] = price
else:
TOKENS_INFO[token] = {'price': price}
# Calculate USD values # Calculate USD values
tr_info['amount_in_usd'] = tr_info['amount_in'] * token_prices.get(tr_info['token_in'], 0) tr_info['amount_in_usd'] = tr_info['amount_in'] * token_prices.get(tr_info['token_in'], 0)
@ -950,8 +989,9 @@ async def follow_move(move):
await send_telegram_message(msg) await send_telegram_message(msg)
return return
your_balance = your_balance_info['amount'] your_balance = TOKENS_INFO[move['token_in']].get('holdedAmount') or your_balance_info['amount']
token_name = your_balance_info['name'] token_name_in = TOKENS_INFO[move['token_in']].get('symbol') or await get_token_name(move['token_in'])
token_name_out = TOKENS_INFO[move['token_out']].get('symbol') or await get_token_name(move['token_out'])
# move["percentage_swapped"] = (move["amount_out"] / move["amount_in"]) * 100 # move["percentage_swapped"] = (move["amount_out"] / move["amount_in"]) * 100
# Calculate the amount to swap based on the same percentage as the followed move # Calculate the amount to swap based on the same percentage as the followed move
@ -968,12 +1008,22 @@ async def follow_move(move):
# Convert to lamports # Convert to lamports
# if decimals is 6, then amount = amount * 1e6; if 9, then amount = amount * 1e9 # if decimals is 6, then amount = amount * 1e6; if 9, then amount = amount * 1e9
amount = int(amount_to_swap * 10**your_balance_info['decimals']) amount = int(amount_to_swap * 10**your_balance_info['decimals'])
transaction_data = await jupiter.swap( transaction_data = await jupiter.swap(
input_mint=move['token_in'], input_mint=move['token_in'],
output_mint=move['token_out'], output_mint=move['token_out'],
amount=amount, amount=amount,
slippage_bps=100, # Increased to 1% slippage_bps=100, # Increased to 1%
) )
notification = (
f"<b>Initiating move:</b>\n (decimals: {your_balance_info['decimals']})\n"
f"Swapping {move['percentage_swapped']:.2f}% ({amount_to_swap:.2f}) {token_name_in} for {token_name_out}"
)
logging.info(notification)
error_logger.info(notification)
await send_telegram_message(notification)
raw_transaction = VersionedTransaction.from_bytes(base64.b64decode(transaction_data)) raw_transaction = VersionedTransaction.from_bytes(base64.b64decode(transaction_data))
signature = private_key.sign_message(message.to_bytes_versioned(raw_transaction.message)) signature = private_key.sign_message(message.to_bytes_versioned(raw_transaction.message))
signed_txn = VersionedTransaction.populate(raw_transaction.message, [signature]) signed_txn = VersionedTransaction.populate(raw_transaction.message, [signature])
@ -983,35 +1033,23 @@ async def follow_move(move):
transaction_id = json.loads(result.to_json())['result'] transaction_id = json.loads(result.to_json())['result']
print(f"Follow Transaction Sent: https://solscan.io/tx/{transaction_id}") print(f"Follow Transaction Sent: https://solscan.io/tx/{transaction_id}")
notification = (
f"<b>Move Initiated:</b>\n (decimals: {your_balance_info['decimals']})\n"
f"Swapping {move['percentage_swapped']:.2f}% ({amount_to_swap}) {token_name} ({move['token_in']}) "
f"for {move['token_out']}"
f"\n\n<b>Transaction:</b> <a href='https://solscan.io/tx/{transaction_id}'>{transaction_id}</a>"
)
logging.info(notification)
await send_telegram_message(notification)
tx_details = await get_transaction_details_with_retry(transaction_id) tx_details = await get_transaction_details_with_retry(transaction_id)
if tx_details is None: if tx_details is None:
logging.info(f"Failed to get transaction details for {transaction_id}") logging.info(f"Failed to get transaction details for {transaction_id}")
notification = ( notification = (
f"<b>Move Followed:</b>\n" f"<b>Move Followed:</b>\n"
f"Swapped {amount_to_swap:.6f} {token_name} ({move['token_in']}) " f"Swapped {amount_to_swap:.6f} {token_name_in} ({move['token_in']}) "
f"(same {move['percentage_swapped']:.2f}% as followed wallet)\n" f"(same {move['percentage_swapped']:.2f}% as followed wallet)\n"
f"\n\n<b>Transaction:</b> <a href='https://solscan.io/tx/{transaction_id}'>{transaction_id}</a>" f"\n\n<b>Transaction:</b> <a href='https://solscan.io/tx/{transaction_id}'>{transaction_id}</a>"
) )
else: else:
output_token_info = your_balances.get(move['token_out'], {'name': 'Unknown'})
output_token_name = output_token_info['name']
notification = ( notification = (
f"<b>Move Followed:</b>\n" f"<b>Move Followed:</b>\n"
f"Swapped {amount_to_swap:.6f} {token_name} ({move['token_in']}) " f"Swapped {amount_to_swap:.6f} {token_name_in} ({move['symbol_in']}) "
f"(same {move['percentage_swapped']:.2f}% as followed wallet)\n" f"(same {move['percentage_swapped']:.2f}% as followed wallet)\n"
f"for {tx_details['amount_out']:.6f} {output_token_name} ({move['token_out']})" f"for {tx_details['amount_out']:.6f} {token_name_out} ({move['symbol_out']})"
# f"Amount In USD: {tr_details['amount_in_USD']}\n" # f"Amount In USD: {tr_details['amount_in_USD']}\n"
f"\n\n<b>Transaction:</b> <a href='https://solscan.io/tx/{transaction_id}'>{transaction_id}</a>" f"\n\n<b>Transaction:</b> <a href='https://solscan.io/tx/{transaction_id}'>{transaction_id}</a>"
) )
@ -1028,7 +1066,7 @@ async def follow_move(move):
else: else:
msg = ( msg = (
f"<b>Move Not Followed:</b>\n" f"<b>Move Not Followed:</b>\n"
f"Insufficient balance to swap {amount_to_swap:.6f} {token_name} ({move['token_in']})" f"Insufficient balance to swap {amount_to_swap:.6f} {token_name_in} ({move['token_in']})"
) )
logging.warning(msg) logging.warning(msg)
await send_telegram_message(msg) await send_telegram_message(msg)
@ -1121,7 +1159,7 @@ async def subscribe_to_wallet():
async def main(): async def main():
# Initialize logging # Initialize logging
await send_telegram_message("Solana Agent Started. Connecting to mainnet...") await send_telegram_message("Solana Agent Started. Connecting to mainnet...")
await list_initial_wallet_states() asyncio.create_task( list_initial_wallet_states())
await subscribe_to_wallet() await subscribe_to_wallet()
def run_flask(): def run_flask():

7
crypto/sol/readme.md
View File

@ -33,3 +33,10 @@ pip-compile requirements.in
# pip-sync requirements.txt # pip-sync requirements.txt
echo "Requirements have been updated in requirements.txt" echo "Requirements have been updated in requirements.txt"
max ammount on FATGF gives error:
ERROR:error_logger:<b>Swap Follow Error:</b>
Program log: Instruction: Transfer", "Program log: Error: insufficient funds", "Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 4300 of 1363889 compute units"