diself 0.3.0

A Discord self-bot library for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use serde::{Deserialize, Serialize};

//Authentication payload for Discord Gateway
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Identify {
    /// User Discord token
    pub token: String,

    /// Connection properties (OS, browser, device)
    pub properties: ConnectionProperties,

    /// Initial presence (optional)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub presence: Option<PresenceUpdate>,

    /// Compression (must be false for selfbots)
    pub compress: Option<bool>,

    /// Client capability (essential for selfbots)
    pub capabilities: u32,

    /// Gateway intents (what events we want to receive)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub intents: Option<u32>,
}

// Connection properties sent in the Identify payload
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConnectionProperties {
    /// Operation System (e.g., "Windows", "Linux", "macOS")
    #[serde(rename = "$os")]
    pub os: String,

    /// Browser (must be "Discord Selfbot" for selfbots)
    #[serde(rename = "$browser")]
    pub browser: String,

    /// Device (empty for desktops)
    #[serde(rename = "$device")]
    pub device: String,

    /// Sytem locale (e.g., "en-US")
    #[serde(rename = "$system_locale")]
    pub system_locale: String,

    /// Navigator version (e.g., "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
    #[serde(rename = "$browser_version")]
    pub browser_version: String,

    /// OS version (e.g., "10")
    #[serde(rename = "$os_version")]
    pub os_version: String,

    /// Referrer (empty for selfbots)
    #[serde(rename = "$referrer")]
    pub referrer: String,

    /// Referring domain (empty for selfbots)
    #[serde(rename = "$referring_domain")]
    pub referring_domain: String,

    /// Release channel (e.g., "stable")
    #[serde(rename = "$release_channel")]
    pub release_channel: String,

    /// Client build number (e.g., 9999)
    #[serde(rename = "$client_build_number")]
    pub client_build_number: u32,
}

impl ConnectionProperties {
    // Returning properties with default values (can be customized if needed)
    pub fn default_client() -> Self {
        Self {
            os: "Mac OS X".to_string(),
            browser: "Discord Client".to_string(),
            device: "".to_string(),
            system_locale: "en-US".to_string(),
            browser_version: "1.135.0".to_string(),
            os_version: "26.3.0".to_string(),
            referrer: "".to_string(),
            referring_domain: "".to_string(),
            release_channel: "stable".to_string(),
            client_build_number: 500334,
        }
    }
}

/// Presence update
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PresenceUpdate {
    /// Status (e.g., "online", "idle", "dnd", "invisible")
    pub status: String,

    /// Timestamps
    pub since: Option<u64>,

    /// Activities
    pub activities: Vec<Activity>,

    /// AFK status
    pub afk: bool,
}

impl Default for PresenceUpdate {
    fn default() -> Self {
        Self {
            status: "online".to_string(),
            since: None,
            activities: vec![],
            afk: false,
        }
    }
}

// Activtiy (playing, streaming, listening, watching)
#[derive(Debug, Clone, Serialize, Deserialize)]

pub struct Activity {
    // Name of the activity (e.g., "Spotify")
    pub name: String,

    // Type of activity (0 = playing, 1 = streaming, 2 = listening, 3 = watching)
    #[serde(rename = "type")]
    pub kind: u8,

    // URL for streaming (optional)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

impl Identify {
    pub fn new(token: impl Into<String>) -> Self {
        // Intents pour recevoir tous les messages:
        // GUILDS (1 << 0) = 1
        // GUILD_MEMBERS (1 << 1) = 2
        // GUILD_MESSAGES (1 << 9) = 512
        // GUILD_MESSAGE_REACTIONS (1 << 10) = 1024
        // DIRECT_MESSAGES (1 << 12) = 4096
        // DIRECT_MESSAGE_REACTIONS (1 << 13) = 8192
        // MESSAGE_CONTENT (1 << 15) = 32768
        // Total: 1 + 2 + 512 + 1024 + 4096 + 8192 + 32768 = 46595
        let intents = 3276799; // All intents (for maximum functionality, but can be customized if needed)

        Self {
            token: token.into(),
            properties: ConnectionProperties::default_client(),
            presence: Some(PresenceUpdate::default()),
            compress: Some(false),
            capabilities: 16381, // Standard capabilities for Discord clients
            intents: Some(intents),
        }
    }
}