Getting started

Setting-up your account.

To launch coins with Telau, you need to create an account in the bot conversation.

As a true web3 project, Telau doesn't requires any mail or phone number.

You just need to start the bot and generate a wallet, you can also enter your own private key.

Security of your account.

Security of Private Keys

The private keys are strictly encrypted (using turnkey) and we do not have access to them, ensuring maximum protection.

You can unlink your wallet at any time in the menu.

Recommendation

To ensure optimal security, we recommend generating a new wallet.

Code Blocks (Some)

                    "menu_wallet" => {
                        handle_wallet(
                            &bot, chat_id, user_id,
                            &*db_pool, &*encryption_key, &*solana_client,
                            WalletMenuMode::Main,
                            None,
                        ).await?;
                    }
                    "wallet_back" => {
                        let mid = if let Some(MaybeInaccessibleMessage::Regular(m)) = &q.message {
                            Some(m.id)
                        } else { None };
                        handle_wallet(
                            &bot, chat_id, user_id,
                            &*db_pool, &*encryption_key, &*solana_client,
                            WalletMenuMode::Main,
                            mid,
                        ).await?;
                    }
                    "wallet_manage_creator" => {
                        let mid = if let Some(MaybeInaccessibleMessage::Regular(m)) = &q.message {
                            Some(m.id)
                        } else { None };
                        handle_wallet(
                            &bot, chat_id, user_id,
                            &*db_pool, &*encryption_key, &*solana_client,
                            WalletMenuMode::Creator,
                            mid,
                        ).await?;
                    }
                    "wallet_import_creator" => {
                        let message_text = "📥 Enter your private key\n_Both \"55aQ5qU6...\" and \"\\[14,72,31,...\\]\" formats are supported_";
                        let sent_msg = bot.send_message(id, half_escape_telegram(message_text))
                            .parse_mode(ParseMode::MarkdownV2)
                            .reply_markup(ForceReply::new())
                            .await?;
                        waiting_for_key.lock().await.insert(id.into(), Some(("import_creator".to_string(), sent_msg.id, None)));
                    }
                    "wallet_export_creator" => {
                        export_wallet_key(&bot, chat_id, user_id, &*db_pool, &*encryption_key, KeyType::Creator).await?;
                    }
                    "wallet_delete_export" => {
                        if let Some(MaybeInaccessibleMessage::Regular(message)) = &q.message {
                            bot.delete_message(message.chat.id, message.id).await?;
                        }
                    }

pub async fn export_wallet_key(
    bot: &Bot,
    chat_id: ChatId,
    user_id: i64,
    db_pool: &PgPool,
    encryption_key: &EncryptionKey,
    which: KeyType,
) -> Result<(), teloxide::RequestError> {
    let label = match which {
        KeyType::Creator => "Creator"
    };
    match get_user_privkey(db_pool, user_id, &*encryption_key, which).await {
        Ok(pk) => {
            match decrypt(&pk, &encryption_key) {
                Ok(plain) => {
                    let bytes: Vec<u8> = serde_json::from_str(&plain).unwrap_or_default();
                    let base58_str = bs58::encode(&bytes).into_string();
                    let text = format!("🔑 {} private key:\n||{}||", label, base58_str);

                    let keyboard = InlineKeyboardMarkup::new(vec![
                        vec![InlineKeyboardButton::callback("🫧 Delete export message", "wallet_delete_export")],
                    ]);
                    bot.send_message(chat_id, text)
                        .parse_mode(ParseMode::MarkdownV2)
                        .reply_markup(keyboard)
                        .await?;
                }
                Err(e) => {
                    eprintln!("Decrypt error: {}", e);
                    bot.send_message(chat_id, error_msg())
                        .parse_mode(ParseMode::MarkdownV2)
                        .disable_link_preview(true)
                        .await?;
                }
            }
        }
        Err(e) => {
            eprintln!("DB error exporting key: {}", e);
            bot.send_message(chat_id, error_msg())
                .parse_mode(ParseMode::MarkdownV2)
                .disable_link_preview(true)
                .await?;
        }
    }
    Ok(())
}

pub enum WalletMenuMode {
    Main,
    Creator
}

pub async fn handle_wallet(
    bot: &Bot,
    chat_id: ChatId,
    user_id: i64,
    db_pool: &sqlx::PgPool,
    encryption_key: &EncryptionKey,
    solana_client: &solana_client::rpc_client::RpcClient,
    mode: WalletMenuMode,
    message_id: Option<MessageId>,
) -> Result<(), teloxide::RequestError> {
    let message;
    let keyboard;

    match mode {
        WalletMenuMode::Main => {
            let creator_info = match get_user_pubkey(db_pool, user_id, encryption_key, KeyType::Creator).await {
                Ok(pubkey) => {
                    let lamports = Pubkey::from_str(&pubkey).ok().and_then(|pk| solana_client.get_balance(&pk).ok()).unwrap_or(0);
                    let sol_balance = lamports as f64 / 1_000_000_000.0;
                    format!(
                        "• 🧑‍💻 Creator address: `{}`\n• 💰 Balance: {} SOL",
                        pubkey,
                        fmt_sol_trim(sol_balance)
                    )
                },
                Err(_) => error_msg(),
            };
            message = format!("💳 __Wallets__\n\n{}",
                half_escape_telegram(&creator_info),
            );
            keyboard = InlineKeyboardMarkup::new(vec![
                vec![InlineKeyboardButton::callback("🧑‍💻 Manage creator", "wallet_manage_creator")]
            ]);
        }
        WalletMenuMode::Creator => {
            let creator_info = match get_user_pubkey(db_pool, user_id, encryption_key, KeyType::Creator).await {
                Ok(pubkey) => {
                    let lamports = Pubkey::from_str(&pubkey).ok().and_then(|pk| solana_client.get_balance(&pk).ok()).unwrap_or(0);
                    let sol_balance = lamports as f64 / 1_000_000_000.0;
                    format!(
                        "• 🧑‍💻 Creator address: `{}`\n• 💰 Balance: {} SOL",
                        pubkey,
                        fmt_sol_trim(sol_balance)
                    )
                },
                Err(_) => error_msg(),
            };
            message = format!("💳 __Creator wallet__\n\n{}", half_escape_telegram(&creator_info));
            keyboard = InlineKeyboardMarkup::new(vec![
                vec![
                    InlineKeyboardButton::callback("📥 Import", "wallet_import_creator"),
                    InlineKeyboardButton::callback("🔑 Export", "wallet_export_creator"),
                ],
                vec![InlineKeyboardButton::callback("⬅️ Back to wallets menu", "wallet_back")],
            ]);
        }
    }

PreviousWhat is Telau ?NextLaunch news coins

Last updated 2 months ago