DEV Community: Brave

TETRIS - JS, Socket, Express

Brave — Sat, 05 Apr 2025 11:08:26 +0000

████████╗███████╗████████╗██████╗ ██╗███████╗
╚══██╔══╝██╔════╝╚══██╔══╝██╔══██╗██║██╔════╝ 
   ██║   █████╗     ██║   ██████╔╝██║███████╗
   ██║   ██╔══╝     ██║   ██╔══██╗██║╚════██║
   ██║   ███████╗   ██║   ██║  ██║██║███████║
   ╚═╝   ╚══════╝   ╚═╝   ╚═╝  ╚═╝╚═╝╚══════╝

This project is a Tetris game built using Node.js, JavaScript, Express, HTML, and CSS. It provides a web-based implementation of the classic Tetris game.

Tech stack

Javascript
Node.js, Express
Socket

https://github.com/plzbugmenot/Tetris-JS-HTML-CSS-Express

How to get Announcement from Binance ASAP?

Brave — Tue, 03 Dec 2024 09:41:44 +0000

Hello, coders.

I am currently working on a project.
I need to get new announcements from "https://www.binance.com/en/support/announcement/new-cryptocurrency-listing?c=48" asap.
I want to get new announcements within 1-2 seconds.

The current codebase is implemented with Python Scrapping.

URL = "https://www.binance.com/en/support/announcement/new-cryptocurrency-listing?c=48"
response = await self.fetch_with_retry(
    f"http://api.scrape.do/?token={API_KEY}&url={URL}",
    GET_MODE,
    headers=HEADERS
)

But it takes over 10 seconds.

I have two questions:

1) Is it possible to get new announcements using API instead of scraping?

2) How can I reduce the time by using scraping?

I hope hear from you.

python Binance Announcement scarpping API

Monitoring Discord server, detect CA, sending it to telegram bot

Brave — Wed, 27 Nov 2024 19:18:57 +0000

What’s a Discord Self-Bot?

A Discord self-bot is basically a bot that runs using your personal Discord account instead of a separate bot account.

Why Use a Self-Bot?

With a self-bot, you can keep an eye on all the servers and channels your account is part of. Just remember, while self-bots can do some cool automation stuff, they come with big risks and are against Discord's rules.

Let’s Build a Simple Discord Self-Bot!

Requirements:

Monitor Specific Servers and Channels: We’ll track the servers and channels that your account has joined.
Catch Messages: The bot will listen for messages in these channels and look for Solana token contract addresses.
Send to Telegram: When it finds a token address, it will send that info to a Telegram trading bot so you can buy the token ASAP. ## Analysis:
Monitoring: We’ll use the Discord self-bot for monitoring.
Messaging: To send messages to the Telegram bot, we’ll use the Telegram API.
Implementation: We’ll write this using JavaScript or TypeScript with Node.js.

Development

Installation

Node.js 18+

npm install discord.js-selfbot-v13@latest telegram

Make self-bot

import { Client } from "discord.js-selfbot-v13";

// Initialize Discord client
const discordClient = new Client();

// Discord event handlers
discordClient.on("ready", () => {
  console.log(`Logged in as ${discordClient.user?.tag}`);
});

...

await discordClient.login(DISCORD_USER_TOKEN);

How to get DISCORD_USER_TOKEN?

Run code (Discord Console - [Ctrl + Shift + I])

allow pasting

window.webpackChunkdiscord_app.push([
  [Math.random()],
  {},
  req => {
    if (!req.c) return;
    for (const m of Object.keys(req.c)
      .map(x => req.c[x].exports)
      .filter(x => x)) {
      if (m.default && m.default.getToken !== undefined) {
        return copy(m.default.getToken());
      }
      if (m.getToken !== undefined) {
        return copy(m.getToken());
      }
    }
  },
]);
console.log('%cWorked!', 'font-size: 50px');
console.log(`%cYou now have your token in the clipboard!`, 'font-size: 16px');

Sending message to telegram bot using Telegram API

import { TelegramClient } from "telegram";

const TELEGRAM_API_ID = parseInt(process.env.TELEGRAM_API_ID || "0");
const TELEGRAM_API_HASH = process.env.TELEGRAM_API_HASH || "";

// Initialize Telegram client
const telegramClient = new TelegramClient(
  new StringSession(""),
  TELEGRAM_API_ID,
  TELEGRAM_API_HASH,
  { connectionRetries: 5 }
);

...
  console.log("Starting Telegram client...");
    await telegramClient.start({
      phoneNumber: async () =>
        await promptUser("Please enter your phone number: "),
      password: async () => await promptUser("Please enter your password: "),
      phoneCode: async () =>
        await promptUser("Please enter the code you received: "),
      onError: (err: any) => console.log(err),
    });
    // logger.info("📲 Telegram client started successfully");

How to get Telegram API key?

Go to https://my.telegram.org/auth
Log in with your phone number
Go to "API development tools"
Create a new application
You'll receive:
- api_id (numbers)
- api_hash (string)

Codebase

import { Client } from "discord.js-selfbot-v13";
import { TelegramClient } from "telegram";
import { StringSession } from "telegram/sessions";
import * as readline from "readline";
import dotenv from "dotenv";
import fs from "fs";
import {
  detectSolanaTokenAddress,
  saveAddress,
  loadTrackedAddresses,
} from "./utils/utils";
// import logger from "./utils/logger";

// Create readline interface
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

// Prompt function
function promptUser(question: string): Promise<string> {
  return new Promise((resolve) => {
    rl.question(question, (answer) => {
      resolve(answer);
    });
  });
}

// Load environment variables
dotenv.config();

// Load config
function loadConfig() {
  return JSON.parse(fs.readFileSync("config.json", "utf8"));
}

const config = loadConfig();

// Access environment variables
const DISCORD_USER_TOKEN = process.env.DISCORD_USER_TOKEN;
const TELEGRAM_API_ID = parseInt(process.env.TELEGRAM_API_ID || "0");
const TELEGRAM_API_HASH = process.env.TELEGRAM_API_HASH || "";

// Get settings from config
const BOT_USERNAME = config.telegram.bot_username;
const MONITORED_SERVERS = config.discord.server_channels;

// Initialize Discord client
const discordClient = new Client();

// Initialize Telegram client
const telegramClient = new TelegramClient(
  new StringSession(""),
  TELEGRAM_API_ID,
  TELEGRAM_API_HASH,
  { connectionRetries: 5 }
);

// Discord event handlers
discordClient.on("ready", () => {
  // logger.info(`Logged in as ${discordClient.user?.tag}`);
  console.log(`Logged in as ${discordClient.user?.tag}`);
});

discordClient.on("messageCreate", async (message: any) => {
  try {
    const serverId = message.guild?.id.toString();
    const channelId = message.channel.id.toString();

    for (const serverConfig of MONITORED_SERVERS) {
      if (
        serverId in serverConfig &&
        serverConfig[serverId].includes(channelId)
      ) {
        // logger.info(`Detected message in ${serverConfig[serverId]}`);

        const solanaAddresses = await detectSolanaTokenAddress(message.content);
        // logger.info(`Detected Solana addresses: ${solanaAddresses}`);

        if (solanaAddresses.length > 0) {
          const addressMap = loadTrackedAddresses();
          // Process addresses sequentially
          for (const address of solanaAddresses) {
            // Check if address exists in Map before sending
            if (!addressMap.has(address)) {
              try {
                await telegramClient.sendMessage(BOT_USERNAME, {
                  message: address,
                });
                // logger.info(`Sent message for address: ${address}`);
                saveAddress(address);
                // Add delay between messages
                await new Promise((resolve) => setTimeout(resolve, 1000));
              } catch (error) {
                // logger.error(
                //   `Failed to send message for address ${address}: ${error}`
                // );
                continue;
              }
            } else {
              // logger.info(`Skipping existing address: ${address}`);
            }
          }
        }
      }
    }
  } catch (error) {
    // logger.error(`Error processing message: ${error}`);
    // Don't exit process, just log the error and continue
  }
});

async function startTelegramClient() {
  try {
    console.log("Starting Telegram client...");
    await telegramClient.start({
      phoneNumber: async () =>
        await promptUser("Please enter your phone number: "),
      password: async () => await promptUser("Please enter your password: "),
      phoneCode: async () =>
        await promptUser("Please enter the code you received: "),
      onError: (err: any) => console.log(err),
    });
    // logger.info("📲 Telegram client started successfully");
  } catch (err: any) {
    console.error("Error starting Telegram client:", err);
    process.exit(1);
  }
}

async function startDiscordClient() {
  try {
    console.log("Starting Discord client... ");
    await discordClient.login(DISCORD_USER_TOKEN);
    // logger.info("🤖 Discord client started successfully");
  } catch (err: any) {
    console.error("Error starting Discord client:", err);
    process.exit(1);
  }
}

// Improve error handling in main function
async function main() {
  console.log("-------------------------> Starting bot...", Date.now());
  try {
    await startTelegramClient();
    await startDiscordClient(); // Make this await

    // Add process error handlers
    process.on("uncaughtException", (error) => {
      // logger.error("Uncaught Exception:", error);
    });

    process.on("unhandledRejection", (error) => {
      // logger.error("Unhandled Rejection:", error);
    });
  } catch (error) {
    // logger.error("Error in main:", error);
    process.exit(1);
  }
}

main();

Additional link: https://github.com/Any-bot/D2T_CA_bot_Node

Discord #self-bot #telegram-api

Understanding Upwork's Security Systems: A Deep Technical Dive

Brave — Fri, 22 Nov 2024 07:55:44 +0000

1. Behavioral Analysis

a) Account Activity Patterns

Login times and frequency (e.g., if someone typically logs in from New York at 9 AM but suddenly logs in from Manila at 3 AM)
Number of proposals sent (e.g., sending 50 proposals in 1 hour is suspicious)
Time spent on each page (genuine users spend time reading, while bots move quickly)

b) Communication Style Monitoring
Message patterns and templates
Language consistency
Response timing Example: If a freelancer suddenly changes their writing style from professional English to broken English, it raises flags

c) Job Posting/Bidding Behaviors
Bid amounts (unusually low or high bids)
Copy-pasted proposals
Immediate responses to all job posts Example: A genuine freelancer takes time to craft unique proposals, while scammers often use identical messages

2. Machine Learning Systems

a) Automated Fraud Detection

def detect_suspicious_activity(user_data):
    risk_score = 0

    # Check login patterns
    if user_data.login_country_changes > 3:
        risk_score += 20

    # Check proposal patterns
    if user_data.proposals_per_hour > 10:
        risk_score += 15

    return risk_score > 30

b) Pattern Recognition

Historical data analysis
Behavior clustering
Anomaly detection Example: System identifies patterns like multiple accounts sharing the same IP address or bank details

3. Profile Quality Checks

a) Portfolio Verification

Image reverse search
Code repository validation
Project timestamp verification Example: System checks if portfolio images are stolen from other websites

b) Skills Assessment Tests
Monitored test taking
Score pattern analysis
Time tracking during tests Example: If someone scores 100% in 2 minutes on a test that typically takes 30 minutes

c) Work History Validation
Client interaction verification
Payment history analysis
Project completion rates Example: A sudden spike in completed projects with minimal time spent raises flags

4. Additional Security Measures

a) Two-Factor Authentication (2FA)

function verify2FA(user, code) {
    const storedCode = generateTOTP(user.secret);
    const timeWindow = 30; // seconds

    return {
        isValid: code === storedCode,
        expiresIn: timeWindow
    };
}

b) IP Address Monitoring

Geolocation tracking
VPN detection
Login pattern analysis Example: Multiple accounts accessing from the same IP range

c) Device Fingerprinting
Browser characteristics
Screen resolution
Installed fonts
Hardware specifications Example: System creates unique device IDs to track suspicious patterns

d) Social Media Verification
Profile cross-referencing
Activity timeline verification
Connection analysis Example: LinkedIn profile showing 10 years of experience while the person claims to be 18

Real-World Implementation:

class AccountRiskAssessor:
    def calculate_risk_score(self, account):
        score = 0

        # Location checks
        if self.has_multiple_login_locations(account):
            score += 25

        # Communication patterns
        if self.detect_template_messages(account):
            score += 15

        # Profile consistency
        if not self.verify_portfolio_authenticity(account):
            score += 30

        # Bidding behavior
        if self.analyze_bid_patterns(account):
            score += 20

        return score

    def take_action(self, risk_score):
        if risk_score > 75:
            return "BLOCK_ACCOUNT"
        elif risk_score > 50:
            return "FLAG_FOR_REVIEW"
        return "MONITOR"

These systems work together in real-time to create a robust security framework. For example:

1. A user logs in from a new location

2. System checks:

Device fingerprint
IP address
Time of login
Previous activity patterns ## 3. Risk score is calculated ## 4. Action is taken based on combined factors

This multi-layered approach helps Upwork maintain platform integrity while allowing legitimate users to work freely. The system continuously learns and adapts to new patterns, making it increasingly effective at detecting sophisticated scam attempts.

If you found this article helpful, consider following me for more technical deep dives. Share your thoughts and experiences in the comments below!

security #machinelearning #authentication #fraud

Building a Discord-to-Telegram Token Address Forwarder

Brave — Fri, 15 Nov 2024 00:25:47 +0000

Welcome, code warriors! Today, we're diving into building a powerful bridge between Discord and Telegram that automatically detects and forwards Solana token addresses. Whether you're tracking new tokens or monitoring specific addresses, this guide will show you how to create an automated solution using Python.
Additional link: https://github.com/Any-bot/D2T-msg-forward.git

1. What is This Project?

This is a self-bot that:

Monitors Discord messages for Solana token addresses
Detects both raw addresses and DexScreener URLs
Forwards unique addresses to a Telegram bot
Maintains a tracking system to avoid duplicates

2. Why Build This?

Real-time Monitoring: Instantly capture token addresses from Discord
Automation: No manual copying and pasting required
Data Filtering: Avoid duplicate addresses with built-in tracking
Cross-Platform: Bridge Discord and Telegram seamlessly

3. Core Components

Discord Client

discord_client = commands.Bot(command_prefix="!", self_bot=True)

Telegram Client

telegram_client = TelegramClient('session_name', TELEGRAM_API_ID, TELEGRAM_API_HASH)

Address Detection System

def detect_solana_token_address(message):
    dexscreener_pattern = r'dexscreener\.com/solana/([1-9A-HJ-NP-Za-km-z]{32,44})'
    # ... detection logic

4. Key Features

4.1 DexScreener Integration:

Extracts base token addresses from DexScreener URLs
Falls back to original address if API fails 4.2 Address Tracking:
JSON-based storage system
Prevents duplicate forwards
Persistent across restarts 4.3 Asynchronous Operations:
Non-blocking message handling
Rate-limited forwarding
Efficient multi-client management

5. Implementation Guide

Environment Setup

DISCORD_USER_TOKEN=your_token
TELEGRAM_API_ID=your_api_id
TELEGRAM_API_HASH=your_api_hash
BOT_USERNAME=@your_bot

Main Event Handler

@discord_client.event
async def on_message(message):
    solana_addresses = detect_solana_token_address(message.content)
    if solana_addresses:
        for address in solana_addresses:
            # Forward unique addresses

Address Storage System

def save_address(address):
    addresses = load_tracked_addresses()
    addresses.append(address)
    with open(TRACKED_ADDRESSES_FILE, 'w') as f:
        json.dump(addresses, f)

6. Best Practices

6.1 Rate Limiting:

1-second delay between messages
Prevents API throttling
Maintains service stability 6.2 Error Handling:
Graceful API failure handling
Logging for debugging
Fallback mechanisms 6.3 Data Management:
JSON-based persistence
Efficient address tracking
Memory-conscious operations

7. Advanced Features

7.1 Regular Expression Patterns:

Solana address validation
DexScreener URL parsing
Flexible pattern matching 7.2 API Integration:
DexScreener data fetching
Base token extraction
Error resilient requests

Conclusion

This project demonstrates the power of automation in crypto monitoring. By combining Discord and Telegram's capabilities, we've created a robust system for tracking Solana token addresses across platforms.

Remember: A great bot isn't just about functionality – it's about reliability, efficiency, and maintainability. Keep your code clean, your error handling robust, and your logging informative.

Happy coding, and may your tokens always find their way! 🚀

This article maintains the engaging style of the analyzed piece while focusing on your specific implementation and its unique features.

How to fix "Module 'audioop' Missing"?

Brave — Wed, 13 Nov 2024 11:46:24 +0000

I am building a Discord bot using Python (discord.py) and encountered an error stating "Module 'audioop' Missing." The error traceback is as follows:

Traceback (most recent call last):
  File "F:\Codes\Python\discordbot\Discord\main.py", line 1, in <module>
    import discord
  File "F:\Codes\Python\discordbot\Lib\site-packages\discord\__init__.py", line 23, in <module>    
    from .client import *
  File "F:\Codes\Python\discordbot\Lib\site-packages\discord\client.py", line 51, in <module>      
    from .user import User, ClientUser
  File "F:\Codes\Python\discordbot\Lib\site-packages\discord\user.py", line 29, in <module>        
    import discord.abc
  File "F:\Codes\Python\discordbot\Lib\site-packages\discord\abc.py", line 59, in <module>
    from .voice_client import VoiceClient, VoiceProtocol
  File "F:\Codes\Python\discordbot\Lib\site-packages\discord\voice_client.py", line 53, in <module>
    from .player import AudioPlayer, AudioSource
  File "F:\Codes\Python\discordbot\Lib\site-packages\discord\player.py", line 28, in <module>
    import audioop
ModuleNotFoundError: No module named 'audioop'

I resolved this issue by executing the command pip install audioop-lts. However, I would like to understand the origin of this error and its implications in greater detail.