Upped version to 4.2.15

added redis as optional to install in windows guide docs

See merge request Kwoth/nadekobot!258

.gitlab-ci.yml

@@ -113,6 +113,7 @@ docker-build:
   # Use the official docker image.
   image: docker:latest
   stage: build
+  allow_failure: true
   services:
     - docker:dind
   before_script:

CHANGELOG.md

@@ -1,8 +1,108 @@
-
 # Changelog
 
 Experimental changelog. Mostly based on [keepachangelog](https://keepachangelog.com/en/1.0.0/) except date format. a-c-f-r-o
 
+## [4.2.15] - 12.07.2022
+
+### Fixed
+
+- Fixed `.nh*ntai` nsfw command
+- Xp Freezes may have been fixed
+- `data/images.yml` should once again support local file paths
+- Fixed multiword aliases
+
+## [4.2.14] - 03.07.2022
+
+### Added
+
+- Added `.log userwarned` (Logging user warnings)
+- Claiming `.timely` will now show a button which you can click to set a reminder
+- Added `%server.icon%` placeholder
+- Added `warn` punishment action for protection commands (it won't work with `.warnp`)
+
+### Changed
+
+- `.log userbanned` will now have a ban reason
+- When `.die` is used, bot will try to update it's status to `Invisible`
+
+### Fixed
+
+- Fixed elipsis character issue with aliases/quotes. You should now be able to set an elipsis to be an alias of `.quoteprint`
+
+## [4.2.13] - 30.06.2022
+
+### Fixed
+
+- Fixed `.cash` bank interaction not being ephemeral anymore
+
+## [4.2.12] - 30.06.2022
+
+### Fixed
+
+- Fixed `.trivia --pokemon` showing incorrect pokemons
+
+## [4.2.11] - 29.06.2022
+
+### Fixed
+
+- Fixed `.draw` command 
+
+## [4.2.10] - 29.06.2022
+
+- Fixed currency generation working only once
+
+## [4.2.9] - 25.06.2022
+  
+### Fixed
+
+- Fixed `creds_example.yml` misssing from output directory
+
+## [4.2.8] - 24.06.2022
+
+### Fixed
+
+- `.timely` should be fixed
+
+## [4.2.7] - 24.06.2022
+
+### Changed
+
+- New cache abstraction added
+  - 2 implemenations: redis and memory
+  - All current bots will stay on redis cache, all new bots will use **in-process memory cache by default**
+  - This change removes bot's hard dependency on redis
+  - Configurable in `creds.yml` (please read the comments)
+  - You **MUST** use 'redis' if your bot runs on more than 1 shard (2000+ servers)
+- [dev] Using new non-locking ConcurrentDictionary
+
+### Fixed
+
+- `.xp` will now show default user avatars too
+
+### Removed
+
+- Removed `.imagesreload` as images are now lazily loaded on request and then cached
+
+## [4.2.6] - 22.06.2022
+
+### Fixed
+
+- Patron system should now properly by disabled on selfhosts by default.
+
+## [4.2.5] - 18.06.2022
+
+### Fixed
+
+- Fixed `.crypto`, you will still need coinmarketcapApiKey in `creds.yml` in order to make it run consistently as the key is shared
+
+## [4.2.3] - 17.06.2022
+
+### Fixed
+
+- Fixed `.timely` nullref bug and made it nicer
+- Fixed `.streamrole` not updating in real time!
+- Disabling specific Global Expressions should now work with `.sc` (and other permission commands)
+
 ## [4.2.2] - 15.06.2022
 
 ### Fixed

docs/guides/windows-guide.md

@@ -31,7 +31,8 @@
  ![Create a new bot](https://i.imgur.com/JxtRk9e.png "Create a new bot")
 - Click on **`DOWNLOAD`** at the lower right
  ![Bot Setup](https://i.imgur.com/HqAl36p.png "Bot Setup")
-- Click on **`Install`** next to **`Redis`**.
+- Click on **`Install`** next to **`Redis`**. 
+- **(Note: Redis is optional unless you are are using the bot on 2000+ servers)**
 - Note: If Redis fails to install, install Redis manually here: [Redis Installer](https://github.com/MicrosoftArchive/redis/releases/tag/win-3.0.504) Download and run the **`.msi`** file.
 - If you will use the music module, click on **`Install`** next to **`FFMPEG`** and **`Youtube-DL`**.
 - If any dependencies fail to install, you can temporarily disable your Windows Defender/AV until you install them. If you don't want to, then read [the last section of this guide](#Manual-Prerequisite-Installation).

src/NadekoBot.Generators/Command/CommandAttributesGenerator.cs

@@ -64,7 +64,9 @@ public class CmdAttribute : System.Attribute
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
 // #if DEBUG
-//         SpinWait.SpinUntil(() => Debugger.IsAttached);
+//         if (!Debugger.IsAttached)
+//             Debugger.Launch();
+//         // SpinWait.SpinUntil(() => Debugger.IsAttached);
 // #endif
         context.RegisterPostInitializationOutput(static ctx => ctx.AddSource(
             "CmdAttribute.g.cs",
@@ -157,7 +159,9 @@ public class CmdAttribute : System.Attribute
             .Distinct();
         
         var methodModels = methods
-            .Select(x => MethodDeclarationToMethodModel(compilation, x!));
+            .Select(x => MethodDeclarationToMethodModel(compilation, x!))
+            .Where(static x => x is not null)
+            .Cast<MethodModel>();
 
         var groups = methodModels
             .GroupBy(static x => $"{x.Namespace}.{string.Join(".", x.Classes)}");
@@ -177,7 +181,7 @@ public class CmdAttribute : System.Attribute
             var model = new FileModel(
                 methods: elems,
                 ns: elems[0].Namespace,
-                classHierarchy: elems[0].Classes
+                classHierarchy: elems![0].Classes
             );
             
             models.Add(model);
@@ -187,11 +191,21 @@ public class CmdAttribute : System.Attribute
         return models;
     }
 
-    private static MethodModel MethodDeclarationToMethodModel(Compilation comp, MethodDeclarationSyntax decl)
+    private static MethodModel? MethodDeclarationToMethodModel(Compilation comp, MethodDeclarationSyntax decl)
     {
         // SpinWait.SpinUntil(static () => Debugger.IsAttached);
 
-        var semanticModel = comp.GetSemanticModel(decl.SyntaxTree);
+        SemanticModel semanticModel;
+        try
+        {
+            semanticModel = comp.GetSemanticModel(decl.SyntaxTree);
+        }
+        catch
+        {
+            // for some reason this method can throw "Not part of this compilation" argument exception
+            return null;
+        }
+
         var methodModel = new MethodModel(
             @params: decl.ParameterList.Parameters
                 .Where(p => p.Type is not null)

src/NadekoBot.Tests/BotStringsTests.cs

@@ -21,7 +21,7 @@ namespace NadekoBot.Tests
             var stringsSource = new LocalFileStringsSource(
                 responsesPath,
                 commandsPath);
-            var strings = new LocalBotStringsProvider(stringsSource);
+            var strings = new MemoryBotStringsProvider(stringsSource);
 
             var culture = new CultureInfo("en-US");
 

src/NadekoBot.Tests/ConcurrentHashSetTests.cs

@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace NadekoBot.Tests;
+
+public class ConcurrentHashSetTests
+{
+    private ConcurrentHashSet<(int?, int?)> _set;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _set = new();
+    }
+
+    [Test]
+    public void AddTest()
+    {
+        var result = _set.Add((1, 2));
+        
+        Assert.AreEqual(true, result);
+        
+        result = _set.Add((1, 2));
+        
+        Assert.AreEqual(false, result);
+    }
+
+    [Test]
+    public void TryRemoveTest()
+    {
+        _set.Add((1, 2));
+        var result = _set.TryRemove((1, 2));
+        
+        Assert.AreEqual(true, result);
+        
+        result = _set.TryRemove((1, 2));
+        Assert.AreEqual(false, result);
+    }
+
+    [Test]
+    public void CountTest()
+    {
+        _set.Add((1, 2)); // 1
+        _set.Add((1, 2)); // 1
+        
+        _set.Add((2, 2)); // 2
+        
+        _set.Add((3, 2)); // 3
+        _set.Add((3, 2)); // 3
+        
+        Assert.AreEqual(3, _set.Count);
+    }
+
+    [Test]
+    public void ClearTest()
+    {
+        _set.Add((1, 2));
+        _set.Add((1, 3));
+        _set.Add((1, 4));
+        
+        _set.Clear();
+        
+        Assert.AreEqual(0, _set.Count);
+    }
+
+    [Test]
+    public void ContainsTest()
+    {
+        _set.Add((1, 2));
+        _set.Add((3, 2));
+        
+        Assert.AreEqual(true, _set.Contains((1, 2)));
+        Assert.AreEqual(true, _set.Contains((3, 2)));
+        Assert.AreEqual(false, _set.Contains((2, 1)));
+        Assert.AreEqual(false, _set.Contains((2, 3)));
+    }
+
+    [Test]
+    public void RemoveWhereTest()
+    {
+        _set.Add((1, 2));
+        _set.Add((1, 3));
+        _set.Add((1, 4));
+        _set.Add((2, 5));
+        
+        // remove tuples which have even second item
+        _set.RemoveWhere(static x => x.Item2 % 2 == 0);
+        
+        Assert.AreEqual(2, _set.Count);
+        Assert.AreEqual(true, _set.Contains((1, 3)));
+        Assert.AreEqual(true, _set.Contains((2, 5)));
+    }
+}

src/NadekoBot/Bot.cs

@@ -70,6 +70,7 @@ public sealed class Bot
                 : GatewayIntents.AllUnprivileged,
             LogGatewayIntentWarnings = false,
             FormatUsersInBidirectionalUnicode = false,
+            DefaultRetryMode = RetryMode.AlwaysRetry ^ RetryMode.RetryRatelimit
         });
 
         _commandService = new(new()
@@ -102,20 +103,20 @@ public sealed class Bot
         var svcs = new ServiceCollection().AddTransient(_ => _credsProvider.GetCreds()) // bot creds
                                           .AddSingleton(_credsProvider)
                                           .AddSingleton(_db) // database
-                                          .AddRedis(_creds.RedisOptions) // redis
                                           .AddSingleton(Client) // discord socket client
                                           .AddSingleton(_commandService)
                                           // .AddSingleton(_interactionService)
                                           .AddSingleton(this)
                                           .AddSingleton<ISeria, JsonSeria>()
-                                          .AddSingleton<IPubSub, RedisPubSub>()
                                           .AddSingleton<IConfigSeria, YamlSeria>()
-                                          .AddBotStringsServices(_creds.TotalShards)
                                           .AddConfigServices()
                                           .AddConfigMigrators()
                                           .AddMemoryCache()
                                           // music
-                                          .AddMusic();
+                                          .AddMusic()
+                                          // cache
+                                          .AddCache(_creds);
+        
         // admin
 #if GLOBAL_NADEKO
         svcs.AddSingleton<ILogCommandService, DummyLogCommandService>();
@@ -143,13 +144,6 @@ public sealed class Bot
                 .AddSingleton<IReadyExecutor>(x => x.GetRequiredService<RemoteGrpcCoordinator>());
         }
 
-        svcs.AddSingleton<RedisLocalDataCache>()
-            .AddSingleton<ILocalDataCache>(x => x.GetRequiredService<RedisLocalDataCache>())
-            .AddSingleton<RedisImagesCache>()
-            .AddSingleton<IImageCache>(x => x.GetRequiredService<RedisImagesCache>())
-            .AddSingleton<IReadyExecutor>(x => x.GetRequiredService<RedisImagesCache>())
-            .AddSingleton<IDataCache, RedisCache>();
-
         svcs.Scan(scan => scan.FromAssemblyOf<IReadyExecutor>()
                               .AddClasses(classes => classes.AssignableToAny(
                                       // services
@@ -267,6 +261,7 @@ public sealed class Bot
         Client.JoinedGuild += Client_JoinedGuild;
         Client.LeftGuild += Client_LeftGuild;
 
+        // _ = Client.SetStatusAsync(UserStatus.Online);
         Log.Information("Shard {ShardId} logged in", Client.ShardId);
     }
 

src/NadekoBot/Common/Attributes/Ratelimit.cs

@@ -15,22 +15,24 @@ public sealed class RatelimitAttribute : PreconditionAttribute
         Seconds = seconds;
     }
 
-    public override Task<PreconditionResult> CheckPermissionsAsync(
+    public override async Task<PreconditionResult> CheckPermissionsAsync(
         ICommandContext context,
         CommandInfo command,
         IServiceProvider services)
     {
         if (Seconds == 0)
-            return Task.FromResult(PreconditionResult.FromSuccess());
+            return PreconditionResult.FromSuccess();
 
-        var cache = services.GetRequiredService<IDataCache>();
-        var rem = cache.TryAddRatelimit(context.User.Id, command.Name, Seconds);
+        var cache = services.GetRequiredService<IBotCache>();
+        var rem = await cache.GetRatelimitAsync(
+            new($"precondition:{context.User.Id}:{command.Name}"),
+            Seconds.Seconds());
 
         if (rem is null)
-            return Task.FromResult(PreconditionResult.FromSuccess());
+            return PreconditionResult.FromSuccess();
 
         var msgContent = $"You can use this command again in {rem.Value.TotalSeconds:F1}s.";
 
-        return Task.FromResult(PreconditionResult.FromError(msgContent));
+        return PreconditionResult.FromError(msgContent);
     }
 }

src/NadekoBot/Common/Cache/BotCacheExtensions.cs

@@ -0,0 +1,46 @@
+using OneOf;
+using OneOf.Types;
+
+namespace NadekoBot.Common;
+
+public static class BotCacheExtensions
+{
+    public static async ValueTask<T?> GetOrDefaultAsync<T>(this IBotCache cache, TypedKey<T> key)
+    {
+        var result = await cache.GetAsync(key);
+        if (result.TryGetValue(out var val))
+            return val;
+
+        return default;
+    }
+    
+    private static TypedKey<byte[]> GetImgKey(Uri uri)
+        => new($"image:{uri}");
+
+    public static ValueTask SetImageDataAsync(this IBotCache c, string key, byte[] data)
+        => c.SetImageDataAsync(new Uri(key), data);
+    public static async ValueTask SetImageDataAsync(this IBotCache c, Uri key, byte[] data)
+        => await c.AddAsync(GetImgKey(key), data, expiry: TimeSpan.FromHours(48));
+
+    public static async ValueTask<OneOf<byte[], None>> GetImageDataAsync(this IBotCache c, Uri key)
+        => await c.GetAsync(GetImgKey(key));
+
+    public static async Task<TimeSpan?> GetRatelimitAsync(
+        this IBotCache c,
+        TypedKey<long> key,
+        TimeSpan length)
+    {
+        var now = DateTime.UtcNow;
+        var nowB = now.ToBinary();
+
+        var cachedValue = await c.GetOrAddAsync(key,
+            () => Task.FromResult(now.ToBinary()),
+            expiry: length);
+
+        if (cachedValue == nowB)
+            return null;
+
+        var diff = now - DateTime.FromBinary(cachedValue);
+        return length - diff;
+    }
+}

src/NadekoBot/Common/Cache/IBotCache.cs

@@ -0,0 +1,47 @@
+using OneOf;
+using OneOf.Types;
+
+namespace NadekoBot.Common;
+
+public interface IBotCache
+{
+    /// <summary>
+    /// Adds an item to the cache
+    /// </summary>
+    /// <param name="key">Key to add</param>
+    /// <param name="value">Value to add to the cache</param>
+    /// <param name="expiry">Optional expiry</param>
+    /// <param name="overwrite">Whether old value should be overwritten</param>
+    /// <typeparam name="T">Type of the value</typeparam>
+    /// <returns>Returns whether add was sucessful. Always true unless ovewrite = false</returns>
+    ValueTask<bool> AddAsync<T>(TypedKey<T> key, T value, TimeSpan? expiry = null, bool overwrite = true);
+    
+    /// <summary>
+    /// Get an element from the cache
+    /// </summary>
+    /// <param name="key">Key</param>
+    /// <typeparam name="T">Type of the value</typeparam>
+    /// <returns>Either a value or <see cref="None"/></returns>
+    ValueTask<OneOf<T, None>> GetAsync<T>(TypedKey<T> key);
+    
+    /// <summary>
+    /// Remove a key from the cache
+    /// </summary>
+    /// <param name="key">Key to remove</param>
+    /// <typeparam name="T">Type of the value</typeparam>
+    /// <returns>Whether there was item</returns>
+    ValueTask<bool> RemoveAsync<T>(TypedKey<T> key);
+
+    /// <summary>
+    /// Get the key if it exists or add a new one
+    /// </summary>
+    /// <param name="key">Key to get and potentially add</param>
+    /// <param name="createFactory">Value creation factory</param>
+    /// <param name="expiry">Optional expiry</param>
+    /// <typeparam name="T">Type of the value</typeparam>
+    /// <returns>The retrieved or newly added value</returns>
+    ValueTask<T?> GetOrAddAsync<T>(
+        TypedKey<T> key,
+        Func<Task<T?>> createFactory,
+        TimeSpan? expiry = null);
+}

src/NadekoBot/Common/Cache/MemoryBotCache.cs

@@ -0,0 +1,71 @@
+using Microsoft.Extensions.Caching.Memory;
+using OneOf;
+using OneOf.Types;
+
+// ReSharper disable InconsistentlySynchronizedField
+
+namespace NadekoBot.Common;
+
+public sealed class MemoryBotCache : IBotCache
+{
+    // needed for overwrites and Delete return value
+    private readonly object _cacheLock = new object();
+    private readonly MemoryCache _cache;
+
+    public MemoryBotCache()
+    {
+        _cache = new MemoryCache(new MemoryCacheOptions());
+    }
+
+    public ValueTask<bool> AddAsync<T>(TypedKey<T> key, T value, TimeSpan? expiry = null, bool overwrite = true)
+    {
+        if (overwrite)
+        {
+            using var item = _cache.CreateEntry(key.Key);
+            item.Value = value;
+            item.AbsoluteExpirationRelativeToNow = expiry;
+            return new(true);
+        }
+        
+        lock (_cacheLock)
+        {
+            if (_cache.TryGetValue(key.Key, out var old) && old is not null)
+                return new(false);
+            
+            using var item = _cache.CreateEntry(key.Key);
+            item.Value = value;
+            item.AbsoluteExpirationRelativeToNow = expiry;
+            return new(true);
+        }
+    }
+
+    public async ValueTask<T?> GetOrAddAsync<T>(
+        TypedKey<T> key,
+        Func<Task<T?>> createFactory,
+        TimeSpan? expiry = null)
+        => await _cache.GetOrCreateAsync(key.Key,
+            async ce =>
+            {
+                ce.AbsoluteExpirationRelativeToNow = expiry;
+                var val = await createFactory();
+                return val;
+            });
+
+    public ValueTask<OneOf<T, None>> GetAsync<T>(TypedKey<T> key)
+    {
+        if (!_cache.TryGetValue(key.Key, out var val) || val is null)
+            return new(new None());
+
+        return new((T)val);
+    }
+
+    public ValueTask<bool> RemoveAsync<T>(TypedKey<T> key)
+    {
+        lock (_cacheLock)
+        {
+            var toReturn = _cache.TryGetValue(key.Key, out var old ) && old is not null;
+            _cache.Remove(key.Key);
+            return new(toReturn);
+        }
+    }
+}

src/NadekoBot/Common/Cache/RedisBotCache.cs

@@ -0,0 +1,119 @@
+using OneOf;
+using OneOf.Types;
+using StackExchange.Redis;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NadekoBot.Common;
+
+public sealed class RedisBotCache : IBotCache
+{
+    private static readonly Type[] _supportedTypes = new []
+    {
+        typeof(bool), typeof(int), typeof(uint), typeof(long),
+        typeof(ulong), typeof(float), typeof(double),
+        typeof(string), typeof(byte[]), typeof(ReadOnlyMemory<byte>), typeof(Memory<byte>),
+        typeof(RedisValue),
+    };
+
+    private static readonly JsonSerializerOptions _opts = new()
+    {
+        PropertyNameCaseInsensitive = true,
+        NumberHandling = JsonNumberHandling.AllowReadingFromString,
+        AllowTrailingCommas = true,
+        IgnoreReadOnlyProperties = false,
+    };
+    private readonly ConnectionMultiplexer _conn;
+
+    public RedisBotCache(ConnectionMultiplexer conn)
+    {
+        _conn = conn;
+    }
+
+    public async ValueTask<bool> AddAsync<T>(TypedKey<T> key, T value, TimeSpan? expiry = null, bool overwrite = true)
+    {
+        // if a null value is passed, remove the key
+        if (value is null)
+        {
+            await RemoveAsync(key);
+            return false;
+        }
+        
+        var db = _conn.GetDatabase();
+        RedisValue val = IsSupportedType(typeof(T)) 
+            ? RedisValue.Unbox(value)
+            : JsonSerializer.Serialize(value, _opts);
+
+        var success = await db.StringSetAsync(key.Key,
+            val,
+            expiry: expiry,
+            when: overwrite ? When.Always : When.NotExists);
+
+        return success;
+    }
+
+    public bool IsSupportedType(Type type)
+    {
+        if (type.IsGenericType)
+        {
+            var typeDef = type.GetGenericTypeDefinition();
+            if (typeDef == typeof(Nullable<>))
+                return IsSupportedType(type.GenericTypeArguments[0]);
+        }
+
+        foreach (var t in _supportedTypes)
+        {
+            if (type == t)
+                return true;
+        }
+
+        return false;
+    }
+    
+    public async ValueTask<OneOf<T, None>> GetAsync<T>(TypedKey<T> key)
+    {
+        var db = _conn.GetDatabase();
+        var val = await db.StringGetAsync(key.Key);
+        if (val == default)
+            return new None();
+
+        if (IsSupportedType(typeof(T)))
+            return (T)((IConvertible)val).ToType(typeof(T), null);
+
+        return JsonSerializer.Deserialize<T>(val.ToString(), _opts)!;
+    }
+
+    public async ValueTask<bool> RemoveAsync<T>(TypedKey<T> key)
+    {
+        var db = _conn.GetDatabase();
+
+        return await db.KeyDeleteAsync(key.Key);
+    }
+
+    public async ValueTask<T?> GetOrAddAsync<T>(TypedKey<T> key, Func<Task<T?>> createFactory, TimeSpan? expiry = null)
+    {
+        var result = await GetAsync(key);
+
+        return await result.Match<Task<T?>>(
+            v => Task.FromResult<T?>(v),
+            async _ =>
+            {
+                var factoryValue = await createFactory();
+
+                if (factoryValue is null)
+                    return default;
+                
+                await AddAsync(key, factoryValue, expiry);
+                
+                // get again to make sure it's the cached value
+                // and not the late factory value, in case there's a race condition
+                
+                var newResult = await GetAsync(key);
+
+                // it's fine to do this, it should blow up if something went wrong.
+                return newResult.Match<T?>(
+                    v => v,
+                    _ => default);
+            });
+    }
+}

src/NadekoBot/Common/Collections/ConcurrentHashSet.cs

@@ -1,4 +1,4 @@
-#nullable disable
+#nullable enable
 #pragma warning disable
 // License MIT
 // Source: https://github.com/i3arnon/ConcurrentHashSet
@@ -7,433 +7,23 @@ using System.Diagnostics;
 
 namespace System.Collections.Generic;
 
-/// <summary>
-///     Represents a thread-safe hash-based unique collection.
-/// </summary>
-/// <typeparam name="T">The type of the items in the collection.</typeparam>
-/// <remarks>
-///     All public members of <see cref="ConcurrentHashSet{T}" /> are thread-safe and may be used
-///     concurrently from multiple threads.
-/// </remarks>
-[DebuggerDisplay("Count = {Count}")]
+[DebuggerDisplay("{_backingStore.Count}")]
 public sealed class ConcurrentHashSet<T> : IReadOnlyCollection<T>, ICollection<T>
 {
-    private const int DEFAULT_CAPACITY = 31;
-    private const int MAX_LOCK_NUMBER = 1024;
-
-    private static int DefaultConcurrencyLevel
-        => PlatformHelper.ProcessorCount;
-
-    /// <summary>
-    ///     Gets a value that indicates whether the <see cref="ConcurrentHashSet{T}" /> is empty.
-    /// </summary>
-    /// <value>
-    ///     true if the <see cref="ConcurrentHashSet{T}" /> is empty; otherwise,
-    ///     false.
-    /// </value>
-    public bool IsEmpty
-    {
-        get
-        {
-            var acquiredLocks = 0;
-            try
-            {
-                AcquireAllLocks(ref acquiredLocks);
-
-                for (var i = 0; i < tables.CountPerLock.Length; i++)
-                {
-                    if (tables.CountPerLock[i] != 0)
-                        return false;
-                }
-            }
-            finally
-            {
-                ReleaseLocks(0, acquiredLocks);
-            }
-
-            return true;
-        }
-    }
-
-    bool ICollection<T>.IsReadOnly
-        => false;
-
-    /// <summary>
-    ///     Gets the number of items contained in the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     .
-    /// </summary>
-    /// <value>
-    ///     The number of items contained in the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     .
-    /// </value>
-    /// <remarks>
-    ///     Count has snapshot semantics and represents the number of items in the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     at the moment when Count was accessed.
-    /// </remarks>
-    public int Count
-    {
-        get
-        {
-            var count = 0;
-            var acquiredLocks = 0;
-            try
-            {
-                AcquireAllLocks(ref acquiredLocks);
-
-                for (var i = 0; i < tables.CountPerLock.Length; i++)
-                    count += tables.CountPerLock[i];
-            }
-            finally
-            {
-                ReleaseLocks(0, acquiredLocks);
-            }
-
-            return count;
-        }
-    }
-
-    private readonly IEqualityComparer<T> _comparer;
-    private readonly bool _growLockArray;
-
-    private int budget;
-    private volatile Tables tables;
-
-    /// <summary>
-    ///     Initializes a new instance of the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     class that is empty, has the default concurrency level, has the default initial capacity, and
-    ///     uses the default comparer for the item type.
-    /// </summary>
+    private readonly ConcurrentDictionary<T, bool> _backingStore;
+    
     public ConcurrentHashSet()
-        : this(DefaultConcurrencyLevel, DEFAULT_CAPACITY, true, EqualityComparer<T>.Default)
-    {
-    }
+        => _backingStore = new();
 
-    /// <summary>
-    ///     Initializes a new instance of the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     class that is empty, has the specified concurrency level and capacity, and uses the default
-    ///     comparer for the item type.
-    /// </summary>
-    /// <param name="concurrencyLevel">
-    ///     The estimated number of threads that will update the
-    ///     <see cref="ConcurrentHashSet{T}" /> concurrently.
-    /// </param>
-    /// <param name="capacity">
-    ///     The initial number of elements that the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     can contain.
-    /// </param>
-    /// <exception cref="T:System.ArgumentOutOfRangeException">
-    ///     <paramref name="concurrencyLevel" /> is
-    ///     less than 1.
-    /// </exception>
-    /// <exception cref="T:System.ArgumentOutOfRangeException">
-    ///     <paramref name="capacity" /> is less than
-    ///     0.
-    /// </exception>
-    public ConcurrentHashSet(int concurrencyLevel, int capacity)
-        : this(concurrencyLevel, capacity, false, EqualityComparer<T>.Default)
-    {
-    }
+    public ConcurrentHashSet(IEnumerable<T> values, IEqualityComparer<T>? comparer = null)
+        => _backingStore = new(values.Select(x => new KeyValuePair<T, bool>(x, true)), comparer);
 
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that contains elements copied from the specified
-    ///     <see
-    ///         cref="T:System.Collections.IEnumerable{T}" />
-    ///     , has the default concurrency
-    ///     level, has the default initial capacity, and uses the default comparer for the item type.
-    /// </summary>
-    /// <param name="collection">
-    ///     The
-    ///     <see
-    ///         cref="T:System.Collections.IEnumerable{T}" />
-    ///     whose elements are copied to
-    ///     the new
-    ///     <see cref="ConcurrentHashSet{T}" />.
-    /// </param>
-    /// <exception cref="T:System.ArgumentNullException"><paramref name="collection" /> is a null reference.</exception>
-    public ConcurrentHashSet(IEnumerable<T> collection)
-        : this(collection, EqualityComparer<T>.Default)
-    {
-    }
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that is empty, has the specified concurrency level and capacity, and uses the specified
-    ///     <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />.
-    /// </summary>
-    /// <param name="comparer">
-    ///     The <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />
-    ///     implementation to use when comparing items.
-    /// </param>
-    /// <exception cref="T:System.ArgumentNullException"><paramref name="comparer" /> is a null reference.</exception>
-    public ConcurrentHashSet(IEqualityComparer<T> comparer)
-        : this(DefaultConcurrencyLevel, DEFAULT_CAPACITY, true, comparer)
-    {
-    }
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that contains elements copied from the specified
-    ///     <see
-    ///         cref="T:System.Collections.IEnumerable" />
-    ///     , has the default concurrency level, has the default
-    ///     initial capacity, and uses the specified
-    ///     <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />.
-    /// </summary>
-    /// <param name="collection">
-    ///     The
-    ///     <see
-    ///         cref="T:System.Collections.IEnumerable{T}" />
-    ///     whose elements are copied to
-    ///     the new
-    ///     <see cref="ConcurrentHashSet{T}" />.
-    /// </param>
-    /// <param name="comparer">
-    ///     The <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />
-    ///     implementation to use when comparing items.
-    /// </param>
-    /// <exception cref="T:System.ArgumentNullException">
-    ///     <paramref name="collection" /> is a null reference
-    ///     (Nothing in Visual Basic). -or-
-    ///     <paramref name="comparer" /> is a null reference (Nothing in Visual Basic).
-    /// </exception>
-    public ConcurrentHashSet(IEnumerable<T> collection, IEqualityComparer<T> comparer)
-        : this(comparer)
-    {
-        if (collection is null)
-            throw new ArgumentNullException(nameof(collection));
-
-        InitializeFromCollection(collection);
-    }
-
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that contains elements copied from the specified <see cref="T:System.Collections.IEnumerable" />,
-    ///     has the specified concurrency level, has the specified initial capacity, and uses the specified
-    ///     <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />.
-    /// </summary>
-    /// <param name="concurrencyLevel">
-    ///     The estimated number of threads that will update the
-    ///     <see cref="ConcurrentHashSet{T}" /> concurrently.
-    /// </param>
-    /// <param name="collection">
-    ///     The <see cref="T:System.Collections.IEnumerable{T}" /> whose elements are copied to the new
-    ///     <see cref="ConcurrentHashSet{T}" />.
-    /// </param>
-    /// <param name="comparer">
-    ///     The <see cref="T:System.Collections.Generic.IEqualityComparer{T}" /> implementation to use
-    ///     when comparing items.
-    /// </param>
-    /// <exception cref="T:System.ArgumentNullException">
-    ///     <paramref name="collection" /> is a null reference.
-    ///     -or-
-    ///     <paramref name="comparer" /> is a null reference.
-    /// </exception>
-    /// <exception cref="T:System.ArgumentOutOfRangeException">
-    ///     <paramref name="concurrencyLevel" /> is less than 1.
-    /// </exception>
-    public ConcurrentHashSet(int concurrencyLevel, IEnumerable<T> collection, IEqualityComparer<T> comparer)
-        : this(concurrencyLevel, DEFAULT_CAPACITY, false, comparer)
-    {
-        if (collection is null)
-            throw new ArgumentNullException(nameof(collection));
-        if (comparer is null)
-            throw new ArgumentNullException(nameof(comparer));
-
-        InitializeFromCollection(collection);
-    }
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ConcurrentHashSet{T}" />
-    ///     class that is empty, has the specified concurrency level, has the specified initial capacity, and
-    ///     uses the specified <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />.
-    /// </summary>
-    /// <param name="concurrencyLevel">
-    ///     The estimated number of threads that will update the
-    ///     <see cref="ConcurrentHashSet{T}" /> concurrently.
-    /// </param>
-    /// <param name="capacity">
-    ///     The initial number of elements that the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     can contain.
-    /// </param>
-    /// <param name="comparer">
-    ///     The <see cref="T:System.Collections.Generic.IEqualityComparer{T}" />
-    ///     implementation to use when comparing items.
-    /// </param>
-    /// <exception cref="T:System.ArgumentOutOfRangeException">
-    ///     <paramref name="concurrencyLevel" /> is less than 1. -or-
-    ///     <paramref name="capacity" /> is less than 0.
-    /// </exception>
-    /// <exception cref="T:System.ArgumentNullException"><paramref name="comparer" /> is a null reference.</exception>
-    public ConcurrentHashSet(int concurrencyLevel, int capacity, IEqualityComparer<T> comparer)
-        : this(concurrencyLevel, capacity, false, comparer)
-    {
-    }
-
-    private ConcurrentHashSet(
-        int concurrencyLevel,
-        int capacity,
-        bool growLockArray,
-        IEqualityComparer<T> comparer)
-    {
-        if (concurrencyLevel < 1)
-            throw new ArgumentOutOfRangeException(nameof(concurrencyLevel));
-        if (capacity < 0)
-            throw new ArgumentOutOfRangeException(nameof(capacity));
-
-        // The capacity should be at least as large as the concurrency level. Otherwise, we would have locks that don't guard
-        // any buckets.
-        if (capacity < concurrencyLevel)
-            capacity = concurrencyLevel;
-
-        var locks = new object[concurrencyLevel];
-        for (var i = 0; i < locks.Length; i++)
-            locks[i] = new();
-
-        var countPerLock = new int[locks.Length];
-        var buckets = new Node[capacity];
-        tables = new(buckets, locks, countPerLock);
-
-        _growLockArray = growLockArray;
-        budget = buckets.Length / locks.Length;
-        _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
-    }
-
-    /// <summary>
-    ///     Removes all items from the <see cref="ConcurrentHashSet{T}" />.
-    /// </summary>
-    public void Clear()
-    {
-        var locksAcquired = 0;
-        try
-        {
-            AcquireAllLocks(ref locksAcquired);
-
-            var newTables = new Tables(new Node[DEFAULT_CAPACITY], tables.Locks, new int[tables.CountPerLock.Length]);
-            tables = newTables;
-            budget = Math.Max(1, newTables.Buckets.Length / newTables.Locks.Length);
-        }
-        finally
-        {
-            ReleaseLocks(0, locksAcquired);
-        }
-    }
-
-    /// <summary>
-    ///     Determines whether the <see cref="ConcurrentHashSet{T}" /> contains the specified
-    ///     item.
-    /// </summary>
-    /// <param name="item">The item to locate in the <see cref="ConcurrentHashSet{T}" />.</param>
-    /// <returns>true if the <see cref="ConcurrentHashSet{T}" /> contains the item; otherwise, false.</returns>
-    public bool Contains(T item)
-    {
-        var hashcode = _comparer.GetHashCode(item!);
-
-        // We must capture the _buckets field in a local variable. It is set to a new table on each table resize.
-        var localTables = tables;
-
-        var bucketNo = GetBucket(hashcode, localTables.Buckets.Length);
-
-        // We can get away w/out a lock here.
-        // The Volatile.Read ensures that the load of the fields of 'n' doesn't move before the load from buckets[i].
-        var current = Volatile.Read(ref localTables.Buckets[bucketNo]);
-
-        while (current is not null)
-        {
-            if (hashcode == current.Hashcode && _comparer.Equals(current.Item, item))
-                return true;
-
-            current = current.Next;
-        }
-
-        return false;
-    }
-
-    void ICollection<T>.Add(T item)
-        => Add(item);
-
-    void ICollection<T>.CopyTo(T[] array, int arrayIndex)
-    {
-        if (array is null)
-            throw new ArgumentNullException(nameof(array));
-        if (arrayIndex < 0)
-            throw new ArgumentOutOfRangeException(nameof(arrayIndex));
-
-        var locksAcquired = 0;
-        try
-        {
-            AcquireAllLocks(ref locksAcquired);
-
-            var count = 0;
-
-            for (var i = 0; i < tables.Locks.Length && count >= 0; i++)
-                count += tables.CountPerLock[i];
-
-            if (array.Length - count < arrayIndex || count < 0) //"count" itself or "count + arrayIndex" can overflow
-            {
-                throw new ArgumentException(
-                    "The index is equal to or greater than the length of the array, or the number of elements in the set is greater than the available space from index to the end of the destination array.");
-            }
-
-            CopyToItems(array, arrayIndex);
-        }
-        finally
-        {
-            ReleaseLocks(0, locksAcquired);
-        }
-    }
-
-    bool ICollection<T>.Remove(T item)
-        => TryRemove(item);
+    public IEnumerator<T> GetEnumerator()
+        => _backingStore.Keys.GetEnumerator();
 
     IEnumerator IEnumerable.GetEnumerator()
         => GetEnumerator();
 
-    /// <summary>
-    ///     Returns an enumerator that iterates through the
-    ///     <see
-    ///         cref="ConcurrentHashSet{T}" />
-    ///     .
-    /// </summary>
-    /// <returns>An enumerator for the <see cref="ConcurrentHashSet{T}" />.</returns>
-    /// <remarks>
-    ///     The enumerator returned from the collection is safe to use concurrently with
-    ///     reads and writes to the collection, however it does not represent a moment-in-time snapshot
-    ///     of the collection.  The contents exposed through the enumerator may contain modifications
-    ///     made to the collection after <see cref="GetEnumerator" /> was called.
-    /// </remarks>
-    public IEnumerator<T> GetEnumerator()
-    {
-        var buckets = tables.Buckets;
-
-        for (var i = 0; i < buckets.Length; i++)
-        {
-            // The Volatile.Read ensures that the load of the fields of 'current' doesn't move before the load from buckets[i].
-            var current = Volatile.Read(ref buckets[i]);
-
-            while (current is not null)
-            {
-                yield return current.Item;
-                current = current.Next;
-            }
-        }
-    }
-
     /// <summary>
     ///     Adds the specified item to the <see cref="ConcurrentHashSet{T}" />.
     /// </summary>
@@ -447,375 +37,57 @@ public sealed class ConcurrentHashSet<T> : IReadOnlyCollection<T>, ICollection<T
     ///     contains too many items.
     /// </exception>
     public bool Add(T item)
-        => AddInternal(item, _comparer.GetHashCode(item), true);
+        => _backingStore.TryAdd(item, true);
+
+    void ICollection<T>.Add(T item)
+        => Add(item);
+
+    public void Clear()
+        => _backingStore.Clear();
+
+    public bool Contains(T item)
+        => _backingStore.ContainsKey(item);
+
+    public void CopyTo(T[] array, int arrayIndex)
+    {
+        ArgumentNullException.ThrowIfNull(array);
+        
+        if (arrayIndex < 0)
+            throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+        
+        if (arrayIndex >= array.Length)
+            throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+
+        CopyToInternal(array, arrayIndex);
+    }
+
+    private void CopyToInternal(T[] array, int arrayIndex)
+    {
+        var len = array.Length;
+        foreach (var (k, _) in _backingStore)
+        {
+            if (arrayIndex >= len)
+                throw new IndexOutOfRangeException(nameof(arrayIndex));
+            
+            array[arrayIndex++] = k;
+        }
+    }
+
+    bool ICollection<T>.Remove(T item)
+        => TryRemove(item);
 
-    /// <summary>
-    ///     Attempts to remove the item from the <see cref="ConcurrentHashSet{T}" />.
-    /// </summary>
-    /// <param name="item">The item to remove.</param>
-    /// <returns>true if an item was removed successfully; otherwise, false.</returns>
     public bool TryRemove(T item)
+        => _backingStore.TryRemove(item, out _);
+
+    public void RemoveWhere(Func<T, bool> predicate)
     {
-        var hashcode = _comparer.GetHashCode(item);
-        while (true)
-        {
-            var localTables = tables;
-
-            GetBucketAndLockNo(hashcode,
-                out var bucketNo,
-                out var lockNo,
-                localTables.Buckets.Length,
-                localTables.Locks.Length);
-
-            lock (localTables.Locks[lockNo])
-            {
-                // If the table just got resized, we may not be holding the right lock, and must retry.
-                // This should be a rare occurrence.
-                if (localTables != tables)
-                    continue;
-
-                Node previous = null;
-                for (var current = localTables.Buckets[bucketNo]; current is not null; current = current.Next)
-                {
-                    Debug.Assert((previous is null && current == localTables.Buckets[bucketNo])
-                                 || previous!.Next == current);
-
-                    if (hashcode == current.Hashcode && _comparer.Equals(current.Item, item))
-                    {
-                        if (previous is null)
-                            Volatile.Write(ref localTables.Buckets[bucketNo], current.Next);
-                        else
-                            previous.Next = current.Next;
-
-                        localTables.CountPerLock[lockNo]--;
-                        return true;
-                    }
-
-                    previous = current;
-                }
-            }
-
-            return false;
-        }
+        foreach (var elem in this.Where(predicate))
+            TryRemove(elem);
     }
 
-    private void InitializeFromCollection(IEnumerable<T> collection)
-    {
-        foreach (var item in collection)
-            AddInternal(item, _comparer.GetHashCode(item), false);
+    public int Count
+        => _backingStore.Count;
 
-        if (budget == 0)
-            budget = tables.Buckets.Length / tables.Locks.Length;
-    }
-
-    private bool AddInternal(T item, int hashcode, bool acquireLock)
-    {
-        while (true)
-        {
-            var localTables = tables;
-            GetBucketAndLockNo(hashcode,
-                out var bucketNo,
-                out var lockNo,
-                localTables.Buckets.Length,
-                localTables.Locks.Length);
-
-            var resizeDesired = false;
-            var lockTaken = false;
-            try
-            {
-                if (acquireLock)
-                    Monitor.Enter(localTables.Locks[lockNo], ref lockTaken);
-
-                // If the table just got resized, we may not be holding the right lock, and must retry.
-                // This should be a rare occurrence.
-                if (localTables != tables)
-                    continue;
-
-                // Try to find this item in the bucket
-                Node previous = null;
-                for (var current = localTables.Buckets[bucketNo]; current is not null; current = current.Next)
-                {
-                    Debug.Assert((previous is null && current == localTables.Buckets[bucketNo])
-                                 || previous!.Next == current);
-                    if (hashcode == current.Hashcode && _comparer.Equals(current.Item, item))
-                        return false;
-
-                    previous = current;
-                }
-
-                // The item was not found in the bucket. Insert the new item.
-                Volatile.Write(ref localTables.Buckets[bucketNo], new(item, hashcode, localTables.Buckets[bucketNo]));
-                checked
-                {
-                    localTables.CountPerLock[lockNo]++;
-                }
-
-                //
-                // If the number of elements guarded by this lock has exceeded the budget, resize the bucket table.
-                // It is also possible that GrowTable will increase the budget but won't resize the bucket table.
-                // That happens if the bucket table is found to be poorly utilized due to a bad hash function.
-                //
-                if (localTables.CountPerLock[lockNo] > budget)
-                    resizeDesired = true;
-            }
-            finally
-            {
-                if (lockTaken)
-                    Monitor.Exit(localTables.Locks[lockNo]);
-            }
-
-            //
-            // The fact that we got here means that we just performed an insertion. If necessary, we will grow the table.
-            //
-            // Concurrency notes:
-            // - Notice that we are not holding any locks at when calling GrowTable. This is necessary to prevent deadlocks.
-            // - As a result, it is possible that GrowTable will be called unnecessarily. But, GrowTable will obtain lock 0
-            //   and then verify that the table we passed to it as the argument is still the current table.
-            //
-            if (resizeDesired)
-                GrowTable(localTables);
-
-            return true;
-        }
-    }
-
-    private static int GetBucket(int hashcode, int bucketCount)
-    {
-        var bucketNo = (hashcode & 0x7fffffff) % bucketCount;
-        Debug.Assert(bucketNo >= 0 && bucketNo < bucketCount);
-        return bucketNo;
-    }
-
-    private static void GetBucketAndLockNo(
-        int hashcode,
-        out int bucketNo,
-        out int lockNo,
-        int bucketCount,
-        int lockCount)
-    {
-        bucketNo = (hashcode & 0x7fffffff) % bucketCount;
-        lockNo = bucketNo % lockCount;
-
-        Debug.Assert(bucketNo >= 0 && bucketNo < bucketCount);
-        Debug.Assert(lockNo >= 0 && lockNo < lockCount);
-    }
-
-    private void GrowTable(Tables localTables)
-    {
-        const int maxArrayLength = 0X7FEFFFFF;
-        var locksAcquired = 0;
-        try
-        {
-            // The thread that first obtains _locks[0] will be the one doing the resize operation
-            AcquireLocks(0, 1, ref locksAcquired);
-
-            // Make sure nobody resized the table while we were waiting for lock 0:
-            if (localTables != tables)
-                // We assume that since the table reference is different, it was already resized (or the budget
-                // was adjusted). If we ever decide to do table shrinking, or replace the table for other reasons,
-                // we will have to revisit this logic.
-                return;
-
-            // Compute the (approx.) total size. Use an Int64 accumulation variable to avoid an overflow.
-            long approxCount = 0;
-            for (var i = 0; i < localTables.CountPerLock.Length; i++)
-                approxCount += localTables.CountPerLock[i];
-
-            //
-            // If the bucket array is too empty, double the budget instead of resizing the table
-            //
-            if (approxCount < localTables.Buckets.Length / 4)
-            {
-                budget = 2 * budget;
-                if (budget < 0)
-                    budget = int.MaxValue;
-
-                return;
-            }
-
-            // Compute the new table size. We find the smallest integer larger than twice the previous table size, and not divisible by
-            // 2,3,5 or 7. We can consider a different table-sizing policy in the future.
-            var newLength = 0;
-            var maximizeTableSize = false;
-            try
-            {
-                checked
-                {
-                    // Double the size of the buckets table and add one, so that we have an odd integer.
-                    newLength = (localTables.Buckets.Length * 2) + 1;
-
-                    // Now, we only need to check odd integers, and find the first that is not divisible
-                    // by 3, 5 or 7.
-                    while (newLength % 3 == 0 || newLength % 5 == 0 || newLength % 7 == 0)
-                        newLength += 2;
-
-                    Debug.Assert(newLength % 2 != 0);
-
-                    if (newLength > maxArrayLength)
-                        maximizeTableSize = true;
-                }
-            }
-            catch (OverflowException)
-            {
-                maximizeTableSize = true;
-            }
-
-            if (maximizeTableSize)
-            {
-                newLength = maxArrayLength;
-
-                // We want to make sure that GrowTable will not be called again, since table is at the maximum size.
-                // To achieve that, we set the budget to int.MaxValue.
-                //
-                // (There is one special case that would allow GrowTable() to be called in the future: 
-                // calling Clear() on the ConcurrentHashSet will shrink the table and lower the budget.)
-                budget = int.MaxValue;
-            }
-
-            // Now acquire all other locks for the table
-            AcquireLocks(1, localTables.Locks.Length, ref locksAcquired);
-
-            var newLocks = localTables.Locks;
-
-            // Add more locks
-            if (_growLockArray && localTables.Locks.Length < MAX_LOCK_NUMBER)
-            {
-                newLocks = new object[localTables.Locks.Length * 2];
-                Array.Copy(localTables.Locks, 0, newLocks, 0, localTables.Locks.Length);
-                for (var i = localTables.Locks.Length; i < newLocks.Length; i++)
-                    newLocks[i] = new();
-            }
-
-            var newBuckets = new Node[newLength];
-            var newCountPerLock = new int[newLocks.Length];
-
-            // Copy all data into a new table, creating new nodes for all elements
-            for (var i = 0; i < localTables.Buckets.Length; i++)
-            {
-                var current = localTables.Buckets[i];
-                while (current is not null)
-                {
-                    var next = current.Next;
-                    GetBucketAndLockNo(current.Hashcode,
-                        out var newBucketNo,
-                        out var newLockNo,
-                        newBuckets.Length,
-                        newLocks.Length);
-
-                    newBuckets[newBucketNo] = new(current.Item, current.Hashcode, newBuckets[newBucketNo]);
-
-                    checked
-                    {
-                        newCountPerLock[newLockNo]++;
-                    }
-
-                    current = next;
-                }
-            }
-
-            // Adjust the budget
-            budget = Math.Max(1, newBuckets.Length / newLocks.Length);
-
-            // Replace tables with the new versions
-            tables = new(newBuckets, newLocks, newCountPerLock);
-        }
-        finally
-        {
-            // Release all locks that we took earlier
-            ReleaseLocks(0, locksAcquired);
-        }
-    }
-
-    public int RemoveWhere(Func<T, bool> predicate)
-    {
-        var elems = this.Where(predicate);
-        var removed = 0;
-        foreach (var elem in elems)
-        {
-            if (TryRemove(elem))
-                removed++;
-        }
-
-        return removed;
-    }
-
-    private void AcquireAllLocks(ref int locksAcquired)
-    {
-        // First, acquire lock 0
-        AcquireLocks(0, 1, ref locksAcquired);
-
-        // Now that we have lock 0, the _locks array will not change (i.e., grow),
-        // and so we can safely read _locks.Length.
-        AcquireLocks(1, tables.Locks.Length, ref locksAcquired);
-        Debug.Assert(locksAcquired == tables.Locks.Length);
-    }
-
-    private void AcquireLocks(int fromInclusive, int toExclusive, ref int locksAcquired)
-    {
-        Debug.Assert(fromInclusive <= toExclusive);
-        var locks = tables.Locks;
-
-        for (var i = fromInclusive; i < toExclusive; i++)
-        {
-            var lockTaken = false;
-            try
-            {
-                Monitor.Enter(locks[i], ref lockTaken);
-            }
-            finally
-            {
-                if (lockTaken)
-                    locksAcquired++;
-            }
-        }
-    }
-
-    private void ReleaseLocks(int fromInclusive, int toExclusive)
-    {
-        Debug.Assert(fromInclusive <= toExclusive);
-
-        for (var i = fromInclusive; i < toExclusive; i++)
-            Monitor.Exit(tables.Locks[i]);
-    }
-
-    private void CopyToItems(T[] array, int index)
-    {
-        var buckets = tables.Buckets;
-        for (var i = 0; i < buckets.Length; i++)
-        for (var current = buckets[i]; current is not null; current = current.Next)
-        {
-            array[index] = current.Item;
-            index++; //this should never flow, CopyToItems is only called when there's no overflow risk
-        }
-    }
-
-    private sealed class Tables
-    {
-        public readonly Node[] Buckets;
-        public readonly object[] Locks;
-
-        public volatile int[] CountPerLock;
-
-        public Tables(Node[] buckets, object[] locks, int[] countPerLock)
-        {
-            Buckets = buckets;
-            Locks = locks;
-            CountPerLock = countPerLock;
-        }
-    }
-
-    private sealed class Node
-    {
-        public readonly int Hashcode;
-        public readonly T Item;
-
-        public volatile Node Next;
-
-        public Node(T item, int hashcode, Node next)
-        {
-            Item = item;
-            Hashcode = hashcode;
-            Next = next;
-        }
-    }
+    public bool IsReadOnly
+        => false;
 }

src/NadekoBot/Common/Configs/BotConfig.cs

@@ -12,7 +12,7 @@ namespace NadekoBot.Common.Configs;
 public sealed partial class BotConfig : ICloneable<BotConfig>
 {
     [Comment(@"DO NOT CHANGE")]
-    public int Version { get; set; } = 2;
+    public int Version { get; set; } = 3;
 
     [Comment(@"Most commands, when executed, have a small colored line
 next to the response. The color depends whether the command
@@ -182,4 +182,4 @@ public enum ConsoleOutputType
     Normal = 0,
     Simple = 1,
     None = 2
-}
+}

src/NadekoBot/Common/Creds.cs

@@ -19,7 +19,10 @@ public sealed class Creds : IBotCredentials
     public bool UsePrivilegedIntents { get; set; }
 
     [Comment(@"The number of shards that the bot will be running on.
-Leave at 1 if you don't know what you're doing.")]
+Leave at 1 if you don't know what you're doing.
+
+note: If you are planning to have more than one shard, then you must change botCache to 'redis'.
+      Also, in that case you should be using NadekoBot.Coordinator to start the bot, and it will correctly override this value.")]
     public int TotalShards { get; set; }
 
     [Comment(   
@@ -50,8 +53,14 @@ go to https://www.patreon.com/portal -> my clients -> create client")]
 
     [Comment(@"Official cleverbot api key.")]
     public string CleverbotApiKey { get; set; }
-
-    [Comment(@"Redis connection string. Don't change if you don't know what you're doing.")]
+    
+    [Comment(@"Which cache implementation should bot use.
+'memory' - Cache will be in memory of the bot's process itself. Only use this on bots with a single shard. When the bot is restarted the cache is reset. 
+'redis' - Uses redis (which needs to be separately downloaded and installed). The cache will persist through bot restarts. You can configure connection string in creds.yml")]
+    public BotCacheImplemenation BotCache { get; set; }
+    
+    [Comment(@"Redis connection string. Don't change if you don't know what you're doing.
+Only used if botCache is set to 'redis'")]
     public string RedisOptions { get; set; }
 
     [Comment(@"Database options. Don't change if you don't know what you're doing. Leave null for default values")]
@@ -104,12 +113,12 @@ Linux default
     args: ""NadekoBot.dll -- {0}""
 Windows default
     cmd: NadekoBot.exe
-    args: {0}")]
+    args: ""{0}""")]
     public RestartConfig RestartCommand { get; set; }
 
     public Creds()
     {
-        Version = 5;
+        Version = 6;
         Token = string.Empty;
         UsePrivilegedIntents = true;
         OwnerIds = new List<ulong>();
@@ -119,6 +128,7 @@ Windows default
         Patreon = new(string.Empty, string.Empty, string.Empty, string.Empty);
         BotListToken = string.Empty;
         CleverbotApiKey = string.Empty;
+        BotCache = BotCacheImplemenation.Memory;
         RedisOptions = "localhost:6379,syncTimeout=30000,responseTimeout=30000,allowAdmin=true,password=";
         Db = new()
         {
@@ -217,4 +227,10 @@ public class GoogleApiConfig
 {
     public string SearchId { get; init; }
     public string ImageSearchId { get; init; }
+}
+
+public enum BotCacheImplemenation
+{
+    Memory,
+    Redis
 }

src/NadekoBot/Common/IBotCredentials.cs

@@ -26,6 +26,7 @@ public interface IBotCredentials
     string TwitchClientId { get; set; }
     string TwitchClientSecret { get; set; }
     GoogleApiConfig Google { get; set; }
+    BotCacheImplemenation BotCache { get; set; }
 }
 
 public class RestartConfig

src/NadekoBot/Common/ILogCommandService.cs

@@ -27,5 +27,6 @@ public enum LogType
     UserPresence,
     VoicePresence,
     VoicePresenceTts,
-    UserMuted
+    UserMuted,
+    UserWarned,
 }

src/NadekoBot/Common/ImageUrls.cs

@@ -1,9 +1,11 @@
 #nullable disable
 using NadekoBot.Common.Yml;
+using Cloneable;
 
 namespace NadekoBot.Common;
 
-public class ImageUrls
+[Cloneable]
+public partial class ImageUrls : ICloneable<ImageUrls> 
 {
     [Comment("DO NOT CHANGE")]
     public int Version { get; set; } = 3;

src/NadekoBot/Common/NadekoModule.cs

@@ -67,13 +67,13 @@ public abstract class NadekoModule : ModuleBase
 
     // localized replies
     public Task<IUserMessage> ReplyErrorLocalizedAsync(LocStr str, NadekoButtonInteraction inter = null)
-        => SendErrorAsync($"{Format.Bold(ctx.User.ToString())} {GetText(str)}");
+        => SendErrorAsync($"{Format.Bold(ctx.User.ToString())} {GetText(str)}", inter);
 
     public Task<IUserMessage> ReplyPendingLocalizedAsync(LocStr str, NadekoButtonInteraction inter = null)
-        => SendPendingAsync($"{Format.Bold(ctx.User.ToString())} {GetText(str)}");
+        => SendPendingAsync($"{Format.Bold(ctx.User.ToString())} {GetText(str)}", inter);
 
     public Task<IUserMessage> ReplyConfirmLocalizedAsync(LocStr str, NadekoButtonInteraction inter = null)
-        => SendConfirmAsync($"{Format.Bold(ctx.User.ToString())} {GetText(str)}");
+        => SendConfirmAsync($"{Format.Bold(ctx.User.ToString())} {GetText(str)}", inter);
 
     public async Task<bool> PromptUserConfirmAsync(IEmbedBuilder embed)
     {

src/NadekoBot/Common/OneOfExtensions.cs

@@ -0,0 +1,10 @@
+using OneOf.Types;
+using OneOf;
+
+namespace NadekoBot.Common;
+
+public static class OneOfExtensions
+{
+    public static bool TryGetValue<T>(this OneOf<T, None> oneOf, out T value)
+        => oneOf.TryPickT0(out value, out _);
+}

src/NadekoBot/Common/Pokemon/SearchPokemon.cs

@@ -1,11 +1,12 @@
 #nullable disable
-using Newtonsoft.Json;
+
+using System.Text.Json.Serialization;
 
 namespace NadekoBot.Common.Pokemon;
 
 public class SearchPokemon
 {
-    [JsonProperty("num")]
+    [JsonPropertyName("num")]
     public int Id { get; set; }
 
     public string Species { get; set; }

src/NadekoBot/Common/QueueRunner.cs

@@ -57,6 +57,6 @@ public sealed class QueueRunner
         }
     }
     
-    public ValueTask Enqueue(Func<Task> action)
+    public ValueTask EnqueueAsync(Func<Task> action)
         => _channel.Writer.WriteAsync(action);
 }

src/NadekoBot/Common/Replacements/ReplacementBuilder.cs

@@ -55,6 +55,7 @@ public class ReplacementBuilder
         _reps.TryAdd("%server%", () => g is null ? "DM" : g.Name);
         _reps.TryAdd("%server.id%", () => g is null ? "DM" : g.Id.ToString());
         _reps.TryAdd("%server.name%", () => g is null ? "DM" : g.Name);
+        _reps.TryAdd("%server.icon%", () => g is null ? null : g.IconUrl);
         _reps.TryAdd("%server.members%", () => g is { } sg ? sg.MemberCount.ToString() : "?");
         _reps.TryAdd("%server.boosters%", () => g.PremiumSubscriptionCount.ToString());
         _reps.TryAdd("%server.boost_level%", () => ((int)g.PremiumTier).ToString());

src/NadekoBot/Db/Extensions/QuoteExtensions.cs

@@ -44,12 +44,12 @@ public static class QuoteExtensions
         var rngk = new NadekoRandom();
         return (await quotes.AsQueryable()
                             .Where(q => q.GuildId == guildId
-                                        && q.Keyword == keyword
-                                        && EF.Functions.Like(q.Text.ToUpper(), $"%{text.ToUpper()}%")
-                                // && q.Text.Contains(text, StringComparison.OrdinalIgnoreCase)
-                            )
-                            .ToListAsync()).OrderBy(_ => rngk.Next())
-                                           .FirstOrDefault();
+                                        && (keyword == null || q.Keyword == keyword)
+                                        && (EF.Functions.Like(q.Text.ToUpper(), $"%{text.ToUpper()}%")
+                                            || EF.Functions.Like(q.AuthorName, text)))
+                            .ToListAsync())
+               .OrderBy(_ => rngk.Next())
+               .FirstOrDefault();
     }
 
     public static void RemoveAllByKeyword(this DbSet<Quote> quotes, ulong guildId, string keyword)

src/NadekoBot/Db/Models/AntiProtection.cs

@@ -48,7 +48,8 @@ public enum PunishmentAction
     RemoveRoles,
     ChatMute,
     VoiceMute,
-    AddRole
+    AddRole,
+    Warn
 }
 
 public class AntiSpamIgnore : DbEntity

src/NadekoBot/Db/Models/LogSetting.cs

@@ -4,7 +4,7 @@ namespace NadekoBot.Services.Database.Models;
 public class LogSetting : DbEntity
 {
     public List<IgnoredLogItem> LogIgnores { get; set; } = new();
-
+    
     public ulong GuildId { get; set; }
     public ulong? LogOtherId { get; set; }
     public ulong? MessageUpdatedId { get; set; }
@@ -29,4 +29,5 @@ public class LogSetting : DbEntity
 
     public ulong? LogVoicePresenceId { get; set; }
     public ulong? LogVoicePresenceTTSId { get; set; }
+    public ulong? LogWarnsId { get; set; }
 }

src/NadekoBot/Db/Models/StreamOnlineMessage.cs

@@ -0,0 +1,13 @@
+#nullable disable
+using NadekoBot.Services.Database.Models;
+
+namespace NadekoBot.Db.Models;
+
+public class StreamOnlineMessage : DbEntity
+{
+    public ulong ChannelId { get; set; }
+    public ulong MessageId { get; set; }
+
+    public FollowedStream.FType Type { get; set; }
+    public string Name { get; set; }
+}

src/NadekoBot/Db/NadekoContext.cs

@@ -58,6 +58,9 @@ public abstract class NadekoContext : DbContext
     public DbSet<PatronUser> Patrons { get; set; }
 
     public DbSet<PatronQuota> PatronQuotas { get; set; }
+    
+    public DbSet<StreamOnlineMessage> StreamOnlineMessages { get; set; }
+
 
     #region Mandatory Provider-Specific Values
 

src/NadekoBot/GlobalUsings.cs

@@ -1,4 +1,5 @@
-global using System.Collections.Concurrent;
+// global using System.Collections.Concurrent;
+global using NonBlocking;
 
 // packages
 global using Serilog;

src/NadekoBot/Migrations/MySql/20220623090718_stondel-db-cache.cs

@@ -0,0 +1,39 @@
+using System;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NadekoBot.Migrations.Mysql
+{
+    public partial class stondeldbcache : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "streamonlinemessages",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    channelid = table.Column<ulong>(type: "bigint unsigned", nullable: false),
+                    messageid = table.Column<ulong>(type: "bigint unsigned", nullable: false),
+                    type = table.Column<int>(type: "int", nullable: false),
+                    name = table.Column<string>(type: "longtext", nullable: true)
+                        .Annotation("MySql:CharSet", "utf8mb4"),
+                    dateadded = table.Column<DateTime>(type: "datetime(6)", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_streamonlinemessages", x => x.id);
+                })
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "streamonlinemessages");
+        }
+    }
+}

src/NadekoBot/Migrations/MySql/20220703194400_logwarns.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NadekoBot.Migrations.Mysql
+{
+    public partial class logwarns : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<ulong>(
+                name: "logwarnsid",
+                table: "logsettings",
+                type: "bigint unsigned",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "logwarnsid",
+                table: "logsettings");
+        }
+    }
+}

src/NadekoBot/Migrations/MySql/MysqlContextModelSnapshot.cs

@@ -16,7 +16,7 @@ namespace NadekoBot.Migrations.Mysql
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "6.0.5")
+                .HasAnnotation("ProductVersion", "6.0.6")
                 .HasAnnotation("Relational:MaxIdentifierLength", 64);
 
             modelBuilder.Entity("NadekoBot.Db.Models.BankUser", b =>
@@ -333,6 +333,39 @@ namespace NadekoBot.Migrations.Mysql
                     b.ToTable("patrons", (string)null);
                 });
 
+            modelBuilder.Entity("NadekoBot.Db.Models.StreamOnlineMessage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasColumnName("id");
+
+                    b.Property<ulong>("ChannelId")
+                        .HasColumnType("bigint unsigned")
+                        .HasColumnName("channelid");
+
+                    b.Property<DateTime?>("DateAdded")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("dateadded");
+
+                    b.Property<ulong>("MessageId")
+                        .HasColumnType("bigint unsigned")
+                        .HasColumnName("messageid");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext")
+                        .HasColumnName("name");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("int")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_streamonlinemessages");
+
+                    b.ToTable("streamonlinemessages", (string)null);
+                });
+
             modelBuilder.Entity("NadekoBot.Services.Database.Models.AntiAltSetting", b =>
                 {
                     b.Property<int>("Id")
@@ -1373,6 +1406,10 @@ namespace NadekoBot.Migrations.Mysql
                         .HasColumnType("bigint unsigned")
                         .HasColumnName("logvoicepresencettsid");
 
+                    b.Property<ulong?>("LogWarnsId")
+                        .HasColumnType("bigint unsigned")
+                        .HasColumnName("logwarnsid");
+
                     b.Property<ulong?>("MessageDeletedId")
                         .HasColumnType("bigint unsigned")
                         .HasColumnName("messagedeletedid");

src/NadekoBot/Migrations/Postgresql/20220623090729_stondel-db-cache.cs

@@ -0,0 +1,37 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace NadekoBot.Migrations.PostgreSql
+{
+    public partial class stondeldbcache : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "streamonlinemessages",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    channelid = table.Column<decimal>(type: "numeric(20,0)", nullable: false),
+                    messageid = table.Column<decimal>(type: "numeric(20,0)", nullable: false),
+                    type = table.Column<int>(type: "integer", nullable: false),
+                    name = table.Column<string>(type: "text", nullable: true),
+                    dateadded = table.Column<DateTime>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_streamonlinemessages", x => x.id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "streamonlinemessages");
+        }
+    }
+}

src/NadekoBot/Migrations/Postgresql/20220703194412_logwarns.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NadekoBot.Migrations.PostgreSql
+{
+    public partial class logwarns : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<decimal>(
+                name: "logwarnsid",
+                table: "logsettings",
+                type: "numeric(20,0)",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "logwarnsid",
+                table: "logsettings");
+        }
+    }
+}

src/NadekoBot/Migrations/Postgresql/PostgreSqlContextModelSnapshot.cs

@@ -17,7 +17,7 @@ namespace NadekoBot.Migrations.PostgreSql
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "6.0.5")
+                .HasAnnotation("ProductVersion", "6.0.6")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
@@ -343,6 +343,41 @@ namespace NadekoBot.Migrations.PostgreSql
                     b.ToTable("patrons", (string)null);
                 });
 
+            modelBuilder.Entity("NadekoBot.Db.Models.StreamOnlineMessage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("ChannelId")
+                        .HasColumnType("numeric(20,0)")
+                        .HasColumnName("channelid");
+
+                    b.Property<DateTime?>("DateAdded")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("dateadded");
+
+                    b.Property<decimal>("MessageId")
+                        .HasColumnType("numeric(20,0)")
+                        .HasColumnName("messageid");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id")
+                        .HasName("pk_streamonlinemessages");
+
+                    b.ToTable("streamonlinemessages", (string)null);
+                });
+
             modelBuilder.Entity("NadekoBot.Services.Database.Models.AntiAltSetting", b =>
                 {
                     b.Property<int>("Id")
@@ -1437,6 +1472,10 @@ namespace NadekoBot.Migrations.PostgreSql
                         .HasColumnType("numeric(20,0)")
                         .HasColumnName("logvoicepresencettsid");
 
+                    b.Property<decimal?>("LogWarnsId")
+                        .HasColumnType("numeric(20,0)")
+                        .HasColumnName("logwarnsid");
+
                     b.Property<decimal?>("MessageDeletedId")
                         .HasColumnType("numeric(20,0)")
                         .HasColumnName("messagedeletedid");

src/NadekoBot/Migrations/Sqlite/20220623073903_stondel-db-cache.cs

@@ -0,0 +1,36 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NadekoBot.Migrations
+{
+    public partial class stondeldbcache : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "StreamOnlineMessages",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    ChannelId = table.Column<ulong>(type: "INTEGER", nullable: false),
+                    MessageId = table.Column<ulong>(type: "INTEGER", nullable: false),
+                    Type = table.Column<int>(type: "INTEGER", nullable: false),
+                    Name = table.Column<string>(type: "TEXT", nullable: false),
+                    DateAdded = table.Column<DateTime>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_StreamOnlineMessages", x => x.Id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "StreamOnlineMessages");
+        }
+    }
+}

src/NadekoBot/Migrations/Sqlite/20220703194348_logwarns.cs

@@ -0,0 +1,43 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace NadekoBot.Migrations
+{
+    public partial class logwarns : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "StreamOnlineMessages",
+                type: "TEXT",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "TEXT");
+
+            migrationBuilder.AddColumn<ulong>(
+                name: "LogWarnsId",
+                table: "LogSettings",
+                type: "INTEGER",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "LogWarnsId",
+                table: "LogSettings");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Name",
+                table: "StreamOnlineMessages",
+                type: "TEXT",
+                nullable: false,
+                defaultValue: "",
+                oldClrType: typeof(string),
+                oldType: "TEXT",
+                oldNullable: true);
+        }
+    }
+}

src/NadekoBot/Migrations/Sqlite/NadekoSqliteContextModelSnapshot.cs

@@ -15,7 +15,7 @@ namespace NadekoBot.Migrations
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "6.0.5");
+            modelBuilder.HasAnnotation("ProductVersion", "6.0.6");
 
             modelBuilder.Entity("NadekoBot.Db.Models.BankUser", b =>
                 {
@@ -262,6 +262,32 @@ namespace NadekoBot.Migrations
                     b.ToTable("Patrons");
                 });
 
+            modelBuilder.Entity("NadekoBot.Db.Models.StreamOnlineMessage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<ulong>("ChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<ulong>("MessageId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("StreamOnlineMessages");
+                });
+
             modelBuilder.Entity("NadekoBot.Services.Database.Models.AntiAltSetting", b =>
                 {
                     b.Property<int>("Id")
@@ -1073,6 +1099,9 @@ namespace NadekoBot.Migrations
                     b.Property<ulong?>("LogVoicePresenceTTSId")
                         .HasColumnType("INTEGER");
 
+                    b.Property<ulong?>("LogWarnsId")
+                        .HasColumnType("INTEGER");
+
                     b.Property<ulong?>("MessageDeletedId")
                         .HasColumnType("INTEGER");
 

src/NadekoBot/Modules/Administration/Self/SelfCommands.cs

@@ -335,6 +335,8 @@ public partial class Administration
         {
             try
             {
+                await _client.SetStatusAsync(UserStatus.Invisible);
+                _ =  _client.StopAsync();
                 await ReplyConfirmLocalizedAsync(strs.shutting_down);
             }
             catch
@@ -500,14 +502,6 @@ public partial class Administration
             await ReplyConfirmLocalizedAsync(strs.message_sent);
         }
 
-        [Cmd]
-        [OwnerOnly]
-        public async partial Task ImagesReload()
-        {
-            await _service.ReloadImagesAsync();
-            await ReplyConfirmLocalizedAsync(strs.images_loading);
-        }
-
         [Cmd]
         [OwnerOnly]
         public async partial Task StringsReload()

src/NadekoBot/Modules/Administration/Self/SelfService.cs

@@ -20,7 +20,6 @@ public sealed class SelfService : IExecNoCommand, IReadyExecutor, INService
 
     private ConcurrentDictionary<ulong?, ConcurrentDictionary<int, Timer>> autoCommands = new();
 
-    private readonly IImageCache _imgs;
     private readonly IHttpClientFactory _httpFactory;
     private readonly BotConfigService _bss;
     private readonly IPubSub _pubSub;
@@ -28,7 +27,6 @@ public sealed class SelfService : IExecNoCommand, IReadyExecutor, INService
 
     //keys
     private readonly TypedKey<ActivityPubData> _activitySetKey;
-    private readonly TypedKey<bool> _imagesReloadKey;
     private readonly TypedKey<string> _guildLeaveKey;
 
     public SelfService(
@@ -37,7 +35,6 @@ public sealed class SelfService : IExecNoCommand, IReadyExecutor, INService
         DbService db,
         IBotStrings strings,
         IBotCredentials creds,
-        IDataCache cache,
         IHttpClientFactory factory,
         BotConfigService bss,
         IPubSub pubSub,
@@ -48,20 +45,15 @@ public sealed class SelfService : IExecNoCommand, IReadyExecutor, INService
         _strings = strings;
         _client = client;
         _creds = creds;
-        _imgs = cache.LocalImages;
         _httpFactory = factory;
         _bss = bss;
         _pubSub = pubSub;
         _eb = eb;
         _activitySetKey = new("activity.set");
-        _imagesReloadKey = new("images.reload");
         _guildLeaveKey = new("guild.leave");
 
         HandleStatusChanges();
 
-        if (_client.ShardId == 0)
-            _pubSub.Sub(_imagesReloadKey, async _ => await _imgs.Reload());
-
         _pubSub.Sub(_guildLeaveKey,
             async input =>
             {
@@ -325,9 +317,6 @@ public sealed class SelfService : IExecNoCommand, IReadyExecutor, INService
         uow.SaveChanges();
     }
 
-    public Task ReloadImagesAsync()
-        => _pubSub.Pub(_imagesReloadKey, true);
-
     public bool ForwardMessages()
     {
         var isForwarding = false;

src/NadekoBot/Modules/Administration/ServerLog/ServerLogCommandService.cs

@@ -26,6 +26,7 @@ public sealed class LogCommandService : ILogCommandService, IReadyExecutor
     private readonly IMemoryCache _memoryCache;
 
     private readonly ConcurrentHashSet<ulong> _ignoreMessageIds = new();
+    private readonly UserPunishService _punishService;
 
     public LogCommandService(
         DiscordSocketClient client,
@@ -35,7 +36,8 @@ public sealed class LogCommandService : ILogCommandService, IReadyExecutor
         ProtectionService prot,
         GuildTimezoneService tz,
         IMemoryCache memoryCache,
-        IEmbedBuilderService eb)
+        IEmbedBuilderService eb,
+        UserPunishService punishService)
     {
         _client = client;
         _memoryCache = memoryCache;
@@ -45,6 +47,8 @@ public sealed class LogCommandService : ILogCommandService, IReadyExecutor
         _mute = mute;
         _prot = prot;
         _tz = tz;
+        _punishService = punishService;
+        
         using (var uow = db.GetDbContext())
         {
             var guildIds = client.Guilds.Select(x => x.Id).ToList();
@@ -78,6 +82,8 @@ public sealed class LogCommandService : ILogCommandService, IReadyExecutor
         _mute.UserUnmuted += MuteCommands_UserUnmuted;
 
         _prot.OnAntiProtectionTriggered += TriggeredAntiProtection;
+        
+        _punishService.OnUserWarned += PunishServiceOnOnUserWarned;
     }
 
     public async Task OnReadyAsync()
@@ -183,6 +189,30 @@ public sealed class LogCommandService : ILogCommandService, IReadyExecutor
         GuildLogSettings.AddOrUpdate(guildId, _ => logSetting, (_, _) => logSetting);
     }
 
+    
+
+    private async Task PunishServiceOnOnUserWarned(Warning arg)
+    {
+        if (!GuildLogSettings.TryGetValue(arg.GuildId, out var logSetting) || logSetting.LogWarnsId is null)
+            return;
+        
+        var g = _client.GetGuild(arg.GuildId);
+        
+        ITextChannel? logChannel;
+        if ((logChannel = await TryGetLogChannel(g, logSetting, LogType.UserWarned)) is null)
+            return;
+
+        var embed = _eb.Create()
+                       .WithOkColor()
+                       .WithTitle($"⚠️ User Warned")
+                       .WithDescription($"<@{arg.UserId}> | {arg.UserId}")
+                       .AddField("Mod", arg.Moderator)
+                       .AddField("Reason", string.IsNullOrWhiteSpace(arg.Reason) ? "-" : arg.Reason, true)
+                       .WithFooter(CurrentTime(g));
+
+        await logChannel.EmbedAsync(embed);
+    }
+    
     private Task _client_UserUpdated(SocketUser before, SocketUser uAfter)
     {
         _ = Task.Run(async () =>
@@ -296,6 +326,9 @@ public sealed class LogCommandService : ILogCommandService, IReadyExecutor
                     channelId = logSetting.LogVoicePresenceTTSId =
                         logSetting.LogVoicePresenceTTSId is null ? cid : default;
                     break;
+                case LogType.UserWarned:
+                    channelId = logSetting.LogWarnsId = logSetting.LogWarnsId is null ? cid : default;
+                    break;
             }
 
             uow.SaveChanges();
@@ -945,11 +978,25 @@ public sealed class LogCommandService : ILogCommandService, IReadyExecutor
                 ITextChannel? logChannel;
                 if ((logChannel = await TryGetLogChannel(guild, logSetting, LogType.UserBanned)) == null)
                     return;
+
+
+                string? reason = null;
+                try
+                {
+                    var ban = await guild.GetBanAsync(usr);
+                    reason = ban?.Reason;
+                }
+                catch
+                {
+                    
+                }
+                
                 var embed = _eb.Create()
                                .WithOkColor()
                                .WithTitle("🚫 " + GetText(logChannel.Guild, strs.user_banned))
                                .WithDescription(usr.ToString()!)
                                .AddField("Id", usr.Id.ToString())
+                               .AddField("Reason", string.IsNullOrWhiteSpace(reason) ? "-" : reason)
                                .WithFooter(CurrentTime(guild));
 
                 var avatarUrl = usr.GetAvatarUrl();
@@ -1130,6 +1177,9 @@ public sealed class LogCommandService : ILogCommandService, IReadyExecutor
             case LogType.UserMuted:
                 id = logSetting.UserMutedId;
                 break;
+            case LogType.UserWarned:
+                id = logSetting.LogWarnsId;
+                break;
         }
 
         if (id is null or 0)
@@ -1200,6 +1250,9 @@ public sealed class LogCommandService : ILogCommandService, IReadyExecutor
             case LogType.VoicePresenceTts:
                 newLogSetting.LogVoicePresenceTTSId = null;
                 break;
+            case LogType.UserWarned:
+                newLogSetting.LogWarnsId = null;
+                break;
         }
 
         GuildLogSettings.AddOrUpdate(guildId, newLogSetting, (_, _) => newLogSetting);

src/NadekoBot/Modules/Administration/UserPunish/UserPunishCommands.cs

@@ -341,7 +341,8 @@ public partial class Administration
         public async partial Task WarnPunish(int number, PunishmentAction punish, StoopidTime time = null)
         {
             // this should never happen. Addrole has its own method with higher priority
-            if (punish == PunishmentAction.AddRole)
+            // also disallow warn punishment for getting warned
+            if (punish is PunishmentAction.AddRole or PunishmentAction.Warn)
                 return;
 
             var success = _service.WarnPunish(ctx.Guild.Id, number, punish, time);

src/NadekoBot/Modules/Administration/UserPunish/UserPunishService.cs

@@ -18,6 +18,8 @@ public class UserPunishService : INService, IReadyExecutor
     private readonly BotConfigService _bcs;
     private readonly DiscordSocketClient _client;
 
+    public event Func<Warning, Task> OnUserWarned = static delegate { return Task.CompletedTask; };
+
     public UserPunishService(
         MuteService mute,
         DbService db,
@@ -93,6 +95,8 @@ public class UserPunishService : INService, IReadyExecutor
             await uow.SaveChangesAsync();
         }
 
+        _ = OnUserWarned(warn);
+
         var totalCount = previousCount + weight;
         
         var p = ps.Where(x => x.Count > previousCount && x.Count <= totalCount)
@@ -185,6 +189,9 @@ public class UserPunishService : INService, IReadyExecutor
                         guild.Id);
                 }
 
+                break;
+            case PunishmentAction.Warn:
+                await Warn(guild, user.Id, mod, 1, reason);
                 break;
         }
     }

src/NadekoBot/Modules/Administration/VcRole/VcRoleService.cs

@@ -8,7 +8,7 @@ namespace NadekoBot.Modules.Administration.Services;
 public class VcRoleService : INService
 {
     public ConcurrentDictionary<ulong, ConcurrentDictionary<ulong, IRole>> VcRoles { get; }
-    public ConcurrentDictionary<ulong, ConcurrentQueue<(bool, IGuildUser, IRole)>> ToAssign { get; }
+    public ConcurrentDictionary<ulong, System.Collections.Concurrent.ConcurrentQueue<(bool, IGuildUser, IRole)>> ToAssign { get; }
     private readonly DbService _db;
     private readonly DiscordSocketClient _client;
 
@@ -37,7 +37,7 @@ public class VcRoleService : INService
         {
             while (true)
             {
-                Task Selector(ConcurrentQueue<(bool, IGuildUser, IRole)> queue)
+                Task Selector(System.Collections.Concurrent.ConcurrentQueue<(bool, IGuildUser, IRole)> queue)
                 {
                     return Task.Run(async () =>
                     {
@@ -203,7 +203,7 @@ public class VcRoleService : INService
 
     private void Assign(bool v, SocketGuildUser gusr, IRole role)
     {
-        var queue = ToAssign.GetOrAdd(gusr.Guild.Id, new ConcurrentQueue<(bool, IGuildUser, IRole)>());
+        var queue = ToAssign.GetOrAdd(gusr.Guild.Id, new System.Collections.Concurrent.ConcurrentQueue<(bool, IGuildUser, IRole)>());
         queue.Enqueue((v, gusr, role));
     }
 }

src/NadekoBot/Modules/Gambling/DiceRoll/DiceRollCommands.cs

@@ -19,8 +19,8 @@ public partial class Gambling
         private static readonly char[] _fateRolls = { '-', ' ', '+' };
         private readonly IImageCache _images;
 
-        public DiceRollCommands(IDataCache data)
-            => _images = data.LocalImages;
+        public DiceRollCommands(ImageCache images)
+            => _images = images;
 
         [Cmd]
         public async partial Task Roll()
@@ -31,10 +31,10 @@ public partial class Gambling
             var num1 = gen / 10;
             var num2 = gen % 10;
 
-            using var img1 = GetDice(num1);
-            using var img2 = GetDice(num2);
+            using var img1 = await GetDiceAsync(num1);
+            using var img2 = await GetDiceAsync(num2);
             using var img = new[] { img1, img2 }.Merge(out var format);
-            await using var ms = img.ToStream(format);
+            await using var ms = await img.ToStreamAsync(format);
             await ctx.Channel.SendFileAsync(ms,
                 $"dice.{format.FileExtensions.First()}",
                 Format.Bold(ctx.User.ToString()) + " " + GetText(strs.dice_rolled(Format.Code(gen.ToString()))));
@@ -96,7 +96,7 @@ public partial class Gambling
                 else
                     toInsert = dice.Count;
 
-                dice.Insert(toInsert, GetDice(randomNumber));
+                dice.Insert(toInsert, await GetDiceAsync(randomNumber));
                 values.Insert(toInsert, randomNumber);
             }
 
@@ -195,20 +195,19 @@ public partial class Gambling
             await ReplyConfirmLocalizedAsync(strs.dice_rolled(Format.Bold(rolled.ToString())));
         }
 
-        private Image<Rgba32> GetDice(int num)
+        private async Task<Image<Rgba32>> GetDiceAsync(int num)
         {
             if (num is < 0 or > 10)
                 throw new ArgumentOutOfRangeException(nameof(num));
 
             if (num == 10)
             {
-                var images = _images.Dice;
-                using var imgOne = Image.Load(images[1]);
-                using var imgZero = Image.Load(images[0]);
+                using var imgOne = Image.Load(await _images.GetDiceAsync(1));
+                using var imgZero = Image.Load(await _images.GetDiceAsync(0));
                 return new[] { imgOne, imgZero }.Merge();
             }
 
-            return Image.Load(_images.Dice[num]);
+            return Image.Load(await _images.GetDiceAsync(num));
         }
     }
 }

src/NadekoBot/Modules/Gambling/Draw/DrawCommands.cs

@@ -14,8 +14,8 @@ public partial class Gambling
         private static readonly ConcurrentDictionary<IGuild, Deck> _allDecks = new();
         private readonly IImageCache _images;
 
-        public DrawCommands(IDataCache data)
-            => _images = data.LocalImages;
+        public DrawCommands(IImageCache images)
+            => _images = images;
 
         private async Task<(Stream ImageStream, string ToSend)> InternalDraw(int num, ulong? guildId = null)
         {
@@ -43,7 +43,8 @@ public partial class Gambling
 
                 var currentCard = cards.Draw();
                 cardObjects.Add(currentCard);
-                images.Add(Image.Load(_images.GetCard(currentCard.ToString().ToLowerInvariant().Replace(' ', '_'))));
+                var cardName = currentCard.ToString().ToLowerInvariant().Replace(' ', '_');
+                images.Add(Image.Load(await File.ReadAllBytesAsync($"data/images/cards/{cardName}.jpg")));
             }
 
             using var img = images.Merge();

src/NadekoBot/Modules/Gambling/Events/GameStatusEvent.cs

@@ -1,5 +1,6 @@
 #nullable disable
 using NadekoBot.Services.Database.Models;
+using System.Collections.Concurrent;
 
 namespace NadekoBot.Modules.Gambling.Common.Events;
 

src/NadekoBot/Modules/Gambling/Events/ReactionEvent.cs

@@ -20,7 +20,7 @@ public class ReactionEvent : ICurrencyEvent
     private readonly bool _isPotLimited;
     private readonly ITextChannel _channel;
     private readonly ConcurrentHashSet<ulong> _awardedUsers = new();
-    private readonly ConcurrentQueue<ulong> _toAward = new();
+    private readonly System.Collections.Concurrent.ConcurrentQueue<ulong> _toAward = new();
     private readonly Timer _t;
     private readonly Timer _timeout;
     private readonly bool _noRecentlyJoinedServer;

src/NadekoBot/Modules/Gambling/FlipCoin/FlipCoinCommands.cs

@@ -25,11 +25,17 @@ public partial class Gambling
         private static readonly NadekoRandom _rng = new();
         private readonly IImageCache _images;
         private readonly ICurrencyService _cs;
+        private readonly ImagesConfig _ic;
 
-        public FlipCoinCommands(IDataCache data, ICurrencyService cs, GamblingConfigService gss)
+        public FlipCoinCommands(
+            IImageCache images,
+            ImagesConfig ic,
+            ICurrencyService cs,
+            GamblingConfigService gss)
             : base(gss)
         {
-            _images = data.LocalImages;
+            _ic = ic;
+            _images = images;
             _cs = cs;
         }
 
@@ -47,8 +53,8 @@ public partial class Gambling
             var imgs = new Image<Rgba32>[count];
             for (var i = 0; i < count; i++)
             {
-                var headsArr = _images.Heads[_rng.Next(0, _images.Heads.Count)];
-                var tailsArr = _images.Tails[_rng.Next(0, _images.Tails.Count)];
+                var headsArr = await _images.GetHeadsImageAsync();
+                var tailsArr = await _images.GetTailsImageAsync();
                 if (_rng.Next(0, 10) < 5)
                 {
                     imgs[i] = Image.Load(headsArr);
@@ -94,7 +100,7 @@ public partial class Gambling
 
             BetFlipGuess result;
             Uri imageToSend;
-            var coins = _images.ImageUrls.Coins;
+            var coins = _ic.Data.Coins;
             if (_rng.Next(0, 1000) <= 499)
             {
                 imageToSend = coins.Heads[_rng.Next(0, coins.Heads.Length)];

src/NadekoBot/Modules/Gambling/Gambling.cs

@@ -7,6 +7,7 @@ using NadekoBot.Modules.Utility.Patronage;
 using NadekoBot.Modules.Gambling.Bank;
 using NadekoBot.Modules.Gambling.Common;
 using NadekoBot.Modules.Gambling.Services;
+using NadekoBot.Modules.Utility.Services;
 using NadekoBot.Services.Currency;
 using NadekoBot.Services.Database.Models;
 using System.Collections.Immutable;
@@ -38,33 +39,33 @@ public partial class Gambling : GamblingModule<GamblingService>
 
     private readonly DbService _db;
     private readonly ICurrencyService _cs;
-    private readonly IDataCache _cache;
     private readonly DiscordSocketClient _client;
     private readonly NumberFormatInfo _enUsCulture;
     private readonly DownloadTracker _tracker;
     private readonly GamblingConfigService _configService;
     private readonly IBankService _bank;
     private readonly IPatronageService _ps;
+    private readonly RemindService _remind;
 
     private IUserMessage rdMsg;
 
     public Gambling(
         DbService db,
         ICurrencyService currency,
-        IDataCache cache,
         DiscordSocketClient client,
         DownloadTracker tracker,
         GamblingConfigService configService,
         IBankService bank,
-        IPatronageService ps)
+        IPatronageService ps,
+        RemindService remind)
         : base(configService)
     {
         _db = db;
         _cs = currency;
-        _cache = cache;
         _client = client;
         _bank = bank;
         _ps = ps;
+        _remind = remind;
 
         _enUsCulture = new CultureInfo("en-US", false).NumberFormat;
         _enUsCulture.NumberDecimalDigits = 0;
@@ -112,7 +113,40 @@ public partial class Gambling : GamblingModule<GamblingService>
         Key = "timely:extra_percent",
         PrettyName = "Timely"
     };
-    
+
+    public class RemindMeInteraction : NInteraction
+    {
+        public RemindMeInteraction(
+            [NotNull] DiscordSocketClient client,
+            ulong userId,
+            [NotNull] Func<SocketMessageComponent, Task> action)
+            : base(client, userId, action)
+        {
+        }
+
+        protected override NadekoInteractionData Data
+            => new NadekoInteractionData(
+                Emote: Emoji.Parse("⏰"),
+                CustomId: "timely:remind_me",
+                Text: "Remind me"
+            );
+    }
+
+    private Func<SocketMessageComponent, Task> RemindTimelyAction(DateTime when)
+        => async smc =>
+        {
+            var tt = TimestampTag.FromDateTime(when, TimestampTagStyles.Relative);
+
+            await _remind.AddReminderAsync(ctx.User.Id,
+                ctx.User.Id,
+                ctx.Guild.Id,
+                true,
+                when,
+                GetText(strs.timely_time));
+
+            await smc.RespondConfirmAsync(_eb, GetText(strs.remind_timely(tt)), ephemeral: true);
+        };
+
     [Cmd]
     public async partial Task Timely()
     {
@@ -124,7 +158,7 @@ public partial class Gambling : GamblingModule<GamblingService>
             return;
         }
 
-        if (_cache.AddTimelyClaim(ctx.User.Id, period) is { } rem)
+        if (await _service.ClaimTimelyAsync(ctx.User.Id, period) is { } rem)
         {
             var now = DateTime.UtcNow;
             var relativeTag = TimestampTag.FromDateTime(now.Add(rem), TimestampTagStyles.Relative);
@@ -138,14 +172,18 @@ public partial class Gambling : GamblingModule<GamblingService>
 
         await _cs.AddAsync(ctx.User.Id, val, new("timely", "claim"));
 
-        await ReplyConfirmLocalizedAsync(strs.timely(N(val), period));
+        var inter = new RemindMeInteraction(_client,
+            ctx.User.Id,
+            RemindTimelyAction(DateTime.UtcNow.Add(TimeSpan.FromHours(period))));
+        
+        await ReplyConfirmLocalizedAsync(strs.timely(N(val), period), inter.GetInteraction());
     }
 
     [Cmd]
     [OwnerOnly]
     public async partial Task TimelyReset()
     {
-        _cache.RemoveAllTimelyClaims();
+        await _service.RemoveAllTimelyClaimsAsync();
         await ReplyConfirmLocalizedAsync(strs.timely_reset);
     }
 

src/NadekoBot/Modules/Gambling/GamblingService.cs

@@ -1,16 +1,13 @@
 #nullable disable
 using LinqToDB;
 using LinqToDB.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore;
 using NadekoBot.Common.ModuleBehaviors;
 using NadekoBot.Db;
 using NadekoBot.Db.Models;
-using NadekoBot.Migrations;
 using NadekoBot.Modules.Gambling.Common;
 using NadekoBot.Modules.Gambling.Common.Connect4;
 using NadekoBot.Modules.Gambling.Common.Slot;
 using NadekoBot.Modules.Gambling.Common.WheelOfFortune;
-using Newtonsoft.Json;
 
 namespace NadekoBot.Modules.Gambling.Services;
 
@@ -22,7 +19,7 @@ public class GamblingService : INService, IReadyExecutor
     private readonly ICurrencyService _cs;
     private readonly Bot _bot;
     private readonly DiscordSocketClient _client;
-    private readonly IDataCache _cache;
+    private readonly IBotCache _cache;
     private readonly GamblingConfigService _gss;
 
     public GamblingService(
@@ -30,7 +27,7 @@ public class GamblingService : INService, IReadyExecutor
         Bot bot,
         ICurrencyService cs,
         DiscordSocketClient client,
-        IDataCache cache,
+        IBotCache cache,
         GamblingConfigService gss)
     {
         _db = db;
@@ -73,6 +70,7 @@ public class GamblingService : INService, IReadyExecutor
         }
     }
 
+    private static readonly TypedKey<long> _curDecayKey = new("currency:last_decay");
     private async Task CurrencyDecayLoopAsync()
     {
         if (_bot.Client.ShardId != 0)
@@ -88,11 +86,16 @@ public class GamblingService : INService, IReadyExecutor
                 if (config.Decay.Percent is <= 0 or > 1 || maxDecay < 0)
                     continue;
 
+                var now = DateTime.UtcNow;
+                
                 await using var uow = _db.GetDbContext();
-                var lastCurrencyDecay = _cache.GetLastCurrencyDecay();
+                var result = await _cache.GetAsync(_curDecayKey);
 
-                if (DateTime.UtcNow - lastCurrencyDecay < TimeSpan.FromHours(config.Decay.HourInterval))
+                if (result.TryPickT0(out var bin, out _)
+                    && (now - DateTime.FromBinary(bin) < TimeSpan.FromHours(config.Decay.HourInterval)))
+                {
                     continue;
+                }
 
                 Log.Information(@"Decaying users' currency - decay: {ConfigDecayPercent}% 
                                     | max: {MaxDecay} 
@@ -115,8 +118,9 @@ public class GamblingService : INService, IReadyExecutor
                                      : old.CurrencyAmount - maxDecay 
                          });
 
-                _cache.SetLastCurrencyDecay();
                 await uow.SaveChangesAsync();
+
+                await _cache.AddAsync(_curDecayKey, now.ToBinary());
             }
             catch (Exception ex)
             {
@@ -161,60 +165,100 @@ public class GamblingService : INService, IReadyExecutor
         return toReturn;
     }
 
+    private static readonly TypedKey<EconomyResult> _ecoKey = new("nadeko:economy");
+
     public async Task<EconomyResult> GetEconomyAsync()
     {
-        if (_cache.TryGetEconomy(out var data))
-        {
-            try
+        var data = await _cache.GetOrAddAsync(_ecoKey,
+            async () =>
             {
-                return JsonConvert.DeserializeObject<EconomyResult>(data);
-            }
-            catch { }
-        }
+                await using var uow = _db.GetDbContext();
+                var cash = uow.DiscordUser.GetTotalCurrency();
+                var onePercent = uow.DiscordUser.GetTopOnePercentCurrency(_client.CurrentUser.Id);
+                decimal planted = uow.PlantedCurrency.AsQueryable().Sum(x => x.Amount);
+                var waifus = uow.WaifuInfo.GetTotalValue();
+                var bot = uow.DiscordUser.GetUserCurrency(_client.CurrentUser.Id);
+                decimal bank = await uow.GetTable<BankUser>()
+                                        .SumAsyncLinqToDB(x => x.Balance);
 
-        decimal cash;
-        decimal onePercent;
-        decimal planted;
-        decimal waifus;
-        decimal bank;
-        long bot;
+                var result = new EconomyResult
+                {
+                    Cash = cash,
+                    Planted = planted,
+                    Bot = bot,
+                    Waifus = waifus,
+                    OnePercent = onePercent,
+                    Bank = bank
+                };
 
-        using (var uow = _db.GetDbContext())
-        {
-            cash = uow.DiscordUser.GetTotalCurrency();
-            onePercent = uow.DiscordUser.GetTopOnePercentCurrency(_client.CurrentUser.Id);
-            planted = uow.PlantedCurrency.AsQueryable().Sum(x => x.Amount);
-            waifus = uow.WaifuInfo.GetTotalValue();
-            bot = uow.DiscordUser.GetUserCurrency(_client.CurrentUser.Id);
-            bank = await uow.GetTable<BankUser>()
-                      .SumAsyncLinqToDB(x => x.Balance);
-        }
+                return result;
+            },
+            TimeSpan.FromMinutes(3));
 
-        var result = new EconomyResult
-        {
-            Cash = cash,
-            Planted = planted,
-            Bot = bot,
-            Waifus = waifus,
-            OnePercent = onePercent,
-            Bank = bank
-        };
-
-        _cache.SetEconomy(JsonConvert.SerializeObject(result));
-        return result;
+        return data;
     }
 
     public Task<WheelOfFortuneGame.Result> WheelOfFortuneSpinAsync(ulong userId, long bet)
         => new WheelOfFortuneGame(userId, bet, _gss.Data, _cs).SpinAsync();
 
 
-    public struct EconomyResult
+    private static readonly SemaphoreSlim _timelyLock = new (1, 1);
+
+    private static TypedKey<Dictionary<ulong, long>> _timelyKey
+        = new("timely:claims");
+    public async Task<TimeSpan?> ClaimTimelyAsync(ulong userId, int period)
     {
-        public decimal Cash { get; set; }
-        public decimal Planted { get; set; }
-        public decimal Waifus { get; set; }
-        public decimal OnePercent { get; set; }
-        public decimal Bank { get; set; }
-        public long Bot { get; set; }
+        if (period == 0)
+            return null;
+
+        await _timelyLock.WaitAsync();
+        try
+        {
+            // get the dictionary from the cache or get a new one
+            var dict = (await _cache.GetOrAddAsync(_timelyKey,
+                () => Task.FromResult(new Dictionary<ulong, long>())))!;
+
+            var now = DateTime.UtcNow;
+            var nowB = now.ToBinary();
+
+            // try to get users last claim
+            if (!dict.TryGetValue(userId, out var lastB))
+                lastB = dict[userId] = now.ToBinary();
+
+            var diff = now - DateTime.FromBinary(lastB);
+
+            // if its now, or too long ago => success
+            if (lastB == nowB || diff > period.Hours())
+            {
+                // update the cache
+                dict[userId] = nowB;
+                await _cache.AddAsync(_timelyKey, dict);
+                
+                return null;
+            }
+            else
+            {
+                // otherwise return the remaining time
+                return period.Hours() - diff;
+            }
+        }
+        finally
+        {
+            _timelyLock.Release();
+        }
+    }
+
+    public async Task RemoveAllTimelyClaimsAsync()
+        => await _cache.RemoveAsync(_timelyKey);
+
+
+    public readonly struct EconomyResult
+    {
+        public decimal Cash { get; init; }
+        public decimal Planted { get; init; }
+        public decimal Waifus { get; init; }
+        public decimal OnePercent { get; init; }
+        public decimal Bank { get; init; }
+        public long Bot { get; init; }
     }
 }

src/NadekoBot/Modules/Gambling/PlantPick/PlantPickService.cs

@@ -16,7 +16,7 @@ namespace NadekoBot.Modules.Gambling.Services;
 public class PlantPickService : INService, IExecNoCommand
 {
     //channelId/last generation
-    public ConcurrentDictionary<ulong, DateTime> LastGenerations { get; } = new();
+    public ConcurrentDictionary<ulong, long> LastGenerations { get; } = new();
     private readonly DbService _db;
     private readonly IBotStrings _strings;
     private readonly IImageCache _images;
@@ -34,7 +34,7 @@ public class PlantPickService : INService, IExecNoCommand
         DbService db,
         CommandHandler cmd,
         IBotStrings strings,
-        IDataCache cache,
+        IImageCache images,
         FontProvider fonts,
         ICurrencyService cs,
         CommandHandler cmdHandler,
@@ -43,7 +43,7 @@ public class PlantPickService : INService, IExecNoCommand
     {
         _db = db;
         _strings = strings;
-        _images = cache.LocalImages;
+        _images = images;
         _fonts = fonts;
         _cs = cs;
         _cmdHandler = cmdHandler;
@@ -110,30 +110,21 @@ public class PlantPickService : INService, IExecNoCommand
     /// <param name="pass">Optional password to add to top left corner.</param>
     /// <param name="extension">Extension of the file, defaults to png</param>
     /// <returns>Stream of the currency image</returns>
-    public Stream GetRandomCurrencyImage(string pass, out string extension)
+    public async Task<(Stream, string)> GetRandomCurrencyImageAsync(string pass)
     {
-        // get a random currency image bytes
-        var rng = new NadekoRandom();
-        var curImg = _images.Currency[rng.Next(0, _images.Currency.Count)];
+        var curImg = await _images.GetCurrencyImageAsync();
 
         if (string.IsNullOrWhiteSpace(pass))
         {
             // determine the extension
-            using (_ = Image.Load(curImg, out var format))
-            {
-                extension = format.FileExtensions.FirstOrDefault() ?? "png";
-            }
+            using var load = _ = Image.Load(curImg, out var format);
 
             // return the image
-            return curImg.ToStream();
+            return (curImg.ToStream(), format.FileExtensions.FirstOrDefault() ?? "png");
         }
 
         // get the image stream and extension
-        var (s, ext) = AddPassword(curImg, pass);
-        // set the out extension parameter to the extension we've got
-        extension = ext;
-        // return the image
-        return s;
+        return AddPassword(curImg, pass);
     }
 
     /// <summary>
@@ -184,15 +175,15 @@ public class PlantPickService : INService, IExecNoCommand
             try
             {
                 var config = _gss.Data;
-                var lastGeneration = LastGenerations.GetOrAdd(channel.Id, DateTime.MinValue);
+                var lastGeneration = LastGenerations.GetOrAdd(channel.Id, DateTime.MinValue.ToBinary());
                 var rng = new NadekoRandom();
 
                 if (DateTime.UtcNow - TimeSpan.FromSeconds(config.Generation.GenCooldown)
-                    < lastGeneration) //recently generated in this channel, don't generate again
+                    < DateTime.FromBinary(lastGeneration)) //recently generated in this channel, don't generate again
                     return;
 
                 var num = rng.Next(1, 101) + (config.Generation.Chance * 100);
-                if (num > 100 && LastGenerations.TryUpdate(channel.Id, DateTime.UtcNow, lastGeneration))
+                if (num > 100 && LastGenerations.TryUpdate(channel.Id, DateTime.UtcNow.ToBinary(), lastGeneration))
                 {
                     var dropAmount = config.Generation.MinAmount;
                     var dropAmountMax = config.Generation.MaxAmount;
@@ -214,10 +205,10 @@ public class PlantPickService : INService, IExecNoCommand
                         var pw = config.Generation.HasPassword ? GenerateCurrencyPassword().ToUpperInvariant() : null;
 
                         IUserMessage sent;
-                        await using (var stream = GetRandomCurrencyImage(pw, out var ext))
-                        {
+                        var (stream, ext) = await GetRandomCurrencyImageAsync(pw);
+
+                        await using (stream)
                             sent = await channel.SendFileAsync(stream, $"currency_image.{ext}", toSend);
-                        }
 
                         await AddPlantToDatabase(channel.GuildId,
                             channel.Id,
@@ -278,7 +269,7 @@ public class PlantPickService : INService, IExecNoCommand
                 if (amount > 0)
                     // give the picked currency to the user
                     await _cs.AddAsync(uid, amount, new("currency", "collect"));
-                uow.SaveChanges();
+                await uow.SaveChangesAsync();
             }
 
             try
@@ -316,11 +307,14 @@ public class PlantPickService : INService, IExecNoCommand
                 msgToSend += " " + GetText(gid, strs.pick_sn(prefix));
 
             //get the image
-            await using var stream = GetRandomCurrencyImage(pass, out var ext);
+            var (stream, ext) = await GetRandomCurrencyImageAsync(pass);
             // send it
-            var msg = await ch.SendFileAsync(stream, $"img.{ext}", msgToSend);
-            // return sent message's id (in order to be able to delete it when it's picked)
-            return msg.Id;
+            await using (stream)
+            {
+                var msg = await ch.SendFileAsync(stream, $"img.{ext}", msgToSend);
+                // return sent message's id (in order to be able to delete it when it's picked)
+                return msg.Id;
+            }
         }
         catch
         {

src/NadekoBot/Modules/Gambling/Slot/SlotCommands.cs

@@ -32,13 +32,13 @@ public partial class Gambling
         private readonly DbService _db;
 
         public SlotCommands(
-            IDataCache data,
+            ImageCache images,
             FontProvider fonts,
             DbService db,
             GamblingConfigService gamb)
             : base(gamb)
         {
-            _images = data.LocalImages;
+            _images = images;
             _fonts = fonts;
             _db = db;
         }
@@ -130,7 +130,8 @@ public partial class Gambling
                                   ?? 0;
                 }
 
-                using (var bgImage = Image.Load<Rgba32>(_images.SlotBackground, out _))
+                var slotBg = await _images.GetSlotBgAsync();
+                using (var bgImage = Image.Load<Rgba32>(slotBg, out _))
                 {
                     var numbers = new int[3];
                     result.Rolls.CopyTo(numbers, 0);
@@ -184,7 +185,7 @@ public partial class Gambling
 
                     for (var i = 0; i < 3; i++)
                     {
-                        using var img = Image.Load(_images.SlotEmojis[numbers[i]]);
+                        using var img = Image.Load(await _images.GetSlotEmojiAsync(numbers[i]));
                         bgImage.Mutate(x => x.DrawImage(img, new Point(148 + (105 * i), 217), 1f));
                     }
 
@@ -201,7 +202,7 @@ public partial class Gambling
                             msg = GetText(strs.slot_jackpot(30));
                     }
 
-                    await using (var imgStream = bgImage.ToStream())
+                    await using (var imgStream = await bgImage.ToStreamAsync())
                     {
                         await ctx.Channel.SendFileAsync(imgStream,
                             "result.png",

src/NadekoBot/Modules/Gambling/Waifus/WaifuService.cs

@@ -1,5 +1,6 @@
 #nullable disable
 using LinqToDB;
+using LinqToDB.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Common.ModuleBehaviors;
 using NadekoBot.Db;
@@ -14,7 +15,7 @@ public class WaifuService : INService, IReadyExecutor
 {
     private readonly DbService _db;
     private readonly ICurrencyService _cs;
-    private readonly IDataCache _cache;
+    private readonly IBotCache _cache;
     private readonly GamblingConfigService _gss;
     private readonly IBotCredentials _creds;
     private readonly DiscordSocketClient _client;
@@ -22,7 +23,7 @@ public class WaifuService : INService, IReadyExecutor
     public WaifuService(
         DbService db,
         ICurrencyService cs,
-        IDataCache cache,
+        IBotCache cache,
         GamblingConfigService gss,
         IBotCredentials creds,
         DiscordSocketClient client)
@@ -236,8 +237,13 @@ public class WaifuService : INService, IReadyExecutor
             var newAff = target is null ? null : uow.GetOrCreateUser(target);
             if (w?.Affinity?.UserId == target?.Id)
             {
+                return (null, false, null);
             }
-            else if (!_cache.TryAddAffinityCooldown(user.Id, out remaining))
+
+            remaining = await _cache.GetRatelimitAsync(GetAffinityKey(user.Id),
+                30.Minutes());
+            
+            if (remaining is not null)
             {
             }
             else if (w is null)
@@ -294,6 +300,12 @@ public class WaifuService : INService, IReadyExecutor
         return uow.WaifuInfo.GetWaifuUserId(ownerId, name);
     }
 
+    private static TypedKey<long> GetDivorceKey(ulong userId)
+        => new($"waifu:divorce_cd:{userId}");
+    
+    private static TypedKey<long> GetAffinityKey(ulong userId)
+        => new($"waifu:affinity:{userId}");
+    
     public async Task<(WaifuInfo, DivorceResult, long, TimeSpan?)> DivorceWaifuAsync(IUser user, ulong targetId)
     {
         DivorceResult result;
@@ -305,10 +317,15 @@ public class WaifuService : INService, IReadyExecutor
             w = uow.WaifuInfo.ByWaifuUserId(targetId);
             if (w?.Claimer is null || w.Claimer.UserId != user.Id)
                 result = DivorceResult.NotYourWife;
-            else if (!_cache.TryAddDivorceCooldown(user.Id, out remaining))
-                result = DivorceResult.Cooldown;
             else
             {
+                remaining = await _cache.GetRatelimitAsync(GetDivorceKey(user.Id), 6.Hours());
+                if (remaining is TimeSpan rem)
+                {
+                    result = DivorceResult.Cooldown;
+                    return (w, result, amount, rem);
+                }
+
                 amount = w.Price / 2;
 
                 if (w.Affinity?.UserId == user.Id)
@@ -486,13 +503,13 @@ public class WaifuService : INService, IReadyExecutor
                    .ToList();
     }
 
+    private static readonly TypedKey<long> _waifuDecayKey = $"waifu:last_decay";
     public async Task OnReadyAsync()
     {
         // only decay waifu values from shard 0
         if (_client.ShardId != 0)
             return;
 
-        var redisKey = $"{_creds.RedisKey()}_last_waifu_decay";
         while (true)
         {
             try
@@ -504,28 +521,31 @@ public class WaifuService : INService, IReadyExecutor
                 if (multi is < 0f or > 1f || decayInterval < 0)
                     continue;
 
-                var val = await _cache.Redis.GetDatabase().StringGetAsync(redisKey);
-                if (val != default)
+                var now = DateTime.UtcNow;
+                var nowB = now.ToBinary();
+
+                var result = await _cache.GetAsync(_waifuDecayKey);
+                
+                if (result.TryGetValue(out var val))
                 {
-                    var lastDecay = DateTime.FromBinary((long)val);
+                    var lastDecay = DateTime.FromBinary(val);
                     var toWait = decayInterval.Hours() - (DateTime.UtcNow - lastDecay);
 
                     if (toWait > 0.Hours())
                         continue;
                 }
 
-                await _cache.Redis.GetDatabase().StringSetAsync(redisKey, DateTime.UtcNow.ToBinary());
+                await _cache.AddAsync(_waifuDecayKey, nowB);
 
                 await using var uow = _db.GetDbContext();
 
-                await uow.WaifuInfo
+                await uow.GetTable<WaifuInfo>()
                          .Where(x => x.Price > minPrice && x.ClaimerId == null)
                          .UpdateAsync(old => new()
                          {
                              Price = (long)(old.Price * multi)
                          });
 
-                await uow.SaveChangesAsync();
             }
             catch (Exception ex)
             {

src/NadekoBot/Modules/Games/Games.cs

@@ -14,9 +14,9 @@ public partial class Games : NadekoModule<GamesService>
     private readonly IHttpClientFactory _httpFactory;
     private readonly Random _rng = new();
 
-    public Games(IDataCache data, IHttpClientFactory factory)
+    public Games(IImageCache images, IHttpClientFactory factory)
     {
-        _images = data.LocalImages;
+        _images = images;
         _httpFactory = factory;
     }
 

src/NadekoBot/Modules/Games/GirlRating.cs

@@ -28,11 +28,12 @@ public class GirlRating
         Roll = roll;
         Advice = advice; // convenient to have it here, even though atm there are only few different ones.
 
-        Stream = new(() =>
+        Stream = new(async () =>
         {
             try
             {
-                using var img = Image.Load(_images.RategirlMatrix);
+                var bgBytes = await _images.GetRategirlBgAsync();
+                using var img = Image.Load(bgBytes);
                 const int minx = 35;
                 const int miny = 385;
                 const int length = 345;
@@ -40,7 +41,8 @@ public class GirlRating
                 var pointx = (int)(minx + (length * (Hot / 10)));
                 var pointy = (int)(miny - (length * ((Crazy - 4) / 6)));
 
-                using (var pointImg = Image.Load(_images.RategirlDot))
+                var dotBytes = await _images.GetRategirlDotAsync(); 
+                using (var pointImg = Image.Load(dotBytes))
                 {
                     img.Mutate(x => x.DrawImage(pointImg, new(pointx - 10, pointy - 10), new GraphicsOptions()));
                 }

src/NadekoBot/Modules/Games/Trivia/TriviaCommands.cs

@@ -9,14 +9,14 @@ public partial class Games
     [Group]
     public partial class TriviaCommands : NadekoModule<GamesService>
     {
-        private readonly IDataCache _cache;
+        private readonly ILocalDataCache _cache;
         private readonly ICurrencyService _cs;
         private readonly GamesConfigService _gamesConfig;
         private readonly DiscordSocketClient _client;
 
         public TriviaCommands(
             DiscordSocketClient client,
-            IDataCache cache,
+            ILocalDataCache cache,
             ICurrencyService cs,
             GamesConfigService gamesConfig)
         {

src/NadekoBot/Modules/Games/Trivia/TriviaGame.cs

@@ -17,7 +17,7 @@ public class TriviaGame
     public bool GameActive { get; private set; }
     public bool ShouldStopGame { get; private set; }
     private readonly SemaphoreSlim _guessLock = new(1, 1);
-    private readonly IDataCache _cache;
+    private readonly ILocalDataCache _cache;
     private readonly IBotStrings _strings;
     private readonly DiscordSocketClient _client;
     private readonly GamesConfig _config;
@@ -35,7 +35,7 @@ public class TriviaGame
         IBotStrings strings,
         DiscordSocketClient client,
         GamesConfig config,
-        IDataCache cache,
+        ILocalDataCache cache,
         ICurrencyService cs,
         IGuild guild,
         ITextChannel channel,
@@ -70,7 +70,7 @@ public class TriviaGame
             showHowToQuit = !showHowToQuit;
 
             // load question
-            CurrentQuestion = _questionPool.GetRandomQuestion(OldQuestions, _options.IsPokemon);
+            CurrentQuestion = await _questionPool.GetRandomQuestionAsync(OldQuestions, _options.IsPokemon);
             if (string.IsNullOrWhiteSpace(CurrentQuestion?.Answer)
                 || string.IsNullOrWhiteSpace(CurrentQuestion.Question))
             {

src/NadekoBot/Modules/Games/Trivia/TriviaQuestion.cs

@@ -4,6 +4,15 @@ using System.Text.RegularExpressions;
 // THANKS @ShoMinamimoto for suggestions and coding help
 namespace NadekoBot.Modules.Games.Common.Trivia;
 
+public sealed class TriviaQuestionModel
+{
+    public string Category { get; init; }
+    public string Question { get; init; }
+    public string ImageUrl { get; init; }
+    public string AnswerImageUrl { get; init; }
+    public string Answer { get; init; }
+}
+
 public class TriviaQuestion
 {
     public const int MAX_STRING_LENGTH = 22;
@@ -17,29 +26,30 @@ public class TriviaQuestion
         new(22, 3)
     };
 
-    public string Category { get; set; }
-    public string Question { get; set; }
-    public string ImageUrl { get; set; }
-    public string AnswerImageUrl { get; set; }
-    public string Answer { get; set; }
+    public string Category
+        => _qModel.Category;
+
+    public string Question
+        => _qModel.Question;
+
+    public string ImageUrl
+        => _qModel.ImageUrl;
+
+    public string AnswerImageUrl
+        => _qModel.AnswerImageUrl ?? ImageUrl;
+
+    public string Answer
+        => _qModel.Answer;
 
     public string CleanAnswer
         => cleanAnswer ?? (cleanAnswer = Clean(Answer));
 
     private string cleanAnswer;
+    private readonly TriviaQuestionModel _qModel;
 
-    public TriviaQuestion(
-        string q,
-        string a,
-        string c,
-        string img = null,
-        string answerImage = null)
+    public TriviaQuestion(TriviaQuestionModel qModel)
     {
-        Question = q;
-        Answer = a;
-        Category = c;
-        ImageUrl = img;
-        AnswerImageUrl = answerImage ?? img;
+        _qModel = qModel;
     }
 
     public string GetHint()

src/NadekoBot/Modules/Games/Trivia/TriviaQuestionPool.cs

@@ -1,45 +1,48 @@
-#nullable disable
 namespace NadekoBot.Modules.Games.Common.Trivia;
 
 public class TriviaQuestionPool
 {
-    private TriviaQuestion[] Pool
-        => _cache.LocalData.TriviaQuestions;
-
-    private IReadOnlyDictionary<int, string> Map
-        => _cache.LocalData.PokemonMap;
-
-    private readonly IDataCache _cache;
+    private readonly ILocalDataCache _cache;
     private readonly int _maxPokemonId;
 
     private readonly NadekoRandom _rng = new();
 
-    public TriviaQuestionPool(IDataCache cache)
+    public TriviaQuestionPool(ILocalDataCache cache)
     {
         _cache = cache;
         _maxPokemonId = 721; //xd
     }
 
-    public TriviaQuestion GetRandomQuestion(HashSet<TriviaQuestion> exclude, bool isPokemon)
+    public async Task<TriviaQuestion?> GetRandomQuestionAsync(HashSet<TriviaQuestion> exclude, bool isPokemon)
     {
-        if (Pool.Length == 0)
-            return null;
-
         if (isPokemon)
         {
+            var pokes = await _cache.GetPokemonMapAsync();
+
+            if (pokes is null or { Count: 0 })
+                return default;
+            
             var num = _rng.Next(1, _maxPokemonId + 1);
-            return new("Who's That Pokémon?",
-                Map[num].ToTitleCase(),
-                "Pokemon",
-                $@"https://nadeko.bot/images/pokemon/shadows/{num}.png",
-                $@"https://nadeko.bot/images/pokemon/real/{num}.png");
+            return new(new()
+            {
+                Question = "Who's That Pokémon?",
+                Answer = pokes[num].ToTitleCase(),
+                Category = "Pokemon",
+                ImageUrl = $@"https://nadeko.bot/images/pokemon/shadows/{num}.png",
+                AnswerImageUrl = $@"https://nadeko.bot/images/pokemon/real/{num}.png"
+            });
         }
 
         TriviaQuestion randomQuestion;
-        while (exclude.Contains(randomQuestion = Pool[_rng.Next(0, Pool.Length)]))
+        var pool = await _cache.GetTriviaQuestionsAsync();
+        
+        if(pool is null)
+            return default;
+        
+        while (exclude.Contains(randomQuestion = new(pool[_rng.Next(0, pool.Length)])))
         {
             // if too many questions are excluded, clear the exclusion list and start over
-            if (exclude.Count > Pool.Length / 10 * 9)
+            if (exclude.Count > pool.Length / 10 * 9)
             {
                 exclude.Clear();
                 break;

src/NadekoBot/Modules/Music/_Common/Impl/RedisTrackCacher.cs

@@ -1,209 +0,0 @@
-using StackExchange.Redis;
-using System.Runtime.CompilerServices;
-using System.Text.Json;
-
-namespace NadekoBot.Modules.Music;
-
-public sealed class RedisTrackCacher : ITrackCacher
-{
-    private readonly ConnectionMultiplexer _multiplexer;
-
-    public RedisTrackCacher(ConnectionMultiplexer multiplexer)
-        => _multiplexer = multiplexer;
-
-    public async Task<string?> GetOrCreateStreamLink(
-        string id,
-        MusicPlatform platform,
-        Func<Task<(string StreamUrl, TimeSpan Expiry)>> streamUrlFactory)
-    {
-        var trackStreamKey = CreateStreamKey(id, platform);
-
-        var value = await GetStreamFromCacheInternalAsync(trackStreamKey);
-
-        // if there is no cached value
-        if (value == default)
-        {
-            // otherwise retrieve and cache a new value, and run this method again
-            var success = await CreateAndCacheStreamUrlAsync(trackStreamKey, streamUrlFactory);
-            if (!success)
-                return null;
-
-            return await GetOrCreateStreamLink(id, platform, streamUrlFactory);
-        }
-
-        // cache new one for future use
-        _ = Task.Run(() => CreateAndCacheStreamUrlAsync(trackStreamKey, streamUrlFactory));
-
-        return value;
-    }
-
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static string CreateStreamKey(string id, MusicPlatform platform)
-        => $"track:stream:{platform}:{id}";
-
-    private async Task<bool> CreateAndCacheStreamUrlAsync(
-        string trackStreamKey,
-        Func<Task<(string StreamUrl, TimeSpan Expiry)>> factory)
-    {
-        try
-        {
-            var data = await factory();
-            if (data == default)
-                return false;
-
-            await CacheStreamUrlInternalAsync(trackStreamKey, data.StreamUrl, data.Expiry);
-            return true;
-        }
-        catch (Exception ex)
-        {
-            Log.Error(ex, "Error resolving stream link for {TrackCacheKey}", trackStreamKey);
-            return false;
-        }
-    }
-
-    public Task CacheStreamUrlAsync(
-        string id,
-        MusicPlatform platform,
-        string url,
-        TimeSpan expiry)
-        => CacheStreamUrlInternalAsync(CreateStreamKey(id, platform), url, expiry);
-
-    private async Task CacheStreamUrlInternalAsync(string trackStreamKey, string url, TimeSpan expiry)
-    {
-        // keys need to be expired after an hour
-        // to make sure client doesn't get an expired stream url
-        // to achieve this, track keys will be just pointers to real data
-        // but that data will expire
-
-        var db = _multiplexer.GetDatabase();
-        var dataKey = $"entry:{Guid.NewGuid()}:{trackStreamKey}";
-        await db.StringSetAsync(dataKey, url, expiry);
-        await db.ListRightPushAsync(trackStreamKey, dataKey);
-    }
-
-    private async Task<string?> GetStreamFromCacheInternalAsync(string trackStreamKey)
-    {
-        // Job of the method which retrieves keys is to pop the elements
-        // from the list of cached trackurls until it finds a non-expired key
-
-        var db = _multiplexer.GetDatabase();
-        while (true)
-        {
-            string? dataKey = await db.ListLeftPopAsync(trackStreamKey);
-            if (dataKey == default)
-                return null;
-
-            var streamUrl = await db.StringGetAsync(dataKey);
-            if (streamUrl == default)
-                continue;
-
-            return streamUrl;
-        }
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static string CreateCachedDataKey(string id, MusicPlatform platform)
-        => $"track:data:{platform}:{id}";
-
-    public Task CacheTrackDataAsync(ICachableTrackData data)
-    {
-        var db = _multiplexer.GetDatabase();
-
-        var trackDataKey = CreateCachedDataKey(data.Id, data.Platform);
-        var dataString = JsonSerializer.Serialize((object)data);
-        // cache for 1 day
-        return db.StringSetAsync(trackDataKey, dataString, TimeSpan.FromDays(1));
-    }
-
-    public async Task<ICachableTrackData?> GetCachedDataByIdAsync(string id, MusicPlatform platform)
-    {
-        var db = _multiplexer.GetDatabase();
-
-        var trackDataKey = CreateCachedDataKey(id, platform);
-        var data = await db.StringGetAsync(trackDataKey);
-        if (data == default)
-            return null;
-
-        return JsonSerializer.Deserialize<CachableTrackData>(data);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static string CreateCachedQueryDataKey(string query, MusicPlatform platform)
-        => $"track:query_to_id:{platform}:{query}";
-
-    public async Task<ICachableTrackData?> GetCachedDataByQueryAsync(string query, MusicPlatform platform)
-    {
-        query = Uri.EscapeDataString(query.Trim());
-
-        var db = _multiplexer.GetDatabase();
-        var queryDataKey = CreateCachedQueryDataKey(query, platform);
-
-        var trackId = await db.StringGetAsync(queryDataKey);
-        if (trackId == default)
-            return null;
-
-        return await GetCachedDataByIdAsync(trackId, platform);
-    }
-
-    public async Task CacheTrackDataByQueryAsync(string query, ICachableTrackData data)
-    {
-        query = Uri.EscapeDataString(query.Trim());
-
-        // first cache the data
-        await CacheTrackDataAsync(data);
-
-        // then map the query to cached data's id
-        var db = _multiplexer.GetDatabase();
-
-        var queryDataKey = CreateCachedQueryDataKey(query, data.Platform);
-        await db.StringSetAsync(queryDataKey, data.Id, TimeSpan.FromDays(7));
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static string CreateCachedPlaylistKey(string playlistId, MusicPlatform platform)
-        => $"playlist:{platform}:{playlistId}";
-
-    public async Task<IReadOnlyCollection<string>> GetPlaylistTrackIdsAsync(string playlistId, MusicPlatform platform)
-    {
-        var db = _multiplexer.GetDatabase();
-        var key = CreateCachedPlaylistKey(playlistId, platform);
-        var vals = await db.ListRangeAsync(key);
-        if (vals == default || vals.Length == 0)
-            return Array.Empty<string>();
-
-        return vals.Select(x => x.ToString()).ToList();
-    }
-
-    public async Task CachePlaylistTrackIdsAsync(string playlistId, MusicPlatform platform, IEnumerable<string> ids)
-    {
-        var db = _multiplexer.GetDatabase();
-        var key = CreateCachedPlaylistKey(playlistId, platform);
-        await db.ListRightPushAsync(key, ids.Select(x => (RedisValue)x).ToArray());
-        await db.KeyExpireAsync(key, TimeSpan.FromDays(7));
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static string CreateCachedPlaylistQueryKey(string query, MusicPlatform platform)
-        => $"playlist:query:{platform}:{query}";
-
-    public Task CachePlaylistIdByQueryAsync(string query, MusicPlatform platform, string playlistId)
-    {
-        query = Uri.EscapeDataString(query.Trim());
-        var key = CreateCachedPlaylistQueryKey(query, platform);
-        var db = _multiplexer.GetDatabase();
-        return db.StringSetAsync(key, playlistId, TimeSpan.FromDays(7));
-    }
-
-    public async Task<string?> GetPlaylistIdByQueryAsync(string query, MusicPlatform platform)
-    {
-        query = Uri.EscapeDataString(query.Trim());
-        var key = CreateCachedPlaylistQueryKey(query, platform);
-
-        var val = await _multiplexer.GetDatabase().StringGetAsync(key);
-        if (val == default)
-            return null;
-
-        return val;
-    }
-}

src/NadekoBot/Modules/Music/_Common/Impl/TrackCacher.cs

@@ -0,0 +1,105 @@
+namespace NadekoBot.Modules.Music;
+
+public sealed class TrackCacher : ITrackCacher
+{
+    private readonly IBotCache _cache;
+
+    public TrackCacher(IBotCache cache)
+        => _cache = cache;
+
+
+    private TypedKey<string> GetStreamLinkKey(MusicPlatform platform, string id)
+        => new($"music:stream:{platform}:{id}");
+    
+    public async Task<string?> GetOrCreateStreamLink(
+        string id,
+        MusicPlatform platform,
+        Func<Task<(string StreamUrl, TimeSpan Expiry)>> streamUrlFactory)
+    {
+        var key = GetStreamLinkKey(platform, id);
+
+        var streamUrl = await _cache.GetOrDefaultAsync(key);
+        await _cache.RemoveAsync(key);
+        
+        if (streamUrl == default)
+        {
+            (streamUrl, _) = await streamUrlFactory();
+        }
+
+        // make a new one for later use
+        _ = Task.Run(async () =>
+        {
+            (streamUrl, var expiry) = await streamUrlFactory();
+            await CacheStreamUrlAsync(id, platform, streamUrl, expiry);
+        });
+        
+        return streamUrl;
+    }
+
+    public async Task CacheStreamUrlAsync(
+        string id,
+        MusicPlatform platform,
+        string url,
+        TimeSpan expiry)
+        => await _cache.AddAsync(GetStreamLinkKey(platform, id), url, expiry);
+
+    // track data by id
+    private TypedKey<CachableTrackData> GetTrackDataKey(MusicPlatform platform, string id)
+        => new($"music:track:{platform}:{id}");
+    public async Task CacheTrackDataAsync(ICachableTrackData data)
+        => await _cache.AddAsync(GetTrackDataKey(data.Platform, data.Id), ToCachableTrackData(data));
+
+    private CachableTrackData ToCachableTrackData(ICachableTrackData data)
+        => new CachableTrackData()
+        {
+            Id = data.Id,
+            Platform = data.Platform,
+            Thumbnail = data.Thumbnail,
+            Title = data.Title,
+            Url = data.Url,
+        };
+
+    public async Task<ICachableTrackData?> GetCachedDataByIdAsync(string id, MusicPlatform platform)
+        => await _cache.GetOrDefaultAsync(GetTrackDataKey(platform, id)); 
+    
+    
+    // track data by query
+    private TypedKey<CachableTrackData> GetTrackDataQueryKey(MusicPlatform platform, string query)
+        => new($"music:track:{platform}:q:{query}");
+
+    public async Task CacheTrackDataByQueryAsync(string query, ICachableTrackData data)
+        => await Task.WhenAll(
+            _cache.AddAsync(GetTrackDataQueryKey(data.Platform, query), ToCachableTrackData(data)).AsTask(),
+            _cache.AddAsync(GetTrackDataKey(data.Platform, data.Id), ToCachableTrackData(data)).AsTask());
+    
+    public async Task<ICachableTrackData?> GetCachedDataByQueryAsync(string query, MusicPlatform platform)
+        => await _cache.GetOrDefaultAsync(GetTrackDataQueryKey(platform, query));
+
+
+    // playlist track ids by playlist id
+    private TypedKey<List<string>> GetPlaylistTracksCacheKey(string playlist, MusicPlatform platform)
+        => new($"music:playlist_tracks:{platform}:{playlist}");
+
+    public async Task CachePlaylistTrackIdsAsync(string playlistId, MusicPlatform platform, IEnumerable<string> ids)
+        => await _cache.AddAsync(GetPlaylistTracksCacheKey(playlistId, platform), ids.ToList());
+
+    public async Task<IReadOnlyCollection<string>> GetPlaylistTrackIdsAsync(string playlistId, MusicPlatform platform)
+    {
+        var result = await _cache.GetAsync(GetPlaylistTracksCacheKey(playlistId, platform));
+        if (result.TryGetValue(out var val))
+            return val;
+
+        return Array.Empty<string>();
+    }
+
+
+    // playlist id by query
+    private TypedKey<string> GetPlaylistCacheKey(string query, MusicPlatform platform)
+        => new($"music:playlist_id:{platform}:{query}");
+    
+    public async Task CachePlaylistIdByQueryAsync(string query, MusicPlatform platform, string playlistId)
+        => await _cache.AddAsync(GetPlaylistCacheKey(query, platform), playlistId);
+
+    public async Task<string?> GetPlaylistIdByQueryAsync(string query, MusicPlatform platform)
+        => await _cache.GetOrDefaultAsync(GetPlaylistCacheKey(query, platform));
+}

src/NadekoBot/Modules/Nsfw/Nhentai/INhentaiService.cs

@@ -0,0 +1,9 @@
+using NadekoBot.Modules.Searches.Common;
+
+namespace NadekoBot.Modules.Nsfw;
+
+public interface INhentaiService
+{
+    Task<Gallery?> GetAsync(uint id);
+    Task<IReadOnlyList<uint>> GetIdsBySearchAsync(string search);
+}

src/NadekoBot/Modules/Nsfw/Nhentai/NhentaiScraperService.cs

@@ -0,0 +1,115 @@
+using AngleSharp.Html.Dom;
+using AngleSharp.Html.Parser;
+using NadekoBot.Modules.Searches.Common;
+
+namespace NadekoBot.Modules.Nsfw;
+
+public sealed class NhentaiScraperService : INhentaiService, INService
+{
+    private readonly IHttpClientFactory _httpFactory;
+
+    private static readonly HtmlParser _htmlParser = new(new()
+    {
+        IsScripting = false,
+        IsEmbedded = false,
+        IsSupportingProcessingInstructions = false,
+        IsKeepingSourceReferences = false,
+        IsNotSupportingFrames = true
+    });
+
+    public NhentaiScraperService(IHttpClientFactory httpFactory)
+    {
+        _httpFactory = httpFactory;
+    }
+
+    private HttpClient GetHttpClient()
+    {
+        var http = _httpFactory.CreateClient();
+        http.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.114 Safari/537.36");
+        http.DefaultRequestHeaders.Add("Cookie", "cf_clearance=I5pR71P4wJkRBFTLFjBndI.GwfKwT.Gx06uS8XNmRJo-1657214595-0-150; csrftoken=WMWRLtsQtBVQYvYkbqXKJHI9T1JwWCdd3tNhoxHn7aHLUYHAqe60XFUKAoWsJtda");
+        return http;
+    }
+    
+    public async Task<Gallery?> GetAsync(uint id)
+    {
+        using var http = GetHttpClient();
+        try
+        {
+            var url = $"https://nhentai.net/g/{id}/";
+            var strRes = await http.GetStringAsync(url);
+            var doc = await _htmlParser.ParseDocumentAsync(strRes);
+
+            var title = doc.QuerySelector("#info .title")?.TextContent;
+            var fullTitle = doc.QuerySelector("meta[itemprop=\"name\"]")?.Attributes["content"]?.Value
+                            ?? title;
+            var thumb = (doc.QuerySelector("#cover a img") as IHtmlImageElement)?.Dataset["src"];
+
+            var tagsElem = doc.QuerySelector("#tags");
+            
+            var pageCount = tagsElem?.QuerySelector("a.tag[href^=\"/search/?q=pages\"] span")?.TextContent;
+            var likes = doc.QuerySelector(".buttons .btn-disabled.btn.tooltip span span")?.TextContent?.Trim('(', ')');
+            var uploadedAt = (tagsElem?.QuerySelector(".tag-container .tags time.nobold") as IHtmlTimeElement)?.DateTime;
+
+            var tags = tagsElem?.QuerySelectorAll(".tag-container .tags > a.tag[href^=\"/tag\"]")
+                .Cast<IHtmlAnchorElement>()
+                .Select(x => new Tag()
+                {
+                    Name = x.QuerySelector("span:first-child")?.TextContent,
+                    Url = $"https://nhentai.net{x.PathName}"
+                })
+                .ToArray();
+
+            if (string.IsNullOrWhiteSpace(fullTitle))
+                return null;
+
+            if (!int.TryParse(pageCount, out var pc))
+                return null;
+
+            if (!int.TryParse(likes, out var lc))
+                return null;
+
+            if (!DateTime.TryParse(uploadedAt, out var ua))
+                return null;
+
+            return new Gallery(id,
+                url,
+                fullTitle,
+                title,
+                thumb,
+                pc,
+                lc,
+                ua,
+                tags);
+        }
+        catch (HttpRequestException)
+        {
+            Log.Warning("Nhentai with id {NhentaiId} not found", id);
+            return null;
+        }
+    }
+
+    public async Task<IReadOnlyList<uint>> GetIdsBySearchAsync(string search)
+    {
+        using var http = GetHttpClient();
+        try
+        {
+            var url = $"https://nhentai.net/search/?q={Uri.EscapeDataString(search)}&sort=popular-today";
+            var strRes = await http.GetStringAsync(url);
+            var doc = await _htmlParser.ParseDocumentAsync(strRes);
+
+            var elems = doc.QuerySelectorAll(".container .gallery a")
+                .Cast<IHtmlAnchorElement>()
+                .Where(x => x.PathName.StartsWith("/g/"))
+                .Select(x => x.PathName[3..^1])
+                .Select(uint.Parse)
+                .ToArray();
+            
+            return elems;
+        }
+        catch (HttpRequestException)
+        {
+            Log.Warning("Nhentai search for {NhentaiSearch} failed", search);
+            return Array.Empty<uint>();
+        }
+    }
+}

src/NadekoBot/Modules/Nsfw/Nsfw.cs

@@ -4,6 +4,7 @@ using Newtonsoft.Json.Linq;
 
 namespace NadekoBot.Modules.Nsfw;
 
+#if !GLOBAL_NADEKO
 [NoPublicBot]
 public partial class NSFW : NadekoModule<ISearchImagesService>
 {
@@ -403,15 +404,19 @@ public partial class NSFW : NadekoModule<ISearchImagesService>
                          .Join(" ");
 
         var embed = _eb.Create()
-                       .WithTitle(g.Title)
-                       .WithDescription(g.FullTitle)
-                       .WithImageUrl(g.Thumbnail)
-                       .WithUrl(g.Url)
-                       .AddField(GetText(strs.favorites), g.Likes, true)
-                       .AddField(GetText(strs.pages), g.PageCount, true)
-                       .AddField(GetText(strs.tags), tagString, true)
-                       .WithFooter(g.UploadedAt.ToString("f"))
-                       .WithOkColor();
+            .WithTitle(g.Title)
+            .WithDescription(g.FullTitle)
+            .WithImageUrl(g.Thumbnail)
+            .WithUrl(g.Url)
+            .AddField(GetText(strs.favorites), g.Likes, true)
+            .AddField(GetText(strs.pages), g.PageCount, true)
+            .AddField(GetText(strs.tags),
+                string.IsNullOrWhiteSpace(tagString)
+                    ? "?"
+                    : tagString,
+                true)
+            .WithFooter(g.UploadedAt.ToString("f"))
+            .WithOkColor();
 
         await ctx.Channel.EmbedAsync(embed);
     }
@@ -436,4 +441,5 @@ public partial class NSFW : NadekoModule<ISearchImagesService>
                                         .WithFooter(
                                             $"{data.Rating} ({data.Provider}) | {string.Join(" | ", data.Tags.Where(x => !string.IsNullOrWhiteSpace(x)).Take(5))}"));
     }
-}
+}
+#endif

src/NadekoBot/Modules/Nsfw/NsfwService.cs

@@ -1,10 +0,0 @@
-#nullable disable
-namespace NadekoBot.Modules.Nsfw;
-
-public interface INsfwService
-{
-}
-
-public class NsfwService
-{
-}

src/NadekoBot/Modules/Nsfw/SearchImagesService.cs

@@ -1,21 +1,11 @@
-#nullable disable
+#nullable disable warnings
 using LinqToDB;
 using NadekoBot.Modules.Nsfw.Common;
 using NadekoBot.Modules.Searches.Common;
-using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace NadekoBot.Modules.Nsfw;
 
-public record UrlReply
-{
-    public string Error { get; init; }
-    public string Url { get; init; }
-    public string Rating { get; init; }
-    public string Provider { get; init; }
-    public List<string> Tags { get; } = new();
-}
-
 public class SearchImagesService : ISearchImagesService, INService
 {
     private ConcurrentDictionary<ulong, HashSet<string>> BlacklistedTags { get; }
@@ -23,18 +13,22 @@ public class SearchImagesService : ISearchImagesService, INService
     public ConcurrentDictionary<ulong, Timer> AutoHentaiTimers { get; } = new();
     public ConcurrentDictionary<ulong, Timer> AutoBoobTimers { get; } = new();
     public ConcurrentDictionary<ulong, Timer> AutoButtTimers { get; } = new();
+    
     private readonly Random _rng;
     private readonly SearchImageCacher _cache;
     private readonly IHttpClientFactory _httpFactory;
     private readonly DbService _db;
+    private readonly INhentaiService _nh;
 
     private readonly object _taglock = new();
 
     public SearchImagesService(
         DbService db,
         SearchImageCacher cacher,
-        IHttpClientFactory httpFactory)
+        IHttpClientFactory httpFactory,
+        INhentaiService nh)
     {
+        _nh = nh;
         _db = db;
         _rng = new NadekoRandom();
         _cache = cacher;
@@ -284,85 +278,18 @@ public class SearchImagesService : ISearchImagesService, INService
 
     #region Nhentai
 
-    private string GetNhentaiExtensionInternal(string s)
-        => s switch
-        {
-            "j" => "jpg",
-            "p" => "png",
-            "g" => "gif",
-            _ => "jpg"
-        };
+    public Task<Gallery?> GetNhentaiByIdAsync(uint id)
+        => _nh.GetAsync(id);
 
-    private Gallery ModelToGallery(NhentaiApiModel.Gallery model)
+    public async Task<Gallery?> GetNhentaiBySearchAsync(string search)
     {
-        var thumbnail = $"https://t.nhentai.net/galleries/{model.MediaId}/thumb."
-                        + GetNhentaiExtensionInternal(model.Images.Thumbnail.T);
+        var ids = await _nh.GetIdsBySearchAsync(search);
 
-        var url = $"https://nhentai.net/g/{model.Id}";
-        return new(model.Id.ToString(),
-            url,
-            model.Title.English,
-            model.Title.Pretty,
-            thumbnail,
-            model.NumPages,
-            model.NumFavorites,
-            model.UploadDate.ToUnixTimestamp().UtcDateTime,
-            model.Tags.Map(x => new Tag
-            {
-                Name = x.Name,
-                Url = "https://nhentai.com/" + x.Url
-            }));
-    }
-
-    private async Task<NhentaiApiModel.Gallery> GetNhentaiByIdInternalAsync(uint id)
-    {
-        using var http = _httpFactory.CreateClient();
-        try
-        {
-            var res = await http.GetStringAsync("https://nhentai.net/api/gallery/" + id);
-            return JsonConvert.DeserializeObject<NhentaiApiModel.Gallery>(res);
-        }
-        catch (HttpRequestException)
-        {
-            Log.Warning("Nhentai with id {NhentaiId} not found", id);
+        if (ids.Count == 0)
             return null;
-        }
-    }
-
-    private async Task<NhentaiApiModel.Gallery[]> SearchNhentaiInternalAsync(string search)
-    {
-        using var http = _httpFactory.CreateClient();
-        try
-        {
-            var res = await http.GetStringAsync("https://nhentai.net/api/galleries/search?query=" + search);
-            return JsonConvert.DeserializeObject<NhentaiApiModel.SearchResult>(res).Result;
-        }
-        catch (HttpRequestException)
-        {
-            Log.Warning("Nhentai with search {NhentaiSearch} not found", search);
-            return null;
-        }
-    }
-
-    public async Task<Gallery> GetNhentaiByIdAsync(uint id)
-    {
-        var model = await GetNhentaiByIdInternalAsync(id);
-
-        return ModelToGallery(model);
-    }
-
-    private static readonly string[] _bannedTags = { "loli", "lolicon", "shota", "shotacon", "cub" };
-
-    public async Task<Gallery> GetNhentaiBySearchAsync(string search)
-    {
-        var models = await SearchNhentaiInternalAsync(search);
-
-        models = models.Where(x => !x.Tags.Any(t => _bannedTags.Contains(t.Name))).ToArray();
-
-        if (models.Length == 0)
-            return null;
-
-        return ModelToGallery(models[_rng.Next(0, models.Length)]);
+        
+        var id = ids[_rng.Next(0, ids.Count)];
+        return await _nh.GetAsync(id);
     }
 
     #endregion

src/NadekoBot/Modules/Nsfw/UrlReply.cs

@@ -0,0 +1,10 @@
+namespace NadekoBot.Modules.Nsfw;
+
+public record UrlReply
+{
+    public string Error { get; init; }
+    public string Url { get; init; }
+    public string Rating { get; init; }
+    public string Provider { get; init; }
+    public List<string> Tags { get; } = new();
+}

src/NadekoBot/Modules/Permissions/Filter/FilterService.cs

@@ -50,7 +50,7 @@ public sealed class FilterService : IExecOnMessage
                 new(configs.SelectMany(gc => gc.FilterLinksChannelIds.Select(fci => fci.ChannelId)));
 
             var dict = configs.ToDictionary(gc => gc.GuildId,
-                gc => new ConcurrentHashSet<string>(gc.FilteredWords.Select(fw => fw.Word)));
+                gc => new ConcurrentHashSet<string>(gc.FilteredWords.Select(fw => fw.Word).Distinct()));
 
             ServerFilteredWords = new(dict);
 

src/NadekoBot/Modules/Searches/Anime/AnimeResult.cs

@@ -1,34 +1,38 @@
 #nullable disable
-using Newtonsoft.Json;
+using System.Text.Json.Serialization;
 
 namespace NadekoBot.Modules.Searches.Common;
 
 public class AnimeResult
 {
+    [JsonPropertyName("id")]
     public int Id { get; set; }
 
-    public string AiringStatus
-        => AiringStatusParsed.ToTitleCase();
-
-    [JsonProperty("airing_status")]
+    [JsonPropertyName("airing_status")]
     public string AiringStatusParsed { get; set; }
 
-    [JsonProperty("title_english")]
+    [JsonPropertyName("title_english")]
     public string TitleEnglish { get; set; }
 
-    [JsonProperty("total_episodes")]
+    [JsonPropertyName("total_episodes")]
     public int TotalEpisodes { get; set; }
-
+    
+    [JsonPropertyName("description")]
     public string Description { get; set; }
 
-    [JsonProperty("image_url_lge")]
+    [JsonPropertyName("image_url_lge")]
     public string ImageUrlLarge { get; set; }
 
+    [JsonPropertyName("genres")]
     public string[] Genres { get; set; }
 
-    [JsonProperty("average_score")]
-    public string AverageScore { get; set; }
+    [JsonPropertyName("average_score")]
+    public float AverageScore { get; set; }
 
+    
+    public string AiringStatus
+        => AiringStatusParsed.ToTitleCase();
+    
     public string Link
         => "http://anilist.co/anime/" + Id;
 

src/NadekoBot/Modules/Searches/Anime/AnimeSearchService.cs

@@ -1,17 +1,15 @@
 #nullable disable
-using AngleSharp;
-using AngleSharp.Html.Dom;
 using NadekoBot.Modules.Searches.Common;
-using Newtonsoft.Json;
+using System.Net.Http.Json;
 
 namespace NadekoBot.Modules.Searches.Services;
 
 public class AnimeSearchService : INService
 {
-    private readonly IDataCache _cache;
+    private readonly IBotCache _cache;
     private readonly IHttpClientFactory _httpFactory;
 
-    public AnimeSearchService(IDataCache cache, IHttpClientFactory httpFactory)
+    public AnimeSearchService(IBotCache cache, IHttpClientFactory httpFactory)
     {
         _cache = cache;
         _httpFactory = httpFactory;
@@ -21,24 +19,25 @@ public class AnimeSearchService : INService
     {
         if (string.IsNullOrWhiteSpace(query))
             throw new ArgumentNullException(nameof(query));
+        
+        TypedKey<AnimeResult> GetKey(string link)
+            => new TypedKey<AnimeResult>($"anime2:{link}");
+        
         try
         {
-            var link = "https://aniapi.nadeko.bot/anime/"
-                       + Uri.EscapeDataString(query.Replace("/", " ", StringComparison.InvariantCulture));
+            var suffix = Uri.EscapeDataString(query.Replace("/", " ", StringComparison.InvariantCulture));
+            var link = $"https://aniapi.nadeko.bot/anime/{suffix}";
             link = link.ToLowerInvariant();
-            var (ok, data) = await _cache.TryGetAnimeDataAsync(link);
-            if (!ok)
+            var result = await _cache.GetAsync(GetKey(link));
+            if (!result.TryPickT0(out var data, out _))
             {
-                using (var http = _httpFactory.CreateClient())
-                {
-                    data = await http.GetStringAsync(link);
-                }
+                using var http = _httpFactory.CreateClient();
+                data = await http.GetFromJsonAsync<AnimeResult>(link);
 
-                await _cache.SetAnimeDataAsync(link, data);
+                await _cache.AddAsync(GetKey(link), data, expiry: TimeSpan.FromHours(12));
             }
 
-
-            return JsonConvert.DeserializeObject<AnimeResult>(data);
+            return data;
         }
         catch
         {
@@ -46,95 +45,31 @@ public class AnimeSearchService : INService
         }
     }
 
-    public async Task<NovelResult> GetNovelData(string query)
-    {
-        if (string.IsNullOrWhiteSpace(query))
-            throw new ArgumentNullException(nameof(query));
-
-        query = query.Replace(" ", "-", StringComparison.InvariantCulture);
-        try
-        {
-            var link = "https://www.novelupdates.com/series/"
-                       + Uri.EscapeDataString(query.Replace(" ", "-").Replace("/", " "));
-            link = link.ToLowerInvariant();
-            var (ok, data) = await _cache.TryGetNovelDataAsync(link);
-            if (!ok)
-            {
-                var config = Configuration.Default.WithDefaultLoader();
-                using var document = await BrowsingContext.New(config).OpenAsync(link);
-                var imageElem = document.QuerySelector("div.seriesimg > img");
-                if (imageElem is null)
-                    return null;
-                var imageUrl = ((IHtmlImageElement)imageElem).Source;
-
-                var descElem = document.QuerySelector("div#editdescription > p");
-                var desc = descElem.InnerHtml;
-
-                var genres = document.QuerySelector("div#seriesgenre")
-                                     .Children.Select(x => x as IHtmlAnchorElement)
-                                     .Where(x => x is not null)
-                                     .Select(x => $"[{x.InnerHtml}]({x.Href})")
-                                     .ToArray();
-
-                var authors = document.QuerySelector("div#showauthors")
-                                      .Children.Select(x => x as IHtmlAnchorElement)
-                                      .Where(x => x is not null)
-                                      .Select(x => $"[{x.InnerHtml}]({x.Href})")
-                                      .ToArray();
-
-                var score = ((IHtmlSpanElement)document.QuerySelector("h5.seriesother > span.uvotes")).InnerHtml;
-
-                var status = document.QuerySelector("div#editstatus").InnerHtml;
-                var title = document.QuerySelector("div.w-blog-content > div.seriestitlenu").InnerHtml;
-
-                var obj = new NovelResult
-                {
-                    Description = desc,
-                    Authors = authors,
-                    Genres = genres,
-                    ImageUrl = imageUrl,
-                    Link = link,
-                    Score = score,
-                    Status = status,
-                    Title = title
-                };
-
-                await _cache.SetNovelDataAsync(link, JsonConvert.SerializeObject(obj));
-
-                return obj;
-            }
-
-            return JsonConvert.DeserializeObject<NovelResult>(data);
-        }
-        catch (Exception ex)
-        {
-            Log.Error(ex, "Error getting novel data");
-            return null;
-        }
-    }
-
     public async Task<MangaResult> GetMangaData(string query)
     {
         if (string.IsNullOrWhiteSpace(query))
             throw new ArgumentNullException(nameof(query));
+        
+        TypedKey<MangaResult> GetKey(string link)
+            => new TypedKey<MangaResult>($"manga2:{link}");
+        
         try
         {
             var link = "https://aniapi.nadeko.bot/manga/"
                        + Uri.EscapeDataString(query.Replace("/", " ", StringComparison.InvariantCulture));
             link = link.ToLowerInvariant();
-            var (ok, data) = await _cache.TryGetAnimeDataAsync(link);
-            if (!ok)
+            
+            var result = await _cache.GetAsync(GetKey(link));
+            if (!result.TryPickT0(out var data, out _))
             {
-                using (var http = _httpFactory.CreateClient())
-                {
-                    data = await http.GetStringAsync(link);
-                }
+                using var http = _httpFactory.CreateClient();
+                data = await http.GetFromJsonAsync<MangaResult>(link);
 
-                await _cache.SetAnimeDataAsync(link, data);
+                await _cache.AddAsync(GetKey(link), data, expiry: TimeSpan.FromHours(3));
             }
 
 
-            return JsonConvert.DeserializeObject<MangaResult>(data);
+            return data;
         }
         catch
         {

src/NadekoBot/Modules/Searches/Anime/MangaResult.cs

@@ -1,32 +1,36 @@
 #nullable disable
-using Newtonsoft.Json;
+using System.Text.Json.Serialization;
 
 namespace NadekoBot.Modules.Searches.Common;
 
 public class MangaResult
 {
+    [JsonPropertyName("id")]
     public int Id { get; set; }
 
-    [JsonProperty("publishing_status")]
+    [JsonPropertyName("publishing_status")]
     public string PublishingStatus { get; set; }
 
-    [JsonProperty("image_url_lge")]
+    [JsonPropertyName("image_url_lge")]
     public string ImageUrlLge { get; set; }
 
-    [JsonProperty("title_english")]
+    [JsonPropertyName("title_english")]
     public string TitleEnglish { get; set; }
 
-    [JsonProperty("total_chapters")]
+    [JsonPropertyName("total_chapters")]
     public int TotalChapters { get; set; }
 
-    [JsonProperty("total_volumes")]
+    [JsonPropertyName("total_volumes")]
     public int TotalVolumes { get; set; }
 
+    [JsonPropertyName("description")]
     public string Description { get; set; }
+    
+    [JsonPropertyName("genres")]
     public string[] Genres { get; set; }
 
-    [JsonProperty("average_score")]
-    public string AverageScore { get; set; }
+    [JsonPropertyName("average_score")]
+    public float AverageScore { get; set; }
 
     public string Link
         => "http://anilist.co/manga/" + Id;

src/NadekoBot/Modules/Searches/Crypto/CryptoService.cs

@@ -15,13 +15,13 @@ namespace NadekoBot.Modules.Searches.Services;
 
 public class CryptoService : INService
 {
-    private readonly IDataCache _cache;
+    private readonly IBotCache _cache;
     private readonly IHttpClientFactory _httpFactory;
     private readonly IBotCredentials _creds;
 
     private readonly SemaphoreSlim _getCryptoLock = new(1, 1);
 
-    public CryptoService(IDataCache cache, IHttpClientFactory httpFactory, IBotCredentials creds)
+    public CryptoService(IBotCache cache, IHttpClientFactory httpFactory, IBotCredentials creds)
     {
         _cache = cache;
         _httpFactory = httpFactory;
@@ -40,7 +40,8 @@ public class CryptoService : INService
         Span<PointF> points = new PointF[gElement.ChildNodes.Count];
         var cnt = 0;
 
-        bool GetValuesFromAttributes(XmlAttributeCollection attrs,
+        bool GetValuesFromAttributes(
+            XmlAttributeCollection attrs,
             out float x1,
             out float y1,
             out float x2,
@@ -56,7 +57,7 @@ public class CryptoService : INService
                    && attrs["y2"]?.Value is string y2Str
                    && float.TryParse(y2Str, NumberStyles.Any, CultureInfo.InvariantCulture, out y2);
         }
-        
+
         foreach (XmlElement x in gElement.ChildNodes)
         {
             if (x.Name != "line")
@@ -67,22 +68,22 @@ public class CryptoService : INService
                 points[cnt++] = new(x1, y1);
                 // this point will be set twice to the same value
                 // on all points except the last one
-                if(cnt + 1 < points.Length)
+                if (cnt + 1 < points.Length)
                     points[cnt + 1] = new(x2, y2);
             }
         }
 
         if (cnt == 0)
             return Array.Empty<PointF>();
-        
+
         return points.Slice(0, cnt).ToArray();
     }
-    
+
     private SixLabors.ImageSharp.Image<Rgba32> GenerateSparklineChart(PointF[] points, bool up)
     {
         const int width = 164;
         const int height = 48;
-        
+
         var img = new Image<Rgba32>(width, height, Color.Transparent);
         var color = up
             ? Color.Green
@@ -92,10 +93,10 @@ public class CryptoService : INService
         {
             x.DrawLines(color, 2, points);
         });
-        
+
         return img;
     }
-    
+
     public async Task<(CmcResponseData? Data, CmcResponseData? Nearest)> GetCryptoData(string name)
     {
         if (string.IsNullOrWhiteSpace(name))
@@ -130,20 +131,20 @@ public class CryptoService : INService
         await _getCryptoLock.WaitAsync();
         try
         {
-            var fullStrData = await _cache.GetOrAddCachedDataAsync("nadeko:crypto_data",
-                async _ =>
+            var data = await _cache.GetOrAddAsync(new("nadeko:crypto_data"),
+                async () =>
                 {
                     try
                     {
                         using var http = _httpFactory.CreateClient();
-                        var strData = await http.GetFromJsonAsync<CryptoResponse>(
+                        var data = await http.GetFromJsonAsync<CryptoResponse>(
                             "https://pro-api.coinmarketcap.com/v1/cryptocurrency/listings/latest?"
                             + $"CMC_PRO_API_KEY={_creds.CoinmarketcapApiKey}"
                             + "&start=1"
                             + "&limit=5000"
                             + "&convert=USD");
 
-                        return JsonSerializer.Serialize(strData);
+                        return data;
                     }
                     catch (Exception ex)
                     {
@@ -151,13 +152,12 @@ public class CryptoService : INService
                         return default;
                     }
                 },
-                "",
                 TimeSpan.FromHours(2));
 
-            if (fullStrData is null)
+            if (data is null)
                 return default;
-            
-            return JsonSerializer.Deserialize<CryptoResponse>(fullStrData)?.Data ?? new();
+
+            return data.Data;
         }
         catch (Exception ex)
         {
@@ -170,44 +170,33 @@ public class CryptoService : INService
         }
     }
 
+    private TypedKey<byte[]> GetSparklineKey(int id)
+        => new($"crypto:sparkline:{id}");
+
     public async Task<Stream?> GetSparklineAsync(int id, bool up)
-    {
-        var key = $"crypto:sparkline:{id}";
-        
-        // attempt to get from cache
-        var db = _cache.Redis.GetDatabase();
-        byte[] bytes = await db.StringGetAsync(key);
-        // if it succeeds, return it
-        if (bytes is { Length: > 0 })
-        {
-            return bytes.ToStream();
-        }
-        
-        // if it fails, generate a new one
-        var points = await DownloadSparklinePointsAsync(id);
-        if (points is null)
-            return default;
-        
-        var sparkline = GenerateSparklineChart(points, up);
-
-        // add to cache for 1h and return it
-        
-        var stream = sparkline.ToStream();
-        await db.StringSetAsync(key, stream.ToArray(), expiry: TimeSpan.FromHours(1));
-        return stream;
-    }
-
-    private async Task<PointF[]?> DownloadSparklinePointsAsync(int id)
     {
         try
         {
-            using var http = _httpFactory.CreateClient();
-            var str = await http.GetStringAsync(
-                $"https://s3.coinmarketcap.com/generated/sparklines/web/7d/usd/{id}.svg");
-            var points = GetSparklinePointsFromSvgText(str);
-            return points;
+            var bytes = await _cache.GetOrAddAsync(GetSparklineKey(id),
+                async () =>
+                {
+                    // if it fails, generate a new one
+                    var points = await DownloadSparklinePointsAsync(id);
+                    var sparkline = GenerateSparklineChart(points, up);
+
+                    using var stream = await sparkline.ToStreamAsync();
+                    return stream.ToArray();
+                },
+                TimeSpan.FromHours(1));
+
+            if (bytes is { Length: > 0 })
+            {
+                return bytes.ToStream();
+            }
+
+            return default;
         }
-        catch(Exception ex)
+        catch (Exception ex)
         {
             Log.Warning(ex,
                 "Exception occurred while downloading sparkline points: {ErrorMessage}",
@@ -215,4 +204,13 @@ public class CryptoService : INService
             return default;
         }
     }
+
+    private async Task<PointF[]> DownloadSparklinePointsAsync(int id)
+    {
+        using var http = _httpFactory.CreateClient();
+        var str = await http.GetStringAsync(
+            $"https://s3.coinmarketcap.com/generated/sparklines/web/7d/usd/{id}.svg");
+        var points = GetSparklinePointsFromSvgText(str);
+        return points;
+    }
 }

src/NadekoBot/Modules/Searches/PokemonSearchCommands.cs

@@ -9,15 +9,9 @@ public partial class Searches
     [Group]
     public partial class PokemonSearchCommands : NadekoModule<SearchesService>
     {
-        public IReadOnlyDictionary<string, SearchPokemon> Pokemons
-            => _cache.LocalData.Pokemons;
+        private readonly ILocalDataCache _cache;
 
-        public IReadOnlyDictionary<string, SearchPokemonAbility> PokemonAbilities
-            => _cache.LocalData.PokemonAbilities;
-
-        private readonly IDataCache _cache;
-
-        public PokemonSearchCommands(IDataCache cache)
+        public PokemonSearchCommands(ILocalDataCache cache)
             => _cache = cache;
 
         [Cmd]
@@ -27,7 +21,7 @@ public partial class Searches
             if (string.IsNullOrWhiteSpace(pokemon))
                 return;
 
-            foreach (var kvp in Pokemons)
+            foreach (var kvp in await _cache.GetPokemonsAsync())
             {
                 if (kvp.Key.ToUpperInvariant() == pokemon.ToUpperInvariant())
                 {
@@ -58,7 +52,7 @@ public partial class Searches
             ability = ability?.Trim().ToUpperInvariant().Replace(" ", "", StringComparison.InvariantCulture);
             if (string.IsNullOrWhiteSpace(ability))
                 return;
-            foreach (var kvp in PokemonAbilities)
+            foreach (var kvp in await _cache.GetPokemonAbilitiesAsync())
             {
                 if (kvp.Key.ToUpperInvariant() == ability)
                 {

src/NadekoBot/Modules/Searches/Search/SearchCommands.cs

@@ -10,14 +10,14 @@ public partial class Searches
     public partial class SearchCommands : NadekoModule
     {
         private readonly ISearchServiceFactory _searchFactory;
-        private readonly ConnectionMultiplexer _redis;
+        private readonly IBotCache _cache;
 
         public SearchCommands(
             ISearchServiceFactory searchFactory,
-            ConnectionMultiplexer redis)
+            IBotCache cache)
         {
             _searchFactory = searchFactory;
-            _redis = redis;
+            _cache = cache;
         }
 
         [Cmd]
@@ -127,18 +127,17 @@ public partial class Searches
             await ctx.Channel.EmbedAsync(null, embeds: embeds);
         }
 
+        private TypedKey<string> GetYtCacheKey(string query)
+            => new($"search:youtube:{query}");
+        
         private async Task AddYoutubeUrlToCacheAsync(string query, string url)
-        {
-            var db = _redis.GetDatabase();
-            await db.StringSetAsync($"search:youtube:{query}", url, expiry: 1.Hours());
-        }
+            => await _cache.AddAsync(GetYtCacheKey(query), url, expiry: 1.Hours());
 
         private async Task<VideoInfo?> GetYoutubeUrlFromCacheAsync(string query)
         {
-            var db = _redis.GetDatabase();
-            var url = await db.StringGetAsync($"search:youtube:{query}");
+            var result = await _cache.GetAsync(GetYtCacheKey(query));
 
-            if (string.IsNullOrWhiteSpace(url))
+            if (!result.TryGetValue(out var url) || string.IsNullOrWhiteSpace(url))
                 return null;
 
             return new VideoInfo()

src/NadekoBot/Modules/Searches/SearchesService.cs

@@ -1,6 +1,4 @@
 #nullable disable
-using AngleSharp.Html.Dom;
-using AngleSharp.Html.Parser;
 using Html2Markdown;
 using NadekoBot.Modules.Searches.Common;
 using Newtonsoft.Json;
@@ -10,7 +8,6 @@ using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.Drawing.Processing;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
-using System.Net;
 using Color = SixLabors.ImageSharp.Color;
 using Image = SixLabors.ImageSharp.Image;
 
@@ -31,9 +28,9 @@ public class SearchesService : INService
     private readonly IHttpClientFactory _httpFactory;
     private readonly IGoogleApiService _google;
     private readonly IImageCache _imgs;
-    private readonly IDataCache _cache;
+    private readonly IBotCache _c;
     private readonly FontProvider _fonts;
-    private readonly IBotCredentials _creds;
+    private readonly IBotCredsProvider _creds;
     private readonly NadekoRandom _rng;
     private readonly List<string> _yomamaJokes;
 
@@ -42,15 +39,16 @@ public class SearchesService : INService
 
     public SearchesService(
         IGoogleApiService google,
-        IDataCache cache,
+        IImageCache images,
+        IBotCache c,
         IHttpClientFactory factory,
         FontProvider fonts,
-        IBotCredentials creds)
+        IBotCredsProvider creds)
     {
         _httpFactory = factory;
         _google = google;
-        _imgs = cache.LocalImages;
-        _cache = cache;
+        _imgs = images;
+        _c = c;
         _fonts = fonts;
         _creds = creds;
         _rng = new();
@@ -76,36 +74,28 @@ public class SearchesService : INService
     }
 
     public async Task<Stream> GetRipPictureAsync(string text, Uri imgUrl)
-    {
-        var data = await _cache.GetOrAddCachedDataAsync($"nadeko_rip_{text}_{imgUrl}",
-            GetRipPictureFactory,
-            (text, imgUrl),
-            TimeSpan.FromDays(1));
-
-        return data.ToStream();
-    }
+        => (await GetRipPictureFactory(text, imgUrl)).ToStream();
 
     private void DrawAvatar(Image bg, Image avatarImage)
         => bg.Mutate(x => x.Grayscale().DrawImage(avatarImage, new(83, 139), new GraphicsOptions()));
 
-    public async Task<byte[]> GetRipPictureFactory((string text, Uri avatarUrl) arg)
+    public async Task<byte[]> GetRipPictureFactory(string text, Uri avatarUrl)
     {
-        var (text, avatarUrl) = arg;
-        using var bg = Image.Load<Rgba32>(_imgs.Rip.ToArray());
-        var (succ, data) = (false, (byte[])null); //await _cache.TryGetImageDataAsync(avatarUrl);
-        if (!succ)
+        using var bg = Image.Load<Rgba32>(await _imgs.GetRipBgAsync());
+        var result = await _c.GetImageDataAsync(avatarUrl);
+        if (!result.TryPickT0(out var data, out _))
         {
             using var http = _httpFactory.CreateClient();
             data = await http.GetByteArrayAsync(avatarUrl);
             using (var avatarImg = Image.Load<Rgba32>(data))
             {
                 avatarImg.Mutate(x => x.Resize(85, 85).ApplyRoundedCorners(42));
-                await using var avStream = avatarImg.ToStream();
+                await using var avStream = await avatarImg.ToStreamAsync();
                 data = avStream.ToArray();
                 DrawAvatar(bg, avatarImg);
             }
 
-            await _cache.SetImageDataAsync(avatarUrl, data);
+            await _c.SetImageDataAsync(avatarUrl, data);
         }
         else
         {
@@ -128,7 +118,7 @@ public class SearchesService : INService
             new(25, 225)));
 
         //flowa
-        using (var flowers = Image.Load(_imgs.RipOverlay.ToArray()))
+        using (var flowers = Image.Load(await _imgs.GetRipOverlayAsync()))
         {
             bg.Mutate(x => x.DrawImage(flowers, new(0, 0), new GraphicsOptions()));
         }
@@ -137,13 +127,12 @@ public class SearchesService : INService
         return stream.ToArray();
     }
 
-    public Task<WeatherData> GetWeatherDataAsync(string query)
+    public async Task<WeatherData> GetWeatherDataAsync(string query)
     {
         query = query.Trim().ToLowerInvariant();
 
-        return _cache.GetOrAddCachedDataAsync($"nadeko_weather_{query}",
-            GetWeatherDataFactory,
-            query,
+        return await _c.GetOrAddAsync(new($"nadeko_weather_{query}"),
+            async () => await GetWeatherDataFactory(query),
             TimeSpan.FromHours(3));
     }
 
@@ -184,26 +173,28 @@ public class SearchesService : INService
         if (string.IsNullOrEmpty(query))
             return (default, TimeErrors.InvalidInput);
 
-        if (string.IsNullOrWhiteSpace(_creds.LocationIqApiKey) || string.IsNullOrWhiteSpace(_creds.TimezoneDbApiKey))
+
+        var locIqKey = _creds.GetCreds().LocationIqApiKey;
+        var tzDbKey = _creds.GetCreds().TimezoneDbApiKey;
+        if (string.IsNullOrWhiteSpace(locIqKey) || string.IsNullOrWhiteSpace(tzDbKey))
             return (default, TimeErrors.ApiKeyMissing);
 
         try
         {
             using var http = _httpFactory.CreateClient();
-            var res = await _cache.GetOrAddCachedDataAsync($"geo_{query}",
-                _ =>
+            var res = await _c.GetOrAddAsync(new($"searches:geo:{query}"),
+                async () =>
                 {
                     var url = "https://eu1.locationiq.com/v1/search.php?"
-                              + (string.IsNullOrWhiteSpace(_creds.LocationIqApiKey)
+                              + (string.IsNullOrWhiteSpace(locIqKey)
                                   ? "key="
-                                  : $"key={_creds.LocationIqApiKey}&")
+                                  : $"key={locIqKey}&")
                               + $"q={Uri.EscapeDataString(query)}&"
                               + "format=json";
 
-                    var res = http.GetStringAsync(url);
+                    var res = await http.GetStringAsync(url);
                     return res;
                 },
-                "",
                 TimeSpan.FromHours(1));
 
             var responses = JsonConvert.DeserializeObject<LocationIqResponse[]>(res);
@@ -217,7 +208,7 @@ public class SearchesService : INService
 
             using var req = new HttpRequestMessage(HttpMethod.Get,
                 "http://api.timezonedb.com/v2.1/get-time-zone?"
-                + $"key={_creds.TimezoneDbApiKey}"
+                + $"key={tzDbKey}"
                 + $"&format=json"
                 + $"&by=position"
                 + $"&lat={geoData.Lat}"
@@ -315,9 +306,8 @@ public class SearchesService : INService
     public async Task<MtgData> GetMtgCardAsync(string search)
     {
         search = search.Trim().ToLowerInvariant();
-        var data = await _cache.GetOrAddCachedDataAsync($"nadeko_mtg_{search}",
-            GetMtgCardFactory,
-            search,
+        var data = await _c.GetOrAddAsync(new($"mtg:{search}"),
+            async () => await GetMtgCardFactory(search),
             TimeSpan.FromDays(1));
 
         if (data is null || data.Length == 0)
@@ -368,12 +358,11 @@ public class SearchesService : INService
         return await cards.Select(GetMtgDataAsync).WhenAll();
     }
 
-    public Task<HearthstoneCardData> GetHearthstoneCardDataAsync(string name)
+    public async Task<HearthstoneCardData> GetHearthstoneCardDataAsync(string name)
     {
         name = name.ToLowerInvariant();
-        return _cache.GetOrAddCachedDataAsync($"nadeko_hearthstone_{name}",
-            HearthstoneCardDataFactory,
-            name,
+        return await _c.GetOrAddAsync($"hearthstone:{name}",
+            () => HearthstoneCardDataFactory(name),
             TimeSpan.FromDays(1));
     }
 
@@ -381,7 +370,7 @@ public class SearchesService : INService
     {
         using var http = _httpFactory.CreateClient();
         http.DefaultRequestHeaders.Clear();
-        http.DefaultRequestHeaders.Add("x-rapidapi-key", _creds.RapidApiKey);
+        http.DefaultRequestHeaders.Add("x-rapidapi-key", _creds.GetCreds().RapidApiKey);
         try
         {
             var response = await http.GetStringAsync("https://omgvamp-hearthstone-v1.p.rapidapi.com/"
@@ -410,16 +399,22 @@ public class SearchesService : INService
         }
     }
 
-    public Task<OmdbMovie> GetMovieDataAsync(string name)
+    public async Task<OmdbMovie> GetMovieDataAsync(string name)
     {
         name = name.Trim().ToLowerInvariant();
-        return _cache.GetOrAddCachedDataAsync($"nadeko_movie_{name}", GetMovieDataFactory, name, TimeSpan.FromDays(1));
+        return await _c.GetOrAddAsync(new($"movie:{name}"),
+            () => GetMovieDataFactory(name),
+            TimeSpan.FromDays(1));
     }
 
     private async Task<OmdbMovie> GetMovieDataFactory(string name)
     {
         using var http = _httpFactory.CreateClient();
-        var res = await http.GetStringAsync(string.Format("https://omdbapi.nadeko.bot/?t={0}&y=&plot=full&r=json",
+        var res = await http.GetStringAsync(string.Format("https://omdbapi.nadeko.bot/"
+                                                          + "?t={0}"
+                                                          + "&y="
+                                                          + "&plot=full"
+                                                          + "&r=json",
             name.Trim().Replace(' ', '+')));
         var movie = JsonConvert.DeserializeObject<OmdbMovie>(res);
         if (movie?.Title is null)
@@ -432,10 +427,11 @@ public class SearchesService : INService
     {
         const string steamGameIdsKey = "steam_names_to_appid";
 
-        var gamesMap = await _cache.GetOrAddCachedDataAsync(steamGameIdsKey,
-            async _ =>
+        var gamesMap = await _c.GetOrAddAsync(new(steamGameIdsKey),
+            async () =>
             {
                 using var http = _httpFactory.CreateClient();
+                
                 // https://api.steampowered.com/ISteamApps/GetAppList/v2/
                 var gamesStr = await http.GetStringAsync("https://api.steampowered.com/ISteamApps/GetAppList/v2/");
                 var apps = JsonConvert
@@ -446,23 +442,18 @@ public class SearchesService : INService
                                    {
                                        apps = new List<SteamGameId>()
                                    }
-                               })
+                               })!
                            .applist.apps;
 
                 return apps.OrderBy(x => x.Name, StringComparer.OrdinalIgnoreCase)
                            .GroupBy(x => x.Name)
                            .ToDictionary(x => x.Key, x => x.First().AppId);
-                //await db.HashSetAsync("steam_game_ids", apps.Select(app => new HashEntry(app.Name.Trim().ToLowerInvariant(), app.AppId)).ToArray());
-                //await db.StringSetAsync("steam_game_ids", gamesStr, TimeSpan.FromHours(24));
-                //await db.KeyExpireAsync("steam_game_ids", TimeSpan.FromHours(24), CommandFlags.FireAndForget);
             },
-            default(string),
             TimeSpan.FromHours(24));
 
         if (gamesMap is null)
             return -1;
-
-
+        
         query = query.Trim();
 
         var keyList = gamesMap.Keys.ToList();

src/NadekoBot/Modules/Searches/StreamNotification/StreamNotificationService.cs

@@ -1,4 +1,6 @@
 #nullable disable
+using LinqToDB;
+using LinqToDB.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore;
 using NadekoBot.Common.ModuleBehaviors;
 using NadekoBot.Db;
@@ -6,10 +8,98 @@ using NadekoBot.Db.Models;
 using NadekoBot.Modules.Searches.Common;
 using NadekoBot.Modules.Searches.Common.StreamNotifications;
 using NadekoBot.Services.Database.Models;
-using StackExchange.Redis;
 
 namespace NadekoBot.Modules.Searches.Services;
 
+public sealed class StreamOnlineMessageDeleterService : INService, IReadyExecutor
+{
+    private readonly StreamNotificationService _notifService;
+    private readonly DbService _db;
+    private readonly DiscordSocketClient _client;
+    private readonly IPubSub _pubSub;
+
+    public StreamOnlineMessageDeleterService(
+        StreamNotificationService notifService,
+        DbService db,
+        IPubSub pubSub,
+        DiscordSocketClient client)
+    {
+        _notifService = notifService;
+        _db = db;
+        _client = client;
+        _pubSub = pubSub;
+    }
+
+    public async Task OnReadyAsync()
+    {
+        _notifService.OnlineMessagesSent += OnOnlineMessagesSent;
+        
+        if(_client.ShardId == 0)
+            await _pubSub.Sub(_notifService.StreamsOfflineKey, OnStreamsOffline);
+    }
+
+    private async Task OnOnlineMessagesSent(FollowedStream.FType type, string name, IReadOnlyCollection<(ulong, ulong)> pairs)
+    {
+        await using var ctx = _db.GetDbContext();
+        foreach (var (channelId, messageId) in pairs)
+        {
+            await ctx.GetTable<StreamOnlineMessage>()
+                     .InsertAsync(() => new()
+                     {
+                         Name = name,
+                         Type = type,
+                         MessageId = messageId,
+                         ChannelId = channelId,
+                         DateAdded = DateTime.UtcNow,
+                     });
+        }
+    }
+
+    private async ValueTask OnStreamsOffline(List<StreamData> streamDatas)
+    {
+        if (_client.ShardId != 0)
+            return;
+
+        var pairs = await GetMessagesToDelete(streamDatas);
+
+        foreach (var (channelId, messageId) in pairs)
+        {
+            try
+            {
+                var textChannel = await _client.GetChannelAsync(channelId) as ITextChannel;
+                if (textChannel is null)
+                    continue;
+
+                await textChannel.DeleteMessageAsync(messageId);
+            }
+            catch
+            {
+                continue;
+            }
+        }
+    }
+
+    private async Task<IEnumerable<(ulong, ulong)>> GetMessagesToDelete(List<StreamData> streamDatas)
+    {
+        await using var ctx = _db.GetDbContext();
+
+        var toReturn = new List<(ulong, ulong)>();
+        foreach (var sd in streamDatas)
+        {
+            var key = sd.CreateKey();
+            var toDelete = await ctx.GetTable<StreamOnlineMessage>()
+                                    .Where(x => (x.Type == key.Type && x.Name == key.Name)
+                                                || Sql.DateDiff(Sql.DateParts.Day, x.DateAdded, DateTime.UtcNow) > 1)
+                                    .DeleteWithOutputAsync();
+            
+            toReturn.AddRange(toDelete.Select(x => (x.ChannelId, x.MessageId)));
+        }
+
+        return toReturn;
+    }
+}
+
+
 public sealed class StreamNotificationService : INService, IReadyExecutor
 {
     private readonly DbService _db;
@@ -29,18 +119,22 @@ public sealed class StreamNotificationService : INService, IReadyExecutor
     private readonly IPubSub _pubSub;
     private readonly IEmbedBuilderService _eb;
 
-    private readonly TypedKey<List<StreamData>> _streamsOnlineKey;
-    private readonly TypedKey<List<StreamData>> _streamsOfflineKey;
+    public TypedKey<List<StreamData>> StreamsOnlineKey { get; }
+    public TypedKey<List<StreamData>> StreamsOfflineKey { get; }
 
     private readonly TypedKey<FollowStreamPubData> _streamFollowKey;
     private readonly TypedKey<FollowStreamPubData> _streamUnfollowKey;
-    private readonly ConnectionMultiplexer _redis;
+
+    public event Func<
+        FollowedStream.FType,
+        string,
+        IReadOnlyCollection<(ulong, ulong)>,
+        Task> OnlineMessagesSent = static delegate { return Task.CompletedTask; };
 
     public StreamNotificationService(
         DbService db,
         DiscordSocketClient client,
         IBotStrings strings,
-        ConnectionMultiplexer redis,
         IBotCredsProvider creds,
         IHttpClientFactory httpFactory,
         Bot bot,
@@ -52,11 +146,11 @@ public sealed class StreamNotificationService : INService, IReadyExecutor
         _strings = strings;
         _pubSub = pubSub;
         _eb = eb;
-        _redis = redis;
-        _streamTracker = new(httpFactory, creds, redis, creds.GetCreds().RedisKey(), client.ShardId == 0);
+        
+        _streamTracker = new(httpFactory, creds);
 
-        _streamsOnlineKey = new("streams.online");
-        _streamsOfflineKey = new("streams.offline");
+        StreamsOnlineKey = new("streams.online");
+        StreamsOfflineKey = new("streams.offline");
 
         _streamFollowKey = new("stream.follow");
         _streamUnfollowKey = new("stream.unfollow");
@@ -100,7 +194,7 @@ public sealed class StreamNotificationService : INService, IReadyExecutor
                 var allFollowedStreams = uow.Set<FollowedStream>().AsQueryable().ToList();
 
                 foreach (var fs in allFollowedStreams)
-                    _streamTracker.CacheAddData(fs.CreateKey(), null, false);
+                    _streamTracker.AddLastData(fs.CreateKey(), null, false);
 
                 _trackCounter = allFollowedStreams.GroupBy(x => new
                                                   {
@@ -112,8 +206,8 @@ public sealed class StreamNotificationService : INService, IReadyExecutor
             }
         }
 
-        _pubSub.Sub(_streamsOfflineKey, HandleStreamsOffline);
-        _pubSub.Sub(_streamsOnlineKey, HandleStreamsOnline);
+        _pubSub.Sub(StreamsOfflineKey, HandleStreamsOffline);
+        _pubSub.Sub(StreamsOnlineKey, HandleStreamsOnline);
 
         if (client.ShardId == 0)
         {
@@ -186,7 +280,7 @@ public sealed class StreamNotificationService : INService, IReadyExecutor
     /// </summary>
     private ValueTask HandleFollowStream(FollowStreamPubData info)
     {
-        _streamTracker.CacheAddData(info.Key, null, false);
+        _streamTracker.AddLastData(info.Key, null, false);
         lock (_shardLock)
         {
             var key = info.Key;
@@ -251,45 +345,8 @@ public sealed class StreamNotificationService : INService, IReadyExecutor
                       .WhenAll();
             }
         }
-
-        if (_client.ShardId == 0)
-        {
-            foreach (var stream in offlineStreams)
-            {
-                await DeleteOnlineMessages(stream);
-            }
-        }
-    }
-
-    private async Task DeleteOnlineMessages(StreamData stream)
-    {
-        var db = _redis.GetDatabase();
-        var data = await db.ListRangeAsync($"streams_online_del:{stream.CreateKey()}");
-        await db.KeyDeleteAsync($"streams_online_del:{stream.CreateKey()}");
-        
-        foreach (string pair in data)
-        {
-            var pairArr = pair.Split(',');
-            if (pairArr.Length != 2)
-                continue;
-
-            if (!ulong.TryParse(pairArr[0], out var chId) || !ulong.TryParse(pairArr[1], out var msgId))
-                continue;
-
-            try
-            {
-                var textChannel = await _client.GetChannelAsync(chId) as ITextChannel;
-                if (textChannel is null)
-                    continue;
-
-                await textChannel.DeleteMessageAsync(msgId);
-            }
-            catch
-            {
-                continue;
-            }
-        }
     }
+    
 
     private async ValueTask HandleStreamsOnline(List<StreamData> onlineStreams)
     {
@@ -331,14 +388,11 @@ public sealed class StreamNotificationService : INService, IReadyExecutor
                 {
                     var pairs = messages
                                 .Where(x => x != default)
-                                .Select(x => (RedisValue)$"{x.Item1},{x.Item2}")
-                                .ToArray();
+                                .Select(x => (x.Item1, x.Item2))
+                                .ToList();
 
-                    if (pairs.Length > 0)
-                    {
-                        var db = _redis.GetDatabase();
-                        await db.ListRightPushAsync($"streams_online_del:{key}", pairs);
-                    }
+                    if (pairs.Count > 0)
+                        await OnlineMessagesSent(key.Type, key.Name, pairs);
                 }
                 catch
                 {
@@ -349,10 +403,10 @@ public sealed class StreamNotificationService : INService, IReadyExecutor
     }
 
     private Task OnStreamsOnline(List<StreamData> data)
-        => _pubSub.Pub(_streamsOnlineKey, data);
+        => _pubSub.Pub(StreamsOnlineKey, data);
 
     private Task OnStreamsOffline(List<StreamData> data)
-        => _pubSub.Pub(_streamsOfflineKey, data);
+        => _pubSub.Pub(StreamsOfflineKey, data);
 
     private Task ClientOnJoinedGuild(GuildConfig guildConfig)
     {

src/NadekoBot/Modules/Searches/_Common/CryptoData.cs

@@ -16,11 +16,11 @@ public class CmcQuote
     [JsonPropertyName("volume_24h")]
     public double Volume24h { get; set; }
 
-    [JsonPropertyName("volume_change_24h")]
-    public double VolumeChange24h { get; set; }
-
-    [JsonPropertyName("percent_change_1h")]
-    public double PercentChange1h { get; set; }
+    // [JsonPropertyName("volume_change_24h")]
+    // public double VolumeChange24h { get; set; }
+    //
+    // [JsonPropertyName("percent_change_1h")]
+    // public double PercentChange1h { get; set; }
 
     [JsonPropertyName("percent_change_24h")]
     public double PercentChange24h { get; set; }
@@ -33,12 +33,6 @@ public class CmcQuote
 
     [JsonPropertyName("market_cap_dominance")]
     public double MarketCapDominance { get; set; }
-
-    [JsonPropertyName("fully_diluted_market_cap")]
-    public double FullyDilutedMarketCap { get; set; }
-
-    [JsonPropertyName("last_updated")]
-    public DateTime LastUpdated { get; set; }
 }
 
 public class CmcResponseData
@@ -58,9 +52,6 @@ public class CmcResponseData
     [JsonPropertyName("cmc_rank")]
     public int CmcRank { get; set; }
 
-    [JsonPropertyName("num_market_pairs")]
-    public int NumMarketPairs { get; set; }
-
     [JsonPropertyName("circulating_supply")]
     public double? CirculatingSupply { get; set; }
 
@@ -70,15 +61,6 @@ public class CmcResponseData
     [JsonPropertyName("max_supply")]
     public double? MaxSupply { get; set; }
 
-    [JsonPropertyName("last_updated")]
-    public DateTime LastUpdated { get; set; }
-
-    [JsonPropertyName("date_added")]
-    public DateTime DateAdded { get; set; }
-
-    [JsonPropertyName("tags")]
-    public List<string> Tags { get; set; }
-
     [JsonPropertyName("quote")]
     public Dictionary<string, CmcQuote> Quote { get; set; }
 }

src/NadekoBot/Modules/Searches/_Common/Gallery.cs

@@ -9,7 +9,7 @@ public sealed class Tag
 
 public sealed class Gallery
 {
-    public string Id { get; }
+    public uint Id { get; }
     public string Url { get; }
     public string FullTitle { get; }
     public string Title { get; }
@@ -21,7 +21,7 @@ public sealed class Gallery
 
 
     public Gallery(
-        string id,
+        uint id,
         string url,
         string fullTitle,
         string title,

src/NadekoBot/Modules/Searches/_Common/NhentaiApiModel.cs

@@ -1,121 +0,0 @@
-#nullable disable
-using Newtonsoft.Json;
-
-namespace NadekoBot.Modules.Searches.Common;
-
-public static class NhentaiApiModel
-{
-    public class Title
-    {
-        [JsonProperty("english")]
-        public string English { get; set; }
-
-        [JsonProperty("japanese")]
-        public string Japanese { get; set; }
-
-        [JsonProperty("pretty")]
-        public string Pretty { get; set; }
-    }
-
-    public class Page
-    {
-        [JsonProperty("t")]
-        public string T { get; set; }
-
-        [JsonProperty("w")]
-        public int W { get; set; }
-
-        [JsonProperty("h")]
-        public int H { get; set; }
-    }
-
-    public class Cover
-    {
-        [JsonProperty("t")]
-        public string T { get; set; }
-
-        [JsonProperty("w")]
-        public int W { get; set; }
-
-        [JsonProperty("h")]
-        public int H { get; set; }
-    }
-
-    public class Thumbnail
-    {
-        [JsonProperty("t")]
-        public string T { get; set; }
-
-        [JsonProperty("w")]
-        public int W { get; set; }
-
-        [JsonProperty("h")]
-        public int H { get; set; }
-    }
-
-    public class Images
-    {
-        [JsonProperty("pages")]
-        public List<Page> Pages { get; set; }
-
-        [JsonProperty("cover")]
-        public Cover Cover { get; set; }
-
-        [JsonProperty("thumbnail")]
-        public Thumbnail Thumbnail { get; set; }
-    }
-
-    public class Tag
-    {
-        [JsonProperty("id")]
-        public int Id { get; set; }
-
-        [JsonProperty("type")]
-        public string Type { get; set; }
-
-        [JsonProperty("name")]
-        public string Name { get; set; }
-
-        [JsonProperty("url")]
-        public string Url { get; set; }
-
-        [JsonProperty("count")]
-        public int Count { get; set; }
-    }
-
-    public class Gallery
-    {
-        [JsonProperty("id")]
-        public int Id { get; set; }
-
-        [JsonProperty("media_id")]
-        public string MediaId { get; set; }
-
-        [JsonProperty("title")]
-        public Title Title { get; set; }
-
-        [JsonProperty("images")]
-        public Images Images { get; set; }
-
-        [JsonProperty("scanlator")]
-        public string Scanlator { get; set; }
-
-        [JsonProperty("upload_date")]
-        public double UploadDate { get; set; }
-
-        [JsonProperty("tags")]
-        public Tag[] Tags { get; set; }
-
-        [JsonProperty("num_pages")]
-        public int NumPages { get; set; }
-
-        [JsonProperty("num_favorites")]
-        public int NumFavorites { get; set; }
-    }
-
-    public class SearchResult
-    {
-        [JsonProperty("result")]
-        public Gallery[] Result { get; set; }
-    }
-}

src/NadekoBot/Modules/Searches/_Common/StreamNotifications/Models/StreamDataKey.cs

@@ -6,10 +6,9 @@ namespace NadekoBot.Modules.Searches.Common;
 
 public readonly struct StreamDataKey
 {
-    public FollowedStream.FType Type { get; }
-    public string Name { get; }
+    public FollowedStream.FType Type { get; init; }
+    public string Name { get; init; }
 
-    [JsonConstructor]
     public StreamDataKey(FollowedStream.FType type, string name)
     {
         Type = type;

src/NadekoBot/Modules/Searches/_Common/StreamNotifications/NotifChecker.cs

@@ -1,7 +1,5 @@
 using NadekoBot.Db.Models;
 using NadekoBot.Modules.Searches.Common.StreamNotifications.Providers;
-using Newtonsoft.Json;
-using StackExchange.Redis;
 
 namespace NadekoBot.Modules.Searches.Common.StreamNotifications;
 
@@ -9,30 +7,22 @@ public class NotifChecker
 {
     public event Func<List<StreamData>, Task> OnStreamsOffline = _ => Task.CompletedTask;
     public event Func<List<StreamData>, Task> OnStreamsOnline = _ => Task.CompletedTask;
-    private readonly ConnectionMultiplexer _multi;
-    private readonly string _key;
 
-    private readonly Dictionary<FollowedStream.FType, Provider> _streamProviders;
+    private readonly IReadOnlyDictionary<FollowedStream.FType, Provider> _streamProviders;
     private readonly HashSet<(FollowedStream.FType, string)> _offlineBuffer;
+    private readonly ConcurrentDictionary<StreamDataKey, StreamData?> _cache = new();
 
     public NotifChecker(
         IHttpClientFactory httpClientFactory,
-        IBotCredsProvider credsProvider,
-        ConnectionMultiplexer multi,
-        string uniqueCacheKey,
-        bool isMaster)
+        IBotCredsProvider credsProvider)
     {
-        _multi = multi;
-        _key = $"{uniqueCacheKey}_followed_streams_data";
-        _streamProviders = new()
+        _streamProviders = new Dictionary<FollowedStream.FType, Provider>()
         {
             { FollowedStream.FType.Twitch, new TwitchHelixProvider(httpClientFactory, credsProvider) },
             { FollowedStream.FType.Picarto, new PicartoProvider(httpClientFactory) },
             { FollowedStream.FType.Trovo, new TrovoProvider(httpClientFactory, credsProvider) }
         };
         _offlineBuffer = new();
-        if (isMaster)
-            CacheClearAllData();
     }
 
     // gets all streams which have been failing for more than the provided timespan
@@ -61,7 +51,7 @@ public class NotifChecker
             {
                 try
                 {
-                    var allStreamData = CacheGetAllData();
+                    var allStreamData = GetAllData();
 
                     var oldStreamDataDict = allStreamData
                                             // group by type
@@ -101,7 +91,7 @@ public class NotifChecker
                             || !typeDict.TryGetValue(key.Name, out var oldData)
                             || oldData is null)
                         {
-                            CacheAddData(key, newData, true);
+                            AddLastData(key, newData, true);
                             continue;
                         }
                         
@@ -109,7 +99,7 @@ public class NotifChecker
                         if (string.IsNullOrWhiteSpace(newData.Game))
                             newData.Game = oldData.Game;
                         
-                        CacheAddData(key, newData, true);
+                        AddLastData(key, newData, true);
 
                         // if the stream is offline, we need to check if it was
                         // marked as offline once previously
@@ -158,39 +148,22 @@ public class NotifChecker
             }
         });
 
-    public bool CacheAddData(StreamDataKey key, StreamData? data, bool replace)
+    public bool AddLastData(StreamDataKey key, StreamData? data, bool replace)
     {
-        var db = _multi.GetDatabase();
-        return db.HashSet(_key,
-            JsonConvert.SerializeObject(key),
-            JsonConvert.SerializeObject(data),
-            replace ? When.Always : When.NotExists);
+        if (replace)
+        {
+            _cache[key] = data;
+            return true;
+        }
+        
+        return _cache.TryAdd(key, data);
     }
 
-    public void CacheDeleteData(StreamDataKey key)
-    {
-        var db = _multi.GetDatabase();
-        db.HashDelete(_key, JsonConvert.SerializeObject(key));
-    }
+    public void DeleteLastData(StreamDataKey key)
+        => _cache.TryRemove(key, out _);
 
-    public void CacheClearAllData()
-    {
-        var db = _multi.GetDatabase();
-        db.KeyDelete(_key);
-    }
-
-    public Dictionary<StreamDataKey, StreamData?> CacheGetAllData()
-    {
-        var db = _multi.GetDatabase();
-        if (!db.KeyExists(_key))
-            return new();
-
-        return db.HashGetAll(_key)
-                 .ToDictionary(entry => JsonConvert.DeserializeObject<StreamDataKey>(entry.Name),
-                     entry => entry.Value.IsNullOrEmpty
-                         ? default
-                         : JsonConvert.DeserializeObject<StreamData>(entry.Value));
-    }
+    public Dictionary<StreamDataKey, StreamData?> GetAllData()
+        => _cache.ToDictionary(x => x.Key, x => x.Value);
 
     public async Task<StreamData?> GetStreamDataByUrlAsync(string url)
     {
@@ -234,9 +207,9 @@ public class NotifChecker
 
         // if stream is found, add it to the cache for tracking only if it doesn't already exist
         // because stream will be checked and events will fire in a loop. We don't want to override old state
-        return CacheAddData(data.CreateKey(), data, false);
+        return AddLastData(data.CreateKey(), data, false);
     }
 
     public void UntrackStreamByKey(in StreamDataKey key)
-        => CacheDeleteData(key);
+        => DeleteLastData(key);
 }

src/NadekoBot/Modules/Utility/CommandMap/CommandMapService.cs

@@ -27,7 +27,8 @@ public class CommandMapService : IInputTransformer, INService
 
         AliasMaps = new(configs.ToDictionary(x => x.GuildId,
             x => new ConcurrentDictionary<string, string>(x.CommandAliases.DistinctBy(ca => ca.Trigger)
-                                                           .ToDictionary(ca => ca.Trigger, ca => ca.Mapping))));
+                                                           .ToDictionary(ca => ca.Trigger, ca => ca.Mapping),
+                StringComparer.OrdinalIgnoreCase)));
 
         _db = db;
     }
@@ -53,37 +54,72 @@ public class CommandMapService : IInputTransformer, INService
     {
         if (guild is null || string.IsNullOrWhiteSpace(input))
             return null;
-
+        
         if (AliasMaps.TryGetValue(guild.Id, out var maps))
         {
-            var keys = maps.Keys.OrderByDescending(x => x.Length);
-
-            foreach (var k in keys)
+            string newInput = null;
+            foreach (var (k, v) in maps)
             {
-                string newInput;
-                if (input.StartsWith(k + " ", StringComparison.InvariantCultureIgnoreCase))
-                    newInput = maps[k] + input.Substring(k.Length, input.Length - k.Length);
-                else if (input.Equals(k, StringComparison.InvariantCultureIgnoreCase))
-                    newInput = maps[k];
-                else
-                    continue;
-
-                try
+                if (string.Equals(input, k, StringComparison.OrdinalIgnoreCase))
                 {
-                    var toDelete = await channel.SendConfirmAsync(_eb, $"{input} => {newInput}");
-                    _ = Task.Run(async () =>
-                    {
-                        await Task.Delay(1500);
-                        await toDelete.DeleteAsync(new()
-                        {
-                            RetryMode = RetryMode.AlwaysRetry
-                        });
-                    });
+                    newInput = v;
+                }
+                else if (input.StartsWith(k + ' ', StringComparison.OrdinalIgnoreCase))
+                {
+                    newInput = v + ' ' + input[k.Length..];
                 }
-                catch { }
 
-                return newInput;
+                if (newInput is not null)
+                {
+                    try
+                    {
+                        var toDelete = await channel.SendConfirmAsync(_eb, $"{input} => {newInput}");
+                        _ = Task.Run(async () =>
+                        {
+                            await Task.Delay(1500);
+                            await toDelete.DeleteAsync(new()
+                            {
+                                RetryMode = RetryMode.AlwaysRetry
+                            });
+                        });
+                    }
+                    catch
+                    {
+                    }
+
+                    return newInput;
+                }
             }
+
+            return null;
+
+            // var keys = maps.Keys.OrderByDescending(x => x.Length);
+            // foreach (var k in keys)
+            // {
+            //     string newInput;
+            //     if (input.StartsWith(k + " ", StringComparison.InvariantCultureIgnoreCase))
+            //         newInput = maps[k] + input.Substring(k.Length, input.Length - k.Length);
+            //     else if (input.Equals(k, StringComparison.InvariantCultureIgnoreCase))
+            //         newInput = maps[k];
+            //     else
+            //         continue;
+            //
+            //     try
+            //     {
+            //         var toDelete = await channel.SendConfirmAsync(_eb, $"{input} => {newInput}");
+            //         _ = Task.Run(async () =>
+            //         {
+            //             await Task.Delay(1500);
+            //             await toDelete.DeleteAsync(new()
+            //             {
+            //                 RetryMode = RetryMode.AlwaysRetry
+            //             });
+            //         });
+            //     }
+            //     catch { }
+            //
+            //     return newInput;
+            // }
         }
 
         return null;

src/NadekoBot/Modules/Utility/Patronage/Config/PatronConfigData.cs

@@ -7,7 +7,7 @@ namespace NadekoBot.Modules.Utility.Patronage;
 public partial class PatronConfigData : ICloneable<PatronConfigData>
 {
     [Comment("DO NOT CHANGE")]
-    public int Version { get; set; } = 1;
+    public int Version { get; set; } = 2;
     
     [Comment("Whether the patronage feature is enabled")]
     public bool IsEnabled { get; set; }

src/NadekoBot/Modules/Utility/Patronage/Config/PatronageConfig.cs

@@ -18,5 +18,19 @@ public class PatronageConfig : ConfigServiceBase<PatronConfigData>
             x => x.IsEnabled,
             bool.TryParse,
             ConfigPrinters.ToString);
+
+        Migrate();
+    }
+
+    private void Migrate()
+    {
+        ModifyConfig(c =>
+        {
+            if (c.Version == 1)
+            {
+                c.Version = 2;
+                c.IsEnabled = false;
+            }
+        });
     }
 }

src/NadekoBot/Modules/Utility/Patronage/PatronageService.cs

@@ -3,6 +3,7 @@ using LinqToDB.EntityFrameworkCore;
 using NadekoBot.Common.ModuleBehaviors;
 using NadekoBot.Db.Models;
 using OneOf;
+using OneOf.Types;
 using StackExchange.Redis;
 using CommandInfo = Discord.Commands.CommandInfo;
 
@@ -30,9 +31,11 @@ public sealed class PatronageService
     private readonly DiscordSocketClient _client;
     private readonly ISubscriptionHandler _subsHandler;
     private readonly IEmbedBuilderService _eb;
-    private readonly ConnectionMultiplexer _redis;
-    private readonly IBotCredentials _creds;
-    private readonly TypedKey<bool> _quotaKey;
+    private static readonly TypedKey<long> _quotaKey 
+        = new($"quota:last_hourly_reset");
+
+    private readonly IBotCache _cache;
+    private readonly IBotCredsProvider _creds;
 
     public PatronageService(
         PatronageConfig pConf,
@@ -40,18 +43,16 @@ public sealed class PatronageService
         DiscordSocketClient client,
         ISubscriptionHandler subsHandler,
         IEmbedBuilderService eb,
-        ConnectionMultiplexer redis,
-        IBotCredentials creds)
+        IBotCache cache, 
+        IBotCredsProvider creds)
     {
         _pConf = pConf;
         _db = db;
         _client = client;
         _subsHandler = subsHandler;
         _eb = eb;
-        _redis = redis;
+        _cache = cache;
         _creds = creds;
-
-        _quotaKey = new TypedKey<bool>($"{_creds.RedisKey()}:quota:last_hourly_reset");
     }
 
     public Task OnReadyAsync()
@@ -100,11 +101,10 @@ public sealed class PatronageService
                 var now = DateTime.UtcNow;
                 var lastRun = DateTime.MinValue;
 
-                var rdb = _redis.GetDatabase();
-                var lastVal = await rdb.StringGetAsync(_quotaKey.Key);
-                if (lastVal != default)
+                var result = await _cache.GetAsync(_quotaKey);
+                if (result.TryGetValue(out var lastVal) && lastVal != default)
                 {
-                    lastRun = DateTime.FromBinary((long)lastVal);
+                    lastRun = DateTime.FromBinary(lastVal);
                 }
 
                 var nowDate = now.ToDateOnly();
@@ -129,8 +129,6 @@ public sealed class PatronageService
                                  HourlyCount = 0,
                                  DailyCount = 0,
                              });
-
-                    await rdb.StringSetAsync(_quotaKey.Key, true);
                 }
                 else if (now.Hour != lastRun.Hour) // if it's not, just reset hourly quotas
                 {
@@ -142,7 +140,7 @@ public sealed class PatronageService
                 }
 
                 // assumes that the code above runs in less than an hour
-                await rdb.StringSetAsync(_quotaKey.Key, now.ToBinary());
+                await _cache.AddAsync(_quotaKey, now.ToBinary());
                 await tran.CommitAsync();
             }
             catch (Exception ex)
@@ -500,7 +498,7 @@ public sealed class PatronageService
         if (!confData.IsEnabled)
             return default;
 
-        if (_creds.IsOwner(userId))
+        if (_creds.GetCreds().IsOwner(userId))
             return default;
 
         // get user tier
@@ -558,7 +556,9 @@ public sealed class PatronageService
             data.TryGetValue(QuotaPer.PerMonth, out var monthly) ? monthly : null
         );
 
-        return quotaCheckResult.Match(_ => default, x => x);
+        return quotaCheckResult.Match<OneOf<Success, InsufficientTier, QuotaLimit>>(
+            _ => new Success(),
+            x => x);
     }
 
     private bool TryGetTierDataOrLower<T>(

src/NadekoBot/Modules/Utility/Quote/QuoteCommands.cs

@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable warnings
 using NadekoBot.Common.Yml;
 using NadekoBot.Db;
 using NadekoBot.Services.Database.Models;
@@ -134,30 +134,40 @@ public partial class Utility
                                                .WithFooter(
                                                    GetText(strs.created_by($"{data.AuthorName} ({data.AuthorId})"))));
 
-        [Cmd]
-        [RequireContext(ContextType.Guild)]
-        public async partial Task QuoteSearch(string keyword, [Leftover] string text)
+        private async Task QuoteSearchinternalAsync(string? keyword, string textOrAuthor)
         {
-            if (string.IsNullOrWhiteSpace(keyword) || string.IsNullOrWhiteSpace(text))
+            if (string.IsNullOrWhiteSpace(textOrAuthor))
                 return;
 
-            keyword = keyword.ToUpperInvariant();
+            keyword = keyword?.ToUpperInvariant();
 
-            Quote keywordquote;
+            Quote quote;
             await using (var uow = _db.GetDbContext())
             {
-                keywordquote = await uow.Quotes.SearchQuoteKeywordTextAsync(ctx.Guild.Id, keyword, text);
+                quote = await uow.Quotes.SearchQuoteKeywordTextAsync(ctx.Guild.Id, keyword, textOrAuthor);
             }
 
-            if (keywordquote is null)
+            if (quote is null)
                 return;
 
-            await ctx.Channel.SendMessageAsync($"`#{keywordquote.Id}` 💬 "
-                                               + keyword.ToLowerInvariant()
+            await ctx.Channel.SendMessageAsync($"`#{quote.Id}` 💬 "
+                                               + quote.Keyword.ToLowerInvariant()
                                                + ":  "
-                                               + keywordquote.Text.SanitizeAllMentions());
+                                               + quote.Text.SanitizeAllMentions());
         }
 
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [Priority(0)]
+        public partial Task QuoteSearch(string textOrAuthor)
+            => QuoteSearchinternalAsync(null, textOrAuthor);
+        
+        [Cmd]
+        [RequireContext(ContextType.Guild)]
+        [Priority(1)]
+        public partial Task QuoteSearch(string keyword, [Leftover] string textOrAuthor)
+            => QuoteSearchinternalAsync(keyword, textOrAuthor);
+
         [Cmd]
         [RequireContext(ContextType.Guild)]
         public async partial Task QuoteId(int id)

src/NadekoBot/Modules/Utility/Remind/RemindService.cs

@@ -178,4 +178,27 @@ public class RemindService : INService, IReadyExecutor
         public string What { get; set; }
         public TimeSpan Time { get; set; }
     }
+
+    public async Task AddReminderAsync(ulong userId,
+        ulong targetId,
+        ulong? guildId,
+        bool isPrivate,
+        DateTime time,
+        string message)
+    {
+        var rem = new Reminder
+        {
+            UserId = userId,
+            ChannelId = targetId,
+            ServerId = guildId ?? 0,
+            IsPrivate = isPrivate,
+            When = time,
+            Message = message, 
+        };
+
+        await using var ctx = _db.GetDbContext();
+        await ctx.Reminders
+                 .AddAsync(rem);
+        await ctx.SaveChangesAsync();
+    }
 }

src/NadekoBot/Modules/Utility/StreamRole/StreamRoleService.cs

@@ -221,7 +221,7 @@ public class StreamRoleService : IReadyExecutor, INService
     }
 
     private async ValueTask RescanUser(IGuildUser user, StreamRoleSettings setting, IRole addRole = null)
-        => await _queueRunner.Enqueue(() => RescanUserInternal(user, setting, addRole));
+        => await _queueRunner.EnqueueAsync(() => RescanUserInternal(user, setting, addRole));
 
     private async Task RescanUserInternal(IGuildUser user, StreamRoleSettings setting, IRole addRole = null)
     {
@@ -239,7 +239,7 @@ public class StreamRoleService : IReadyExecutor, INService
             && setting.Blacklist.All(x => x.UserId != user.Id)
             && user.RoleIds.Contains(setting.FromRoleId))
         {
-            await _queueRunner.Enqueue(async () =>
+            await _queueRunner.EnqueueAsync(async () =>
             {
                 try
                 {
@@ -277,7 +277,7 @@ public class StreamRoleService : IReadyExecutor, INService
             //check if user is in the addrole
             if (user.RoleIds.Contains(setting.AddRoleId))
             {
-                await _queueRunner.Enqueue(async () =>
+                await _queueRunner.EnqueueAsync(async () =>
                 {
                     try
                     {

src/NadekoBot/Modules/Utility/UnitConversion/ConverterService.cs

@@ -1,23 +1,24 @@
 #nullable disable
 using NadekoBot.Common.ModuleBehaviors;
 using NadekoBot.Modules.Utility.Common;
-using Newtonsoft.Json;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace NadekoBot.Modules.Utility.Services;
 
 public class ConverterService : INService, IReadyExecutor
 {
-    public ConvertUnit[] Units
-        => _cache.Redis.GetDatabase().StringGet("converter_units").ToString().MapJson<ConvertUnit[]>();
+    private static readonly TypedKey<List<ConvertUnit>> _convertKey =
+        new("convert:units");
 
     private readonly TimeSpan _updateInterval = new(12, 0, 0);
     private readonly DiscordSocketClient _client;
-    private readonly IDataCache _cache;
+    private readonly IBotCache _cache;
     private readonly IHttpClientFactory _httpFactory;
 
     public ConverterService(
         DiscordSocketClient client,
-        IDataCache cache,
+        IBotCache cache,
         IHttpClientFactory factory)
     {
         _client = client;
@@ -48,7 +49,7 @@ public class ConverterService : INService, IReadyExecutor
     {
         using var http = _httpFactory.CreateClient();
         var res = await http.GetStringAsync("https://convertapi.nadeko.bot/latest");
-        return JsonConvert.DeserializeObject<Rates>(res);
+        return JsonSerializer.Deserialize<Rates>(res);
     }
 
     private async Task UpdateCurrency()
@@ -61,29 +62,38 @@ public class ConverterService : INService, IReadyExecutor
             Modifier = decimal.One,
             UnitType = unitTypeString
         };
-        var range = currencyRates.ConversionRates.Select(u => new ConvertUnit
+        var units = currencyRates.ConversionRates.Select(u => new ConvertUnit
                                  {
                                      Triggers = new[] { u.Key },
                                      Modifier = u.Value,
                                      UnitType = unitTypeString
                                  })
-                                 .ToArray();
+                                 .ToList();
 
-        var fileData = JsonConvert.DeserializeObject<ConvertUnit[]>(File.ReadAllText("data/units.json"))
-                                  ?.Where(x => x.UnitType != "currency");
-        if (fileData is null)
-            return;
-
-        var data = JsonConvert.SerializeObject(range.Append(baseType).Concat(fileData).ToList());
-        _cache.Redis.GetDatabase().StringSet("converter_units", data);
+        var stream =  File.OpenRead("data/units.json");
+        var defaultUnits = await JsonSerializer.DeserializeAsync<ConvertUnit[]>(stream);
+        if(defaultUnits is not null)
+            units.AddRange(defaultUnits);
+        
+        units.Add(baseType);
+        
+        await _cache.AddAsync(_convertKey, units);
     }
+
+    public async Task<IReadOnlyList<ConvertUnit>> GetUnitsAsync()
+        => (await _cache.GetAsync(_convertKey)).TryGetValue(out var list)
+            ? list
+            : Array.Empty<ConvertUnit>();
 }
 
 public class Rates
 {
+    [JsonPropertyName("base")]
     public string Base { get; set; }
+    
+    [JsonPropertyName("date")]
     public DateTime Date { get; set; }
 
-    [JsonProperty("rates")]
+    [JsonPropertyName("rates")]
     public Dictionary<string, decimal> ConversionRates { get; set; }
 }

src/NadekoBot/Modules/Utility/UnitConversion/UnitConversionCommands.cs

@@ -11,7 +11,7 @@ public partial class Utility
         [Cmd]
         public async partial Task ConvertList()
         {
-            var units = _service.Units;
+            var units = await _service.GetUnitsAsync();
 
             var embed = _eb.Create().WithTitle(GetText(strs.convertlist)).WithOkColor();
 
@@ -29,9 +29,10 @@ public partial class Utility
         [Priority(0)]
         public async partial Task Convert(string origin, string target, decimal value)
         {
-            var originUnit = _service.Units.FirstOrDefault(x
+            var units = await _service.GetUnitsAsync();
+            var originUnit = units.FirstOrDefault(x
                 => x.Triggers.Select(y => y.ToUpperInvariant()).Contains(origin.ToUpperInvariant()));
-            var targetUnit = _service.Units.FirstOrDefault(x
+            var targetUnit = units.FirstOrDefault(x
                 => x.Triggers.Select(y => y.ToUpperInvariant()).Contains(target.ToUpperInvariant()));
             if (originUnit is null || targetUnit is null)
             {

src/NadekoBot/Modules/Utility/Utility.cs

@@ -1,4 +1,7 @@
 #nullable disable
+using Microsoft.CodeAnalysis.CSharp.Scripting;
+using Microsoft.CodeAnalysis.Scripting;
+using NadekoBot.Modules.Utility.Services;
 using Newtonsoft.Json;
 using System.Diagnostics;
 using System.Text;
@@ -32,6 +35,7 @@ public partial class Utility : NadekoModule
     private readonly IBotCredentials _creds;
     private readonly DownloadTracker _tracker;
     private readonly IHttpClientFactory _httpFactory;
+    private readonly VerboseErrorsService _veService;
 
     public Utility(
         DiscordSocketClient client,
@@ -39,7 +43,8 @@ public partial class Utility : NadekoModule
         IStatsService stats,
         IBotCredentials creds,
         DownloadTracker tracker,
-        IHttpClientFactory httpFactory)
+        IHttpClientFactory httpFactory,
+        VerboseErrorsService veService)
     {
         _client = client;
         _coord = coord;
@@ -47,6 +52,7 @@ public partial class Utility : NadekoModule
         _creds = creds;
         _tracker = tracker;
         _httpFactory = httpFactory;
+        _veService = veService;
     }
     
     [Cmd]
@@ -482,44 +488,17 @@ public partial class Utility : NadekoModule
             sem.Release();
         }
     }
+    
+    [Cmd]
+    [RequireContext(ContextType.Guild)]
+    [UserPerm(GuildPerm.ManageMessages)]
+    public async partial Task VerboseError(bool? newstate = null)
+    {
+        var state = _veService.ToggleVerboseErrors(ctx.Guild.Id, newstate);
 
-
-    // [NadekoCommand, Usage, Description, Aliases]
-    // [RequireContext(ContextType.Guild)]
-    // public async Task CreateMyInvite(CreateInviteType type = CreateInviteType.Any)
-    // {
-    //     if (type == CreateInviteType.Any)
-    //     {
-    //         if (_inviteService.TryGetInvite(type, out var code))
-    //         {
-    //             await ReplyErrorLocalizedAsync(strs.your_invite($"https://discord.gg/{code}"));
-    //             return;
-    //         }
-    //     }
-    //     
-    //     var invite = await ((ITextChannel) ctx.Channel).CreateInviteAsync(isUnique: true);
-    // }
-    //
-    // [NadekoCommand, Usage, Description, Aliases]
-    // [RequireContext(ContextType.Guild)]
-    // public async partial Task InviteLb(int page = 1)
-    // {
-    //     if (--page < 0)
-    //         return;
-    //
-    //     var inviteUsers = await _inviteService.GetInviteUsersAsync(ctx.Guild.Id);
-    //     
-    //     var embed = _eb.Create()
-    //         .WithOkColor();
-    //
-    //     await ctx.SendPaginatedConfirmAsync(page, (curPage) =>
-    //     {
-    //         var items = inviteUsers.Skip(curPage * 9).Take(9);
-    //         var i = 0;
-    //         foreach (var item in items)
-    //             embed.AddField($"#{curPage * 9 + ++i} {item.UserName} [{item.User.Id}]", item.InvitedUsers);
-    //
-    //         return embed;
-    //     }, inviteUsers.Count, 9);
-    // }
+        if (state)
+            await ReplyConfirmLocalizedAsync(strs.verbose_errors_enabled);
+        else
+            await ReplyConfirmLocalizedAsync(strs.verbose_errors_disabled);
+    }
 }

src/NadekoBot/Modules/Utility/VerboseErrors/EvalCommands.cs

@@ -0,0 +1,76 @@
+#nullable disable
+using Microsoft.CodeAnalysis.CSharp.Scripting;
+using Microsoft.CodeAnalysis.Scripting;
+
+namespace NadekoBot.Modules.Utility;
+
+public partial class Utility
+{
+    [Group]
+    public partial class EvalCommands : NadekoModule
+    {
+        private readonly IServiceProvider _services;
+
+        public EvalCommands(IServiceProvider services)
+        {
+            _services = services;
+        }
+        
+        [Cmd]
+        [NoPublicBot]
+        [OwnerOnly]
+        public async partial Task Eval([Leftover] string scriptText)
+        {
+            _ = ctx.Channel.TriggerTypingAsync();
+
+            if (scriptText.StartsWith("```cs"))
+                scriptText = scriptText[5..];
+            else if (scriptText.StartsWith("```"))
+                scriptText = scriptText[3..];
+
+            if (scriptText.EndsWith("```"))
+                scriptText = scriptText[..^3];
+            
+            var script = CSharpScript.Create(scriptText,
+                ScriptOptions.Default
+                             .WithReferences(this.GetType().Assembly)
+                             .WithImports(
+                                 "System",
+                                 "NadekoBot",
+                                 "NadekoBot.Extensions",
+                                 "Microsoft.Extensions.DependencyInjection",
+                                 "NadekoBot.Common",
+                                 "System.Text",
+                                 "System.Text.Json"),
+                globalsType: typeof(EvalGlobals));
+            
+            try
+            {
+                var result = await script.RunAsync(new EvalGlobals()
+                {
+                    ctx = this.ctx,
+                    guild = this.ctx.Guild,
+                    channel = this.ctx.Channel,
+                    user = this.ctx.User,
+                    self = this,
+                    services = _services
+                });
+
+                var output = result.ReturnValue?.ToString();
+                if (!string.IsNullOrWhiteSpace(output))
+                {
+                    var eb = _eb.Create(ctx)
+                                .WithOkColor()
+                                .AddField("Code", scriptText)
+                                .AddField("Output", output.TrimTo(512)!);
+
+                    _ = ctx.Channel.EmbedAsync(eb);
+                }
+            }
+            catch (Exception ex)
+            {
+                await SendErrorAsync(ex.Message);
+            }
+        }
+    }
+}

src/NadekoBot/Modules/Utility/VerboseErrors/EvalGlobals.cs

@@ -0,0 +1,13 @@
+// ReSharper disable InconsistentNaming
+#nullable disable
+namespace NadekoBot.Modules.Utility;
+
+public class EvalGlobals
+{
+    public ICommandContext ctx;
+    public Utility.EvalCommands self;
+    public IUser user;
+    public IMessageChannel channel;
+    public IGuild guild;
+    public IServiceProvider services;
+}