repository·master·Indexed 20 days ago
https://github.com/disgoorg/disgoA Go library for interacting with the Discord API. It provides a high-level Client for managing REST, Gateway/Sharding, and HTTP servers, as well as specialized modules for OAuth2 and Webhooks. The library includes a voice package supporting End-to-End Encryption (E2EE) via DAVE, with both GoDave (CGO) and Dave-Go (Pure Go) implementations.
You can configure disgo to route its communication through external proxies, such as gateway-proxy or http-proxy. This is achieved by setting specific environment variables that redirect the gateway (WebSocket) and REST (HTTP) traffic to your proxy URLs instead of the default Discord endpoints.
disgo_gateway_url=ws://gateway-proxy:7878
disgo_rest_url=http://rest-proxy:7979/api/v10To use the GoDave CGO binding for DAVE (End-to-End Encryption) in your project, install the golibdave package using go get.
go get github.com/disgoorg/godave/golibdaveThe webhook.New function accepts variadic webhook.ConfigOpt arguments to customize the client. You can provide a custom logger or set default allowed mentions for all messages sent by this client.
client := webhook.New(snowflake.ID("webhookID"), "webhookToken",
webhook.WithLogger(logrus.New()),
webhook.WithDefaultAllowedMentions(discord.AllowedMentions{
RepliedUser: false,
}),
)To use the experimental pure Go implementation of DAVE (End-to-End Encryption), install the dave-go package.
go get github.com/thomas-vilte/dave-goTo use webhooks in disgo, import the webhook package. You can initialize a WebhookClient using either a specific webhook_id and webhook_token or via a direct webhookURL.
Note: The WebhookClient should be created once and reused, as it holds important state.
import "github.com/disgoorg/disgo/webhook"
// Using ID and Token
client := webhook.New(snowflake.ID("webhookID"), "webhookToken")
// Using Webhook URL
client, err := webhook.NewWithURL("webhookURL")The oauth2 module allows you to authenticate users with Discord on your website. To use it, you must first configure an application in the Discord Developer Portal:
client ID and client secret.redirect URL in your Discord application settings.This example demonstrates how to integrate disgo with DAVE (Discord's End-to-End Encryption) for handling voice channels.
Important: Before attempting to run voice-related examples, you must ensure that the underlying DAVE dependencies are installed on your system. Refer to the libdave installation instructions for the required setup.
By default, httpserver uses crypto/ed25519 for signing verification. If you require a different implementation (for example, a faster one like github.com/oasisprotocol/curve25519-voi), you can override the global Verify function in the httpserver package.
To do this, assign a function to httpserver.Verify that matches the signature: func(publicKey PublicKey, message, sig []byte) bool.
package main
import (
"github.com/oasisprotocol/curve25519-voi/primitives/ed25519"
"github.com/disgoorg/disgo/httpserver"
)
func main() {
// Override the default ed25519 verification with a custom implementation
httpserver.Verify = func(publicKey httpserver.PublicKey, message, sig []byte) bool {
return ed25519.Verify(publicKey, message, sig)
}
}To send audio in a Discord voice channel using bot.Client, you must:
gateway.IntentGuildVoiceStates intent.VoiceManager with a DAVE session creation function (either golibdave.NewSession for GoDave or session.NewSession for Dave-Go).client.VoiceManager().CreateConn(guildID).conn.Open.conn.UDP().Write(frame) to send Opus frames.const (
guildID = 12345
channelID = 12345
)
client, err := disgo.New(token,
bot.WithGatewayConfigOpts(gateway.WithIntents(gateway.IntentGuildVoiceStates)),
bot.WithVoiceManagerConfigOpts(
// for GoDave use this
voice.WithDaveSessionCreateFunc(golibdave.NewSession),
// for Dave-Go use this
// voice.WithDaveSessionCreateFunc(session.NewSession),
),
)
// handle err
conn := client.VoiceManager().CreateConn(guildID)
err = conn.Open(context.TODO(), channelID, false, false)
// handle err
// set speaking flag
err = conn.SetSpeaking(ctx, voice.SpeakingFlagMicrophone)
// send opus frame
conn.UDP().Write(frame)
// close connection
conn.Close()Existing messages can be updated using the following methods. All methods require the message_id as a string:
UpdateContent: Updates only the text content of the message.UpdateEmbeds: Updates only the embeds of the message.UpdateMessage: The flexible method. It accepts a discord.NewWebhookMessageUpdate() builder or a webhook.WebhookMessageUpdate struct, along with rest.UpdateWebhookMessageParams.client := webhook.New(snowflake.ID("webhookID"), "webhookToken")
// Update text
message, err := client.UpdateContent("870741249114652722", "hello world!")
// Update embeds
message, err := client.UpdateEmbeds("870741249114652722", discord.NewEmbed().
WithDescription("hello world!"),
)
// Using the builder pattern
message, err := client.UpdateMessage("870741249114652722", discord.NewWebhookMessageUpdate().
WithContent("hello world!"),
rest.UpdateWebhookMessageParams{},
)
// Using a struct
message, err := client.UpdateMessage("870741249114652722", webhook.WebhookMessageUpdate{
Content: json.Ptr("hello world!"),
}, rest.UpdateWebhookMessageParams{})You can send messages using several methods depending on the level of control required:
CreateContent: A simple way to send plain text content.CreateEmbeds: Used to send messages containing only embeds.CreateMessage: The most flexible method. It accepts a discord.NewWebhookMessageCreate() builder or a webhook.WebhookMessageCreate struct, along with rest.CreateWebhookMessageParams for advanced configuration.client := webhook.New(snowflake.ID("webhookID"), "webhookToken")
// Simple text
message, err := client.CreateContent("hello world!")
// Using embeds
message, err := client.CreateEmbeds(discord.NewEmbed().
WithDescription("hello world!"),
)
// Using the builder pattern
message, err := client.CreateMessage(discord.NewWebhookMessageCreate().
WithContent("hello world!"),
rest.CreateWebhookMessageParams{},
)
// Using a struct
message, err := client.CreateMessage(webhook.WebhookMessageCreate{
Content: "hello world!",
}, rest.CreateWebhookMessageParams{})To remove a message sent by the webhook, use the DeleteMessage method with the message ID.
client := webhook.New(snowflake.ID("webhookID"), "webhookToken")
err := client.DeleteMessage("message_id")