Random "Unknown interaction" errors sometimes

[ikheetjeff]

Issue description

I have a bot with clicks on buttons every second and people executing commands. This generally goes very well, but sometimes I get an "Unknown Interaction" when I defer to it.

I've been debugging for the past three days and can't seem to understand why it's happening. My last possible explanation is an error in Discord.js or on the side of Discord.

I have attached a few screenshots describing the error

I would prefer to know if this is due to my code, or Discord.js or Discord itself.

Code sample

// Button Handler
        if(interaction.isButton()) {
            console.log(customId);
            const button = client.buttons.get(customId);
            if(!button) return;

            let {
                cooldown = -1,
                deferUpdate = false
            } = button;

            if(deferUpdate) {
                console.error('defer button');
                const testHook = interaction;
                console.error(interaction.member.user.username, interaction.member.id)
                await interaction.deferUpdate();
                console.error("doei", interaction.member.user.username, interaction.member.id)
                
            }
            
            let buttonName = (customId.startsWith('games-all-')) ? "btn-games-all" : "btn-" + customId;
            console.log(buttonName);
            if(!cooldownButtons.has(buttonName)) {
                console.log(buttonName, 'add cooldown')
                cooldownButtons.set(buttonName, new Collection());
            }

            const currentBtnTime = Date.now();
            const timestamps = await cooldownButtons.get(buttonName);
            const cooldownAmount = (cooldown) * 1000;

            if(timestamps.has(member.id)) {
                console.log(member.id, 'heeft cooldown')
                const expirationTime = timestamps.get(member.id) + cooldownAmount;

                if(currentBtnTime < expirationTime) {
                    console.log(member.id, 'heeft cooldown')
                    const time_left = (expirationTime - currentBtnTime) / 1000;

                    if(deferUpdate) {
                        return interaction.followUp({content: `**Cooldown:** You have to wait ${time_left.toFixed(1)} seconds.`, ephemeral: true});
                    }else{
                        return interaction.followUp({content: `**Cooldown:** You have to wait ${time_left.toFixed(1)} seconds.`, ephemeral: true});
                    }
                }
            }else{
                timestamps.set(member.id, currentBtnTime);
                setTimeout(() => timestamps.delete(member.id), cooldownAmount);

                try{
                    await button.execute(interaction);
                }catch(error) {
                    console.error(error);
                }
            }
        }

discord.js version

13.3.1

Node.js version

16.13.0

Operating system

Debian 10

Priority this issue should have

Medium (should be fixed soon)

Which partials do you have configured?

CHANNEL, GUILD_MEMBER, MESSAGE, REACTION

Which gateway intents are you subscribing to?

GUILDS, GUILD_MEMBERS, GUILD_INVITES, GUILD_VOICE_STATES, GUILD_MESSAGES, GUILD_MESSAGE_REACTIONS, DIRECT_MESSAGES

I have tested this issue on a development release

No response

[manuelvleeuwen]

Could you provide a minimal, reproducible code sample?

[ikheetjeff]

index.js

// Events Handler
const eventFiles = fs.readdirSync('./events').filter(file => file.endsWith('.js'));

for (const file of eventFiles) {
    let event = require(`./events/${file}`);
    if(event.once) {
        client.once(event.name, async (...args) => await event.execute(...args));
    }else{
        client.on(event.name, async (...args) => {
            if(event.name == "interactionCreate") console.error(event.name, 'called event!');
            event.execute(client, ...args);
        });        
    }
}

interactionCreate

const {creator} = require('../config.json');
const wait = require('util').promisify(setTimeout);
const { MessageEmbed, MessageActionRow, MessageButton, Collection } = require('discord.js');
let moment = require('moment');
let guildInfo = require('../app/modules/guildInfo.js');
let helper = require('../app/functions/helper.js');

let cooldownCommands = new Collection();
let cooldownButtons = new Collection();
let cooldownMenus = new Collection();

module.exports = {
    name: "interactionCreate",
    async execute(client, interaction) {
        console.error('interaction started!', interaction.member.id)
        let {message, member, channel, guild, commandName, customId} = interaction;
        if(channel.type == "DM") return interaction.reply({ content: 'Can\'t use commands here.', ephemeral: true});

        // Select Menu Handler
        if(interaction.isSelectMenu()) {
            console.log(customId);
            const menu = client.menus.get(customId);
            if(!menu) return console.log('menu not found');

            let {
                cooldown = -1,
                cooldownType = 1,
                deferReply = false,
                ephemeral = false,
            } = menu;

            if(deferReply) {
                console.error("defer menu")
                console.error(interaction.member.user.username, interaction.member.id)
                await interaction.deferUpdate({ ephemeral: ephemeral });
                console.error("doei", interaction.member.user.username, interaction.member.id)
            }

            let selectName = (cooldownType === 2 && interaction.values.length === 1) ? "slc-value-" + interaction.values[0] : "slc-" + customId;
            if(!cooldownMenus.has(selectName)) {
                cooldownMenus.set(selectName, new Collection());
            }

            const currentSelectTime = Date.now();
            const timestamps = cooldownMenus.get(selectName);
            const cooldownAmount = (cooldown) * 1000;

            await interaction.message.edit({components: interaction.message.components}).catch((err) => {});

            if(timestamps.has(member.id)) {
                const expirationTime = timestamps.get(member.id) + cooldownAmount;

                if(currentSelectTime < expirationTime) {
                    const time_left = (expirationTime - currentSelectTime) / 1000;

                    if(deferReply) return interaction.editReply({ content: `**Cooldown:** You have to wait ${time_left.toFixed(1)} seconds.`, ephemeral: true});
                    return interaction.reply({ content: `**Cooldown:** You have to wait ${time_left.toFixed(1)} seconds.`, ephemeral: true});
                }
            }

            timestamps.set(member.id, currentSelectTime);
            setTimeout(() => timestamps.delete(member.id), cooldownAmount);

            try{
                await menu.execute(interaction);
            }catch(error) {
                console.error(error);
            }
        }

        // Button Handler
        if(interaction.isButton()) {
            console.log(customId);
            const button = client.buttons.get(customId);
            if(!button) return;

            let {
                cooldown = -1,
                deferUpdate = false
            } = button;

            if(deferUpdate) {
                console.error('defer button');
                const testHook = interaction;
                console.error(interaction.member.user.username, interaction.member.id)
                await interaction.deferUpdate();
                console.error("doei", interaction.member.user.username, interaction.member.id)
                
            }
            
            let buttonName = (customId.startsWith('games-all-')) ? "btn-games-all" : "btn-" + customId;
            console.log(buttonName);
            if(!cooldownButtons.has(buttonName)) {
                console.log(buttonName, 'add cooldown')
                cooldownButtons.set(buttonName, new Collection());
            }

            const currentBtnTime = Date.now();
            const timestamps = await cooldownButtons.get(buttonName);
            const cooldownAmount = (cooldown) * 1000;

            if(timestamps.has(member.id)) {
                console.log(member.id, 'heeft cooldown')
                const expirationTime = timestamps.get(member.id) + cooldownAmount;

                if(currentBtnTime < expirationTime) {
                    console.log(member.id, 'heeft cooldown TEEEEEEEEST')
                    const time_left = (expirationTime - currentBtnTime) / 1000;

                    if(deferUpdate) {
                        return interaction.followUp({content: `**Cooldown:** You have to wait ${time_left.toFixed(1)} seconds.`, ephemeral: true});
                    }else{
                        return interaction.followUp({content: `**Cooldown:** You have to wait ${time_left.toFixed(1)} seconds.`, ephemeral: true});
                    }
                }
            }else{
                timestamps.set(member.id, currentBtnTime);
                setTimeout(() => timestamps.delete(member.id), cooldownAmount);

                try{
                    await button.execute(interaction);
                }catch(error) {
                    console.error(error);
                }
            }
        }

        // Command Handler
        if(interaction.isCommand()) {
            let command = interaction.client.commands.get(interaction.commandName);
            
            if(!command) return;

            let {
                data = null,
                maintenance = false,
                deferReply = false
            } = command;

            if(deferReply) {
                console.error('defer command');
                console.error(interaction.member.user.username, interaction.member.id)
                await interaction.deferReply();
                console.error("doei", interaction.member.user.username, interaction.member.id)
            }

            // Cooldown
            let cooldown = await guildInfo.cmdCooldown(guild, commandName).catch(console.error);
            cooldown = (cooldown == undefined) ? -1 : cooldown;

            //AllowedChannels
            let allowedChannels = await guildInfo.cmdAllowedChannels(guild, commandName).catch(console.error);

            //DeniedChannels
            let deniedChannels = await guildInfo.cmdDeniedChannels(guild, commandName).catch(console.error);

            // let deniedChannels= [];
            // let allowedChannels = [];
            // let cooldown = -1;
            
            if(allowedChannels.length) {
                if(typeof allowedChannels === "string") {
                    allowedChannels = [allowedChannels]
                }
            }
        
            if(deniedChannels.length) {
                if(typeof deniedChannels === "string") {
                    deniedChannels = [deniedChannels]
                }
            }

            if(maintenance && member.id !== creator['id']) return interaction.reply({content: 'This command is disabled.', ephemeral: true});
            if(!allowedChannels.some(r=> r.includes(interaction.channel.id)) && allowedChannels.length && !member.permissions.has('ADMINISTRATOR')) return interaction.reply({content: 'You may not use this here.', ephemeral: true});
	        if(deniedChannels.some(r=> r.includes(interaction.channel.id)) && !member.permissions.has('ADMINISTRATOR')) return interaction.reply({content: 'You may not use this here.', ephemeral: true});

            try{

                if(!cooldownCommands.has(commandName)) {
                    cooldownCommands.set(commandName, new Collection());
                }

                const currentTime = Date.now();
                const timestamps = cooldownCommands.get(commandName);
                const cooldownAmount = (cooldown) * 1000;

                if(timestamps.has(member.id)) {
                    const expirationTime = timestamps.get(member.id) + cooldownAmount;

                    if(currentTime < expirationTime) {
                        const time_left = (expirationTime - currentTime) / 1000;

                        if(deferReply) {
                            return interaction.editReply({content: `**Cooldown:** You have to wait ${time_left.toFixed(1)} seconds.`, ephemeral: true});
                        }else{
                            return interaction.reply({content: `**Cooldown:** You have to wait ${time_left.toFixed(1)} seconds.`, ephemeral: true});
                        }
                    }
                }

                timestamps.set(member.id, currentTime);
                setTimeout(() => timestamps.delete(member.id), cooldownAmount);

                const embed = new MessageEmbed()
                .setColor('#ED8223')
                .setDescription('👷 Deze command heb je in onderhoud-modus uitgevoerd.');

                if(maintenance && member.id === creator['id']) await interaction.channel.send({embeds: [embed], ephemeral: true});
                
                // Command uitvoert
                await command.execute(interaction);

            }catch(error) {
                console.error(error);
                if(deferReply) {
                    await interaction.editReply({content: 'Something went wrong during execution.', ephemeral: true});
                }else{
                    await interaction.reply({content: 'Something went wrong during execution.', ephemeral: true});
                }
            }
        }
    },
}

/buttons/rules-confirm.js (see screenshot under the code)

const { MessageEmbed, MessageActionRow, MessageButton, Permissions } = require('discord.js');
let guildInfo = require('../app/modules/guildInfo.js');
const con = require(`../app/functions/db`);
let invites = require('../app/modules/invites.js');

module.exports = {
    name: "rules-confirm",
    cooldown: 60,
    deferUpdate: true,
    async execute(interaction) {
        let { guild, member, channel} = interaction;

        try{
            let community = await guildInfo.roles(guild, "community").catch(console.error);
            
            if(community) {
                await member.roles.add(community).catch((err) => channel.send(`Oops! I can't give ${member.toString()} a role! <@300319943793311744> ${err}`));

                await invites.verify(interaction);
            }
        }catch(err) {
            console.error(err);
        }
    }
}

It happens most often when deferring this button. But sometimes it happens to a command. It can really go well for a few hours, and then get a bunch of errors in a row.

The bot is in a very busy server with multiple clicks every second. So if you want to test something in that server or want to watch it, you can. Please feel free to let me know what I can do for you.

[imranbarbhuiya]

Same happening for me.
Its showing interaction failed to the user and throwing error of Unknown interaction.
I tried with deferring before responding, but it's then showing the interaction isn't deferred or replied even when I deferred also in discord it's showing bot is thinking still I'm getting this error.

[DTrombett]

You need to await your defer

[imranbarbhuiya]

Oh sorry, my bad. Thank you.

[philipaarseth]

Same thing happened to me. Suddenly getting errors (though everything was working fine still).

It's not the 3 second rule, I checked and responses was always <1s.

According to the discord.js guide, deferring is something you'd use if you expect 3+ sec answers, but I tried it anyway and no more errors 🤷🏼‍♂️.

[ikheetjeff]

The point is: I get an Unknown Interaction very often when I want to defer an interaction (<2 seconds).
I even upgraded my server and checked my firewall to see if there is anything with connections. But it remains.

24-11 02:33:07.360: 906848354590400563 aW50ZXJhY3Rpb246OTEyODc4NDU0NzcxNDMzNDgyOnJtZ0FPUEJhaEttdjF6dUJ2TDllRkNWMkpGZmpZNFAyT0sxOTBGREVXQ1lrT2d0S3Y2T0F0cEVVQWtzOTB0cjhxZ2pWR2JtcjJKY1JNTUtJRVgwdTBNWGswclR6dW5LSElRd0o5RnoxTGlKdG8wdHFHbXZsMmlDM1FrS3MwcmlV
24-11 02:33:07.859: DiscordAPIError: Unknown interaction
24-11 02:33:07.859:     at RequestHandler.execute (/home/discord/Bull/node_modules/discord.js/src/rest/RequestHandler.js:349:13)
24-11 02:33:07.859:     at runMicrotasks (<anonymous>)
24-11 02:33:07.859:     at processTicksAndRejections (node:internal/process/task_queues:96:5)
24-11 02:33:07.859:     at async RequestHandler.push (/home/discord/Bull/node_modules/discord.js/src/rest/RequestHandler.js:50:14)
24-11 02:33:07.859:     at async ButtonInteraction.reply (/home/discord/Bull/node_modules/discord.js/src/structures/interfaces/InteractionResponses.js:98:5)
24-11 02:33:07.859:     at async Object.execute (/home/discord/Bull/buttons/rules-confirm.js:21:17)
24-11 02:33:07.859:     at async Object.execute (/home/discord/Bull/events/interactionCreate.js:121:21) {
24-11 02:33:07.859:   method: 'post',
24-11 02:33:07.859:   path: '/interactions/912878454771433482/aW50ZXJhY3Rpb246OTEyODc4NDU0NzcxNDMzNDgyOnJtZ0FPUEJhaEttdjF6dUJ2TDllRkNWMkpGZmpZNFAyT0sxOTBGREVXQ1lrT2d0S3Y2T0F0cEVVQWtzOTB0cjhxZ2pWR2JtcjJKY1JNTUtJRVgwdTBNWGswclR6dW5LSElRd0o5RnoxTGlKdG8wdHFHbXZsMmlDM1FrS3MwcmlV/callback',
24-11 02:33:07.859:   code: 10062,
24-11 02:33:07.859:   httpStatus: 404,
24-11 02:33:07.859:   requestData: { json: { type: 4, data: [Object] }, files: [] }
24-11 02:33:07.859: }

Or:

24-11 02:35:27.329: 900609711169208322 aW50ZXJhY3Rpb246OTEyODc5MDU1MDQ3NjIyNjg2OllTc09wT21ObUVsSERuV244TTNFMUZIaExGUVVLdzBqSmpmQlBybDJTZlFtd0J0cG5JV21QZWd4TG9qcDZxMmVsYUFjN215VG5Jd3g4QUxwc3RWcDRoSlNnRzIxaXcxdzZDN0d3UEtCVlpJYW9IRTNvdFNtRlVYemFGa0JoM0pF
24-11 02:35:27.330: defer command invites
24-11 02:35:27.330: Spodermannnnn 900609711169208322
24-11 02:35:30.635: 912278128007720982 aW50ZXJhY3Rpb246OTEyODc5MDY4ODU5NDk4NTE2OmRDVjhzYW9oQmZ3cFJlVFI4ajNxQTM2TEdvTTJNRThmMlNtT0p1bWxBUnA3ZWRZdmVGd0JmZHZ1THlqY2pWdnI4QVFkaUVqUWsxMkl0U1pCNGRkMGFBMktKYnBOZ2R5UmxveEdidFphZVlma3Y4T2RQcGt6bmNEWVFyaWxqcTEz
24-11 02:35:32.985: 905646164202901565 aW50ZXJhY3Rpb246OTEyODc5MDc4Mzk3MzE3MTQxOkh0UWpJUE5GcTViQkRzSXFJVjAwenZHelY2Unc1ZXYwdTExUWpqeGJidGJ5Y215T2piQ2Z0S3RGMEpacFBHeDh1aXNsT2NBNjRHR2pJTllSRGg5Nk1QczRBV1ZadE00SmJET3RLY3NvakUxbFRpUTk4dnFDOW54OHN3TEdBMlBv
24-11 02:35:37.804: DiscordAPIError: Unknown interaction
24-11 02:35:37.804:     at RequestHandler.execute (/home/discord/Bull/node_modules/discord.js/src/rest/RequestHandler.js:349:13)
24-11 02:35:37.804:     at runMicrotasks (<anonymous>)
24-11 02:35:37.804:     at processTicksAndRejections (node:internal/process/task_queues:96:5)
24-11 02:35:37.804:     at async RequestHandler.push (/home/discord/Bull/node_modules/discord.js/src/rest/RequestHandler.js:50:14)
24-11 02:35:37.804:     at async CommandInteraction.deferReply (/home/discord/Bull/node_modules/discord.js/src/structures/interfaces/InteractionResponses.js:57:5)
24-11 02:35:37.804:     at async Object.execute (/home/discord/Bull/events/interactionCreate.js:143:17) {
24-11 02:35:37.804:   method: 'post',
24-11 02:35:37.804:   path: '/interactions/912879055047622686/aW50ZXJhY3Rpb246OTEyODc5MDU1MDQ3NjIyNjg2OllTc09wT21ObUVsSERuV244TTNFMUZIaExGUVVLdzBqSmpmQlBybDJTZlFtd0J0cG5JV21QZWd4TG9qcDZxMmVsYUFjN215VG5Jd3g4QUxwc3RWcDRoSlNnRzIxaXcxdzZDN0d3UEtCVlpJYW9IRTNvdFNtRlVYemFGa0JoM0pF/callback',
24-11 02:35:37.804:   code: 10062,
24-11 02:35:37.804:   httpStatus: 404,
24-11 02:35:37.804:   requestData: { json: { type: 5, data: [Object] }, files: [] }
24-11 02:35:37.804: }

[Jiralite]

I'd like to voice that I'm not hitting these issues at all. My slash commands utilise both deferring and not deferring on 13.3.1. If this is an actual issue, I would have thought this would have more activity, right? This is a very core concept.

By the way, a minimal reproduction sample doesn't mean copying and pasting your entire file. A minimal reproduction sample means supplying the bare minimum code that you can reproduce the issue with. For example:

const { Client } = require("discord.js");

const client = new Client({
  intents: []
});

client.once("ready", async () => {
  // Create the command
  client.application.commands.create({
    name: "test",
    description: "test"
  }, "guild_id");
});

client.on("interactionCreate", async interaction => {
  await interaction.deferReply();
  interaction.editReply("Hello!");
});

client.login("token");

This seems to be the basis of your issue where sometimes awaiting the .deferReply() would error. I have spammed this command to no avail so I'm not able to reproduce this in testing or production. I'm not sure how to remedy this for you other than suggest it may be your own code?

[ikheetjeff]

This seems to be the basis of your issue where sometimes awaiting the .deferReply() would error. I have spammed this command to no avail so I'm not able to reproduce this in testing or production. I'm not sure how to remedy this for you other than suggest it may be your own code?

Thank you for your response and thoughtfulness. I currently have 6 different bots on my linux server. All bots are used sometimes, but the bot where I have this issue is used every second. Then again it is very random when this happens. Sometimes it doesn't happen for a while, sometimes a few times in a row.

I don't have it with all my other bots with the same code. Just because it is so unexpected, I wanted to send exactly my code to possibly see where the issue might be.

I'm trying to ask big bots that use buttons as well, but haven't gotten a response to this yet. I'd just like to know if it's because of me or Discord.

Should anyone want to watch live with me via screen share via Discord, they can. Then you can also see the problem immediately. @Jiralite @thehackerboi69github

[applebee1558]

Does your Linux server by any chance have its cpu a bit overloaded with all the bots that it isn’t able to quickly decode every payload and send a request in time?

In addition, are you frequently changing the status of your bot? It’s more noticeable with bigger bots as the gateway delays all events until it publishes your presence to every guild.

[ikheetjeff]

Does your Linux server by any chance have its cpu a bit overloaded with all the bots that it isn’t able to quickly decode every payload and send a request in time?

In addition, are you frequently changing the status of your bot? It’s more noticeable with bigger bots as the gateway delays all events until it publishes your presence to every guild.

I don't update my status of my bot, except the activity I update every day.

I also doubt if it is due to the server. That's why I increased it in capacity. No difference yet. I'm going to try another hosting now, see if that makes a difference.