Repository: hikari-py/hikari
Pull request #1210 (2022-07-13 13:07:24)

Bump coverage[toml] from 6.4.1 to 6.4.2
Bumps [coverage[toml]](https://github.com/nedbat/coveragepy) from 6.4.1 to 6.4.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/nedbat/coveragepy/releases">coverage[toml]'s releases</a>.</em></p>
<blockquote>
<h2>6.4.2</h2>
<ul>
<li>Updated for a small change in Python 3.11.0 beta 4: modules now start with a line with line number 0, which is ignored. This line cannnot be executed, so coverage totals were thrown off. This line is now ignored by coverage.py, but this also means that truly empty modules (like <code>__init__.py</code>) have no lines in them, rather than one phantom line. Fixes <a href="https://github-redirect.dependabot.com/nedbat/coveragepy/issues/1419">issue 1419</a>.</li>
<li>Internal debugging data added to sys.modules is now an actual module, to avoid confusing code that examines everything in sys.modules. Thanks, Yilei Yang (<a href="https://github-redirect.dependabot.com/nedbat/coveragepy/pull/1399">pull 1399</a>).</li>
</ul>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/nedbat/coveragepy/blob/master/CHANGES.rst">coverage[toml]'s changelog</a>.</em></p>
<blockquote>
<h2>Version 6.4.2 — 2022-07-12</h2>
<ul>
<li>
<p>Updated for a small change in Python 3.11.0 beta 4: modules now start with a
line with line number 0, which is ignored.  This line cannnot be executed, so
coverage totals were thrown off.  This line is now ignored by coverage.py,
but this also means that truly empty modules (like <code>__init__.py</code>) have no
lines in them, rather than one phantom line.  Fixes <code>issue 1419</code>_.</p>
</li>
<li>
<p>Internal debugging data added to sys.modules is now an actual module, to
avoid confusing code that examines everything in sys.modules.  Thanks,
Yilei Yang (<code>pull 1399</code>_).</p>
</li>
</ul>
<p>.. _pull 1399: <a href="https://github-redirect.dependabot.com/nedbat/coveragepy/pull/1399">nedbat/coveragepy#1399</a>
.. _issue 1419: <a href="https://github-redirect.dependabot.com/nedbat/coveragepy/issues/1419">nedbat/coveragepy#1419</a></p>
<p>.. _changes_6-4-1:</p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/nedbat/coveragepy/commit/8ab9ff17409e3f6f3f5f2c0076d8b3250e8da4a0"><code>8ab9ff1</code></a> docs: latest sample HTML report</li>
<li><a href="https://github.com/nedbat/coveragepy/commit/ee751cf6de6aa28649217aeae88900b61bf9079c"><code>ee751cf</code></a> docs: prep for 6.4.2</li>
<li><a href="https://github.com/nedbat/coveragepy/commit/413ccb71855bb563de1d71bff5ff37335447ee02"><code>413ccb7</code></a> build: run tests on nightly versions every day</li>
<li><a href="https://github.com/nedbat/coveragepy/commit/d890bff10374bfed8b4a484e7b582f6b24343b18"><code>d890bff</code></a> docs: update the 3.11 version</li>
<li><a href="https://github.com/nedbat/coveragepy/commit/0d6449874cd4d3003ce908d66fa654b64bfea0c0"><code>0d64498</code></a> fix: 3.11.0b4 has 0-numbered lines. Fixes <a href="https://github-redirect.dependabot.com/nedbat/coveragepy/issues/1419">#1419</a></li>
<li><a href="https://github.com/nedbat/coveragepy/commit/297b70e43e083297093781be6e5e1681e5dd70cb"><code>297b70e</code></a> build: styfle/cancel-workflow-action@0.10.0 now accepts 'all'</li>
<li><a href="https://github.com/nedbat/coveragepy/commit/ef258677a28c4f51cffb3010c5afd633973717bb"><code>ef25867</code></a> build(deps): bump actions/dependency-review-action from 1 to 2 (<a href="https://github-redirect.dependabot.com/nedbat/coveragepy/issues/1404">#1404</a>)</li>
<li><a href="https://github.com/nedbat/coveragepy/commit/b1f9cc07c681b36108be5f31e467dc4055ea4d05"><code>b1f9cc0</code></a> build(deps): bump styfle/cancel-workflow-action from 0.9.1 to 0.10.0 (<a href="https://github-redirect.dependabot.com/nedbat/coveragepy/issues/1412">#1412</a>)</li>
<li><a href="https://github.com/nedbat/coveragepy/commit/f75d60a63f9b5e99481231ea9b2b956616278327"><code>f75d60a</code></a> style: use new regex match object group access</li>
<li><a href="https://github.com/nedbat/coveragepy/commit/8447c995e822ca63836037290d045f0fd6d53fb5"><code>8447c99</code></a> test: copying <strong>pycache</strong> was causing race conditions, and was unneeded anyway.</li>
<li>Additional commits viewable in <a href="https://github.com/nedbat/coveragepy/compare/6.4.1...6.4.2">compare view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=coverage[toml]&package-manager=pip&previous-version=6.4.1&new-version=6.4.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)


</details>


Patch:
diff --git a/changes/1126.feature.md b/changes/1126.feature.md
new file mode 100644
index 00000000..5fb8623e
--- /dev/null
+++ b/changes/1126.feature.md
@@ -0,0 +1,2 @@
+Add `hikari.events.StickersUpdateEvent` and relevant cache internals.
+Add sticker related public methods onto `hikari.impl.CacheImpl` and `hikari.guilds.Guild`.
diff --git a/changes/1195.deprecation.md b/changes/1195.deprecation.md
new file mode 100644
index 00000000..4624ce05
--- /dev/null
+++ b/changes/1195.deprecation.md
@@ -0,0 +1,1 @@
+`RESTClient.edit_permission_overwrites` renamed to `RESTClient.edit_permission_overwrite`
diff --git a/changes/1207.breaking.md b/changes/1207.breaking.md
new file mode 100644
index 00000000..3b72d741
--- /dev/null
+++ b/changes/1207.breaking.md
@@ -0,0 +1,1 @@
+Removed case of `Member.mention` returning bang (`!`) mention, as it is deprecated by Discord.
diff --git a/changes/1212.bugfix.md b/changes/1212.bugfix.md
new file mode 100644
index 00000000..e5bb026f
--- /dev/null
+++ b/changes/1212.bugfix.md
@@ -0,0 +1,1 @@
+Fix how CommandBuilder handles `default_member_permissions` to match the behaviour on PartialCommand.
diff --git a/dev-requirements.txt b/dev-requirements.txt
index 41c757cd..2d1da28e 100644
--- a/dev-requirements.txt
+++ b/dev-requirements.txt
@@ -12,7 +12,7 @@ pytest-cov==3.0.0
 pytest-randomly==3.12.0
 
 # Coverage testing.
-coverage[toml]==6.4.1
+coverage[toml]==6.4.2
 
 # Other stuff
 async-timeout==4.0.2  # Used for timeouts in some test cases.
@@ -29,7 +29,7 @@ sphobjinv==2.2.2
 #################
 
 mypy==0.961
-pyright==1.1.258
+pyright==1.1.260
 
 #######################
 # DEPENDENCY CHECKING #
diff --git a/hikari/api/cache.py b/hikari/api/cache.py
index 02a0ca55..b544d3ed 100644
--- a/hikari/api/cache.py
+++ b/hikari/api/cache.py
@@ -38,6 +38,7 @@
     from hikari import messages
     from hikari import presences
     from hikari import snowflakes
+    from hikari import stickers
     from hikari import users
     from hikari import voices
     from hikari.api import config
@@ -168,6 +169,51 @@ def get_emojis_view_for_guild(
             specified guild.
         """
 
+    @abc.abstractmethod
+    def get_sticker(
+        self, sticker: snowflakes.SnowflakeishOr[stickers.GuildSticker], /
+    ) -> typing.Optional[stickers.GuildSticker]:
+        """Get a sticker from the cache.
+
+        Parameters
+        ----------
+        sticker : hikari.snowflakes.SnowflakeishOr[hikari.stickers.GuildSticker]
+            Object or ID of the sticker to get from the cache.
+
+        Returns
+        -------
+        typing.Optional[hikari.stickers.GuildSticker]
+            The object of the sticker that was found in the cache or `builtins.None`.
+        """
+
+    @abc.abstractmethod
+    def get_stickers_view(self) -> CacheView[snowflakes.Snowflake, stickers.GuildSticker]:
+        """Get a view of the sticker objects in the cache.
+
+        Returns
+        -------
+        CacheView[hikari.snowflakes.Snowflake, hikari.stickers.GuildSticker]
+            A view of sticker IDs to objects of the stickers found in the cache.
+        """
+
+    @abc.abstractmethod
+    def get_stickers_view_for_guild(
+        self, guild: snowflakes.SnowflakeishOr[guilds.PartialGuild], /
+    ) -> CacheView[snowflakes.Snowflake, stickers.GuildSticker]:
+        """Get a view of the known custom emojis cached for a specific guild.
+
+        Parameters
+        ----------
+        guild : hikari.snowflakes.SnowflakeishOr[hikari.guilds.PartialGuild]
+            Object or ID of the guild to get the cached sticker objects for.
+
+        Returns
+        -------
+        CacheView[hikari.snowflakes.Snowflake, hikari.guilds.stickers.GuildSticker]
+            A view of sticker IDs to objects of stickers found in the cache for the
+            specified guild.
+        """
+
     @abc.abstractmethod
     def get_guild(
         self, guild: snowflakes.SnowflakeishOr[guilds.PartialGuild], /
@@ -816,6 +862,72 @@ def update_emoji(
             `builtins.None`).
         """
 
+    @abc.abstractmethod
+    def clear_stickers(self) -> CacheView[snowflakes.Snowflake, stickers.GuildSticker]:
+        """Remove all the sticker objects from the cache.
+
+        !!! note
+            This will skip stickers that are being kept alive by a reference.
+
+        Returns
+        -------
+        CacheView[hikari.snowflakes.Snowflake, hikari.stickers.GuildSticker]
+            A cache view of sticker IDs to objects of the stickers that were
+            removed from the cache.
+        """
+
+    @abc.abstractmethod
+    def clear_stickers_for_guild(
+        self, guild: snowflakes.SnowflakeishOr[guilds.PartialGuild], /
+    ) -> CacheView[snowflakes.Snowflake, stickers.GuildSticker]:
+        """Remove the known custom emoji objects cached for a specific guild.
+
+        Parameters
+        ----------
+        guild : hikari.snowflakes.SnowflakeishOr[hikari.guilds.PartialGuild]
+            Object or ID of the guild to remove the cached sticker objects for.
+
+        !!! note
+            This will skip stickers that are being kept alive by a reference.
+
+        Returns
+        -------
+        CacheView[hikari.snowflakes.Snowflake, hikari.stickers.GuildSticker]
+            A view of sticker IDs to objects of the stickers that were removed
+            from the cache.
+        """
+
+    @abc.abstractmethod
+    def delete_sticker(
+        self, sticker: snowflakes.SnowflakeishOr[stickers.GuildSticker], /
+    ) -> typing.Optional[stickers.GuildSticker]:
+        """Remove a sticker from the cache.
+
+        Parameters
+        ----------
+        sticker : hikari.snowflakes.SnowflakeishOr[hikari.stickers.GuildSticker]
+            Object or ID of the sticker to remove from the cache.
+
+        !!! note
+            This will not delete stickers that are being kept alive by a reference.
+
+        Returns
+        -------
+        typing.Optional[hikari.stickers.GuildSticker]
+            The object of the sticker that was removed from the cache or
+            `builtins.None`.
+        """
+
+    @abc.abstractmethod
+    def set_sticker(self, sticker: stickers.GuildSticker, /) -> None:
+        """Add a sticker to the cache.
+
+        Parameters
+        ----------
+        sticker : hikari.stickers.GuildSticker
+            The object of the sticker to add to the cache.
+        """
+
     @abc.abstractmethod
     def clear_guilds(self) -> CacheView[snowflakes.Snowflake, guilds.GatewayGuild]:
         """Remove all the guild objects from the cache.
diff --git a/hikari/api/config.py b/hikari/api/config.py
index ada229e6..3c84f04f 100644
--- a/hikari/api/config.py
+++ b/hikari/api/config.py
@@ -73,6 +73,9 @@ class CacheComponents(enums.Flag):
     DM_CHANNEL_IDS = 1 << 10
     """Enables the DM channel IDs cache."""
 
+    GUILD_STICKERS = 1 << 11
+    """Enables the guild stickers cache."""
+
     ALL = (
         GUILDS
         | GUILD_CHANNELS
@@ -85,6 +88,7 @@ class CacheComponents(enums.Flag):
         | MESSAGES
         | ME
         | DM_CHANNEL_IDS
+        | GUILD_STICKERS
     )
     """Fully enables the cache."""
 
diff --git a/hikari/api/entity_factory.py b/hikari/api/entity_factory.py
index a09f7b4f..b171e1e8 100644
--- a/hikari/api/entity_factory.py
+++ b/hikari/api/entity_factory.py
@@ -79,6 +79,10 @@ def channels(self) -> typing.Mapping[snowflakes.Snowflake, channel_models.GuildC
     def emojis(self) -> typing.Mapping[snowflakes.Snowflake, emoji_models.KnownCustomEmoji]:
         """Get a mapping of emoji IDs to the emojis that belong to the guild."""
 
+    @abc.abstractmethod
+    def stickers(self) -> typing.Mapping[snowflakes.Snowflake, sticker_models.GuildSticker]:
+        """Get a mapping of sticker IDs to the stickers that belong to the guild."""
+
     @abc.abstractmethod
     def guild(self) -> guild_models.GatewayGuild:
         """Get the object of the guild this definition is for."""
@@ -912,8 +916,9 @@ def deserialize_gateway_guild(self, payload: data_binding.JSONObject) -> Gateway
             `hikari.channels.GuildChannel`,
             `hikari.guilds.Member`,
             `hikari.presences.MemberPresence`,
-            `hikari.guilds.Role`, and
-            `hikari.emojis.KnownCustomEmoji`. This is provided in
+            `hikari.guilds.Role`,
+            `hikari.emojis.KnownCustomEmoji`, and
+            `hikari.stickers.GuildSticker`. This is provided in
             several components to allow separate caching and linking
             between entities in various relational cache implementations
             internally.
diff --git a/hikari/api/event_factory.py b/hikari/api/event_factory.py
index 31677c13..36fb5f7b 100644
--- a/hikari/api/event_factory.py
+++ b/hikari/api/event_factory.py
@@ -446,6 +446,34 @@ def deserialize_guild_emojis_update_event(
             The parsed guild emojis update event object.
         """
 
+    @abc.abstractmethod
+    def deserialize_guild_stickers_update_event(
+        self,
+        shard: gateway_shard.GatewayShard,
+        payload: data_binding.JSONObject,
+        *,
+        old_stickers: typing.Optional[typing.Sequence[guild_models.stickers.GuildSticker]] = None,
+    ) -> guild_events.StickersUpdateEvent:
+        """Parse a raw payload from Discord into a guild stickers update event object.
+
+        Parameters
+        ----------
+        shard : hikari.api.shard.GatewayShard
+            The shard that emitted this event.
+        payload : hikari.internal.data_binding.JSONObject
+            The dict payload to parse.
+
+        Other Parameters
+        ----------------
+        typing.Optional[typing.Sequence[hikari.guilds.stickers.GuildSticker]]
+            The sequence of stickers or `builtins.None`.
+
+        Returns
+        -------
+        hikari.events.guild_events.StickersUpdateEvent
+            The parsed guild stickers update event object.
+        """
+
     @abc.abstractmethod
     def deserialize_integration_create_event(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
diff --git a/hikari/api/rest.py b/hikari/api/rest.py
index 9e074b12..28b5e4a0 100644
--- a/hikari/api/rest.py
+++ b/hikari/api/rest.py
@@ -505,7 +505,7 @@ async def edit_voice_state(
 
     @typing.overload
     @abc.abstractmethod
-    async def edit_permission_overwrites(
+    async def edit_permission_overwrite(
         self,
         channel: snowflakes.SnowflakeishOr[channels_.GuildChannel],
         target: typing.Union[channels_.PermissionOverwrite, users.PartialUser, guilds.PartialRole],
@@ -518,7 +518,7 @@ async def edit_permission_overwrites(
 
     @typing.overload
     @abc.abstractmethod
-    async def edit_permission_overwrites(
+    async def edit_permission_overwrite(
         self,
         channel: snowflakes.SnowflakeishOr[channels_.GuildChannel],
         target: snowflakes.Snowflakeish,
@@ -531,7 +531,7 @@ async def edit_permission_overwrites(
         """Edit permissions for a given entity ID and type."""
 
     @abc.abstractmethod
-    async def edit_permission_overwrites(
+    async def edit_permission_overwrite(
         self,
         channel: snowflakes.SnowflakeishOr[channels_.GuildChannel],
         target: typing.Union[
@@ -560,9 +560,9 @@ async def edit_permission_overwrites(
             If provided, the type of the target to update. If unset, will attempt to get
             the type from `target`.
         allow : hikari.undefined.UndefinedOr[hikari.permissions.Permissions]
-            If provided, the new vale of all allowed permissions.
+            If provided, the new value of all allowed permissions.
         deny : hikari.undefined.UndefinedOr[hikari.permissions.Permissions]
-            If provided, the new vale of all disallowed permissions.
+            If provided, the new value of all disallowed permissions.
         reason : hikari.undefined.UndefinedOr[builtins.str]
             If provided, the reason that will be recorded in the audit logs.
             Maximum of 512 characters.
diff --git a/hikari/channels.py b/hikari/channels.py
index af769dce..dde06869 100644
--- a/hikari/channels.py
+++ b/hikari/channels.py
@@ -1035,9 +1035,9 @@ async def edit_overwrite(
             If provided, the type of the target to update. If unset, will attempt to get
             the type from `target`.
         allow : hikari.undefined.UndefinedOr[hikari.permissions.Permissions]
-            If provided, the new vale of all allowed permissions.
+            If provided, the new value of all allowed permissions.
         deny : hikari.undefined.UndefinedOr[hikari.permissions.Permissions]
-            If provided, the new vale of all disallowed permissions.
+            If provided, the new value of all disallowed permissions.
         reason : hikari.undefined.UndefinedOr[builtins.str]
             If provided, the reason that will be recorded in the audit logs.
             Maximum of 512 characters.
@@ -1074,11 +1074,9 @@ async def edit_overwrite(
             assert not isinstance(
                 target, int
             ), "Cannot determine the type of the target to update. Try specifying 'target_type' manually."
-            return await self.app.rest.edit_permission_overwrites(
-                self.id, target, allow=allow, deny=deny, reason=reason
-            )
+            return await self.app.rest.edit_permission_overwrite(self.id, target, allow=allow, deny=deny, reason=reason)
 
-        return await self.app.rest.edit_permission_overwrites(
+        return await self.app.rest.edit_permission_overwrite(
             self.id, typing.cast(int, target), target_type=target_type, allow=allow, deny=deny, reason=reason
         )
 
diff --git a/hikari/events/guild_events.py b/hikari/events/guild_events.py
index 2e8c5bd2..2a328591 100644
--- a/hikari/events/guild_events.py
+++ b/hikari/events/guild_events.py
@@ -36,6 +36,7 @@
     "BanCreateEvent",
     "BanDeleteEvent",
     "EmojisUpdateEvent",
+    "StickersUpdateEvent",
     "IntegrationEvent",
     "IntegrationCreateEvent",
     "IntegrationDeleteEvent",
@@ -60,6 +61,7 @@
     from hikari import guilds
     from hikari import presences as presences_
     from hikari import snowflakes
+    from hikari import stickers as stickers_
     from hikari import users
     from hikari import voices
     from hikari.api import shard as gateway_shard
@@ -168,6 +170,9 @@ class GuildAvailableEvent(GuildVisibilityEvent):
         The emojis in the guild.
     """
 
+    stickers: typing.Mapping[snowflakes.Snowflake, stickers_.GuildSticker] = attr.field(repr=False)
+    """Mapping of sticker IDs to the stickers in the guild."""
+
     roles: typing.Mapping[snowflakes.Snowflake, guilds.Role] = attr.field(repr=False)
     """Mapping of role IDs to the roles in the guild.
 
@@ -259,6 +264,9 @@ class GuildJoinEvent(GuildVisibilityEvent):
     emojis: typing.Mapping[snowflakes.Snowflake, emojis_.KnownCustomEmoji] = attr.field(repr=False)
     """Mapping of emoji IDs to the emojis in the guild."""
 
+    stickers: typing.Mapping[snowflakes.Snowflake, stickers_.GuildSticker] = attr.field(repr=False)
+    """Mapping of sticker IDs to the stickers in the guild."""
+
     roles: typing.Mapping[snowflakes.Snowflake, guilds.Role] = attr.field(repr=False)
     """Mapping of role IDs to the roles in the guild."""
 
@@ -373,6 +381,9 @@ class GuildUpdateEvent(GuildEvent):
         The emojis in the guild.
     """
 
+    stickers: typing.Mapping[snowflakes.Snowflake, stickers_.GuildSticker] = attr.field(repr=False)
+    """Mapping of sticker IDs to the stickers in the guild."""
+
     roles: typing.Mapping[snowflakes.Snowflake, guilds.Role] = attr.field(repr=False)
     """Mapping of role IDs to the roles in the guild.
 
@@ -523,6 +534,41 @@ async def fetch_emojis(self) -> typing.Sequence[emojis_.KnownCustomEmoji]:
         return await self.app.rest.fetch_guild_emojis(self.guild_id)
 
 
+@attr_extensions.with_copy
+@attr.define(kw_only=True, weakref_slot=False)
+@base_events.requires_intents(intents.Intents.GUILD_EMOJIS)
+class StickersUpdateEvent(GuildEvent):
+    """Event that is fired when the emojis in a guild are updated."""
+
+    app: traits.RESTAware = attr.field(metadata={attr_extensions.SKIP_DEEP_COPY: True})
+    # <<inherited docstring from Event>>.
+
+    shard: gateway_shard.GatewayShard = attr.field(metadata={attr_extensions.SKIP_DEEP_COPY: True})
+    # <<inherited docstring from ShardEvent>>.
+
+    guild_id: snowflakes.Snowflake = attr.field()
+    # <<inherited docstring from GuildEvent>>.
+
+    old_stickers: typing.Optional[typing.Sequence[guilds.stickers.GuildSticker]] = attr.field()
+    """Sequence of all old stickers in this guild.
+
+    This will be `builtins.None` if it's missing from the cache.
+    """
+
+    stickers: typing.Sequence[guilds.stickers.GuildSticker] = attr.field()
+    """Sequence of all stickers in this guild."""
+
+    async def fetch_stickers(self) -> typing.Sequence[guilds.stickers.GuildSticker]:
+        """Perform an API call to retrieve an up-to-date view of the emojis.
+
+        Returns
+        -------
+        typing.Sequence[guilds.stickers.GuildSticker]
+            All emojis in the guild.
+        """
+        return await self.app.rest.fetch_guild_stickers(self.guild_id)
+
+
 @base_events.requires_intents(intents.Intents.GUILD_INTEGRATIONS)
 class IntegrationEvent(GuildEvent, abc.ABC):
     """Event base for any integration related events."""
diff --git a/hikari/guilds.py b/hikari/guilds.py
index 0155f078..52abeb3a 100644
--- a/hikari/guilds.py
+++ b/hikari/guilds.py
@@ -484,28 +484,7 @@ def is_system(self) -> bool:
 
     @property
     def mention(self) -> str:
-        """Return a raw mention string for the given member.
-
-        If the member has a known nickname, we always return
-        a bang ("`!`") before the ID part of the mention string. This
-        mimics the behaviour Discord clients tend to provide.
-
-        Example
-        -------
-
-        ```py
-        >>> some_member_without_nickname.mention
-        '<@123456789123456789>'
-        >>> some_member_with_nickname.mention
-        '<@!123456789123456789>'
-        ```
-
-        Returns
-        -------
-        builtins.str
-            The mention string to use.
-        """
-        return f"<@!{self.id}>" if self.nickname is not None else self.user.mention
+        return self.user.mention
 
     def communication_disabled_until(self) -> typing.Optional[datetime.datetime]:
         """Return when the timeout for this member ends.
@@ -2914,6 +2893,19 @@ def get_emojis(self) -> typing.Mapping[snowflakes.Snowflake, emojis_.KnownCustom
 
         return self.app.cache.get_emojis_view_for_guild(self.id)
 
+    def get_stickers(self) -> typing.Mapping[snowflakes.Snowflake, stickers.GuildSticker]:
+        """Return the stickers in this guild.
+
+        Returns
+        -------
+        typing.Mapping[hikari.snowflakes.Snowflake, hikari.stickers.GuildSticker]
+            A mapping of sticker IDs to the objects of sticker in this guild.
+        """
+        if not isinstance(self.app, traits.CacheAware):
+            return {}
+
+        return self.app.cache.get_stickers_view_for_guild(self.id)
+
     def get_roles(self) -> typing.Mapping[snowflakes.Snowflake, Role]:
         """Return the roles in this guild.
 
@@ -3154,6 +3146,27 @@ def get_emoji(
 
         return self.app.cache.get_emoji(emoji)
 
+    def get_sticker(
+        self, sticker: snowflakes.SnowflakeishOr[stickers.GuildSticker]
+    ) -> typing.Optional[stickers.GuildSticker]:
+        """Get a cached sticker that belongs to the guild by it's ID or object.
+
+        Parameters
+        ----------
+        sticker : hikari.snowflakes.SnowflakeishOr[hikari.stickers.GuildSticker]
+            The object or ID of the sticker to get from the cache.
+
+        Returns
+        -------
+        typing.Optional[hikari.stickers.GuildSticker]
+            The object of the sticker if found in cache, else
+            `builtins.None`.
+        """
+        if not isinstance(self.app, traits.CacheAware):
+            return None
+
+        return self.app.cache.get_sticker(sticker)
+
     def get_role(self, role: snowflakes.SnowflakeishOr[PartialRole]) -> typing.Optional[Role]:
         """Get a cached role that belongs to the guild by it's ID or object.
 
@@ -3405,6 +3418,9 @@ class RESTGuild(Guild):
     )
     """A mapping of emoji IDs to the objects of the emojis this guild provides."""
 
+    stickers: typing.Mapping[snowflakes.Snowflake, stickers.GuildSticker] = attr.field(eq=False, hash=False, repr=False)
+    """A mapping of sticker IDs to the objects of the stickers this guild provides."""
+
     roles: typing.Mapping[snowflakes.Snowflake, Role] = attr.field(eq=False, hash=False, repr=False)
     """The roles in this guild, represented as a mapping of role ID to role object."""
 
diff --git a/hikari/impl/cache.py b/hikari/impl/cache.py
index 62937886..f2e0e715 100644
--- a/hikari/impl/cache.py
+++ b/hikari/impl/cache.py
@@ -45,6 +45,7 @@
     from hikari import guilds
     from hikari import invites
     from hikari import presences
+    from hikari import stickers
     from hikari import traits
     from hikari import users
     from hikari import voices
@@ -74,6 +75,7 @@ class CacheImpl(cache.MutableCache):
         "_invite_entries",
         "_me",
         "_role_entries",
+        "_sticker_entries",
         "_unknown_custom_emoji_entries",
         "_user_entries",
         "_message_entries",
@@ -89,6 +91,7 @@ class CacheImpl(cache.MutableCache):
     _guild_entries: collections.ExtendedMutableMapping[snowflakes.Snowflake, cache_utility.GuildRecord]
     _invite_entries: collections.ExtendedMutableMapping[str, cache_utility.InviteData]
     _role_entries: collections.ExtendedMutableMapping[snowflakes.Snowflake, guilds.Role]
+    _sticker_entries: collections.ExtendedMutableMapping[snowflakes.Snowflake, cache_utility.GuildStickerData]
     _unknown_custom_emoji_entries: collections.ExtendedMutableMapping[
         snowflakes.Snowflake,
         cache_utility.RefCell[emojis.CustomEmoji],
@@ -118,6 +121,7 @@ def _create_cache(self) -> None:
         self._guild_entries = collections.FreezableDict()
         self._invite_entries = collections.FreezableDict()
         self._role_entries = collections.FreezableDict()
+        self._sticker_entries = collections.FreezableDict()
         # This is a purely internal cache used for handling the caching and de-duplicating of the unknown custom emojis
         # found attached to cached presence activities.
         self._unknown_custom_emoji_entries = collections.FreezableDict()
@@ -305,6 +309,120 @@ def update_emoji(
         self.set_emoji(emoji)
         return cached_emoji, self.get_emoji(emoji.id)
 
+    def _build_sticker(
+        self,
+        sticker_data: cache_utility.GuildStickerData,
+    ) -> stickers.GuildSticker:
+        return sticker_data.build_entity(self._app)
+
+    def clear_stickers(self) -> cache.CacheView[snowflakes.Snowflake, stickers.GuildSticker]:
+        if not self._is_cache_enabled_for(config_api.CacheComponents.GUILD_STICKERS):
+            return cache_utility.EmptyCacheView()
+
+        cached_stickers = self._sticker_entries
+        self._sticker_entries = collections.FreezableDict()
+
+        for sticker_data in cached_stickers.values():
+            if sticker_data.user:
+                self._garbage_collect_user(sticker_data.user, decrement=1)
+
+        for guild_id, guild_record in self._guild_entries.freeze().items():
+            guild_record.stickers = None
+            self._remove_guild_record_if_empty(guild_id, guild_record)
+
+        return cache_utility.CacheMappingView(cached_stickers, builder=self._build_sticker)
+
+    def clear_stickers_for_guild(
+        self, guild: snowflakes.SnowflakeishOr[guilds.PartialGuild], /
+    ) -> cache.CacheView[snowflakes.Snowflake, stickers.GuildSticker]:
+        if not self._is_cache_enabled_for(config_api.CacheComponents.GUILD_STICKERS):
+            return cache_utility.EmptyCacheView()
+
+        guild_id = snowflakes.Snowflake(guild)
+        guild_record = self._guild_entries.get(guild_id)
+        if not guild_record or not guild_record.stickers:
+            return cache_utility.EmptyCacheView()
+
+        cached_stickers = {sticker_id: self._sticker_entries.pop(sticker_id) for sticker_id in guild_record.stickers}
+        guild_record.stickers = None
+        self._remove_guild_record_if_empty(guild_id, guild_record)
+
+        for sticker_data in cached_stickers.values():
+            if sticker_data.user:
+                self._garbage_collect_user(sticker_data.user, decrement=1)
+
+        return cache_utility.CacheMappingView(cached_stickers, builder=self._build_sticker)
+
+    def get_sticker(
+        self, sticker: snowflakes.SnowflakeishOr[stickers.GuildSticker], /
+    ) -> typing.Optional[stickers.GuildSticker]:
+        if not self._is_cache_enabled_for(config_api.CacheComponents.GUILD_STICKERS):
+            return None
+
+        sticker_data = self._sticker_entries.get(snowflakes.Snowflake(sticker))
+        return self._build_sticker(sticker_data) if sticker_data else None
+
+    def get_stickers_view(self) -> cache.CacheView[snowflakes.Snowflake, stickers.GuildSticker]:
+        if not self._is_cache_enabled_for(config_api.CacheComponents.GUILD_STICKERS):
+            return cache_utility.EmptyCacheView()
+
+        return cache_utility.CacheMappingView(self._sticker_entries.freeze(), builder=self._build_sticker)
+
+    def get_stickers_view_for_guild(
+        self, guild: snowflakes.SnowflakeishOr[guilds.PartialGuild], /
+    ) -> cache.CacheView[snowflakes.Snowflake, stickers.GuildSticker]:
+        if not self._is_cache_enabled_for(config_api.CacheComponents.GUILD_STICKERS):
+            return cache_utility.EmptyCacheView()
+
+        guild_record = self._guild_entries.get(snowflakes.Snowflake(guild))
+        if not guild_record or not guild_record.stickers:
+            return cache_utility.EmptyCacheView()
+
+        cached_stickers = {sticker_id: self._sticker_entries[sticker_id] for sticker_id in guild_record.stickers}
+        return cache_utility.CacheMappingView(cached_stickers, builder=self._build_sticker)
+
+    def delete_sticker(
+        self, sticker: snowflakes.SnowflakeishOr[stickers.GuildSticker], /
+    ) -> typing.Optional[stickers.GuildSticker]:
+        if not self._is_cache_enabled_for(config_api.CacheComponents.GUILD_STICKERS):
+            return None
+
+        sticker_id = snowflakes.Snowflake(sticker)
+        sticker_data = self._sticker_entries.pop(sticker_id, None)
+        if not sticker_data:
+            return None
+
+        if sticker_data.user:
+            self._garbage_collect_user(sticker_data.user, decrement=1)
+
+        guild_record = self._guild_entries.get(sticker_data.guild_id)
+        if guild_record and guild_record.stickers:
+            guild_record.stickers.remove(sticker_id)
+
+            if not guild_record.stickers:
+                guild_record.stickers = None
+
+        return self._build_sticker(sticker_data)
+
+    def set_sticker(self, sticker: stickers.GuildSticker, /) -> None:
+        if not self._is_cache_enabled_for(config_api.CacheComponents.GUILD_STICKERS):
+            return None
+
+        user: typing.Optional[cache_utility.RefCell[users.User]] = None
+        if sticker.user:
+            user = self._set_user(sticker.user)
+            if sticker.id not in self._sticker_entries:
+                self._increment_ref_count(user)
+
+        sticker_data = cache_utility.GuildStickerData.build_from_entity(sticker, user=user)
+        self._sticker_entries[sticker.id] = sticker_data
+        guild_record = self._get_or_create_guild_record(sticker.guild_id)
+
+        if guild_record.stickers is None:  # TODO: add test cases when it is not None?
+            guild_record.stickers = collections.SnowflakeSet()
+
+        guild_record.stickers.add(sticker.id)
+
     def _remove_guild_record_if_empty(
         self, guild_id: snowflakes.Snowflake, record: cache_utility.GuildRecord, /
     ) -> None:
diff --git a/hikari/impl/entity_factory.py b/hikari/impl/entity_factory.py
index ba82d50d..ba24729f 100644
--- a/hikari/impl/entity_factory.py
+++ b/hikari/impl/entity_factory.py
@@ -252,6 +252,9 @@ class _GatewayGuildDefinition(entity_factory.GatewayGuildDefinition):
     _emojis: UndefinedSnowflakeMapping[emoji_models.KnownCustomEmoji] = attr.field(
         init=False, default=undefined.UNDEFINED
     )
+    _stickers: UndefinedSnowflakeMapping[sticker_models.GuildSticker] = attr.field(
+        init=False, default=undefined.UNDEFINED
+    )
     _members: UndefinedSnowflakeMapping[guild_models.Member] = attr.field(init=False, default=undefined.UNDEFINED)
     _presences: UndefinedSnowflakeMapping[presence_models.MemberPresence] = attr.field(
         init=False, default=undefined.UNDEFINED
@@ -289,6 +292,15 @@ def emojis(self) -> typing.Mapping[snowflakes.Snowflake, emoji_models.KnownCusto
 
         return self._emojis
 
+    def stickers(self) -> typing.Mapping[snowflakes.Snowflake, sticker_models.GuildSticker]:
+        if self._stickers is undefined.UNDEFINED:
+            self._stickers = {
+                snowflakes.Snowflake(s["id"]): self._entity_factory.deserialize_guild_sticker(s)
+                for s in self._payload["stickers"]
+            }
+
+        return self._stickers
+
     def guild(self) -> guild_models.GatewayGuild:
         if self._guild is undefined.UNDEFINED:
             payload = self._payload
@@ -1569,6 +1581,10 @@ def deserialize_rest_guild(self, payload: data_binding.JSONObject) -> guild_mode
             snowflakes.Snowflake(emoji["id"]): self.deserialize_known_custom_emoji(emoji, guild_id=guild_fields.id)
             for emoji in payload["emojis"]
         }
+        stickers = {
+            snowflakes.Snowflake(sticker["id"]): self.deserialize_guild_sticker(sticker)
+            for sticker in payload["stickers"]
+        }
         return guild_models.RESTGuild(
             app=self._app,
             id=guild_fields.id,
@@ -1605,6 +1621,7 @@ def deserialize_rest_guild(self, payload: data_binding.JSONObject) -> guild_mode
             approximate_active_member_count=approximate_active_member_count,
             roles=roles,
             emojis=emojis,
+            stickers=stickers,
         )
 
     def deserialize_gateway_guild(self, payload: data_binding.JSONObject) -> entity_factory.GatewayGuildDefinition:
diff --git a/hikari/impl/event_factory.py b/hikari/impl/event_factory.py
index 5489f0ff..edfd93ca 100644
--- a/hikari/impl/event_factory.py
+++ b/hikari/impl/event_factory.py
@@ -216,6 +216,7 @@ def deserialize_guild_available_event(
             channels=guild_information.channels(),
             members=guild_information.members(),
             presences=guild_information.presences(),
+            stickers=guild_information.stickers(),
             voice_states=guild_information.voice_states(),
         )
 
@@ -231,6 +232,7 @@ def deserialize_guild_join_event(
             channels=guild_information.channels(),
             members=guild_information.members(),
             presences=guild_information.presences(),
+            stickers=guild_information.stickers(),
             voice_states=guild_information.voice_states(),
         )
 
@@ -247,6 +249,7 @@ def deserialize_guild_update_event(
             guild=guild_information.guild(),
             emojis=guild_information.emojis(),
             roles=guild_information.roles(),
+            stickers=guild_information.stickers(),
             old_guild=old_guild,
         )
 
@@ -302,6 +305,19 @@ def deserialize_guild_emojis_update_event(
             app=self._app, shard=shard, guild_id=guild_id, emojis=emojis, old_emojis=old_emojis
         )
 
+    def deserialize_guild_stickers_update_event(
+        self,
+        shard: gateway_shard.GatewayShard,
+        payload: data_binding.JSONObject,
+        *,
+        old_stickers: typing.Optional[typing.Sequence[guild_models.stickers.GuildSticker]] = None,
+    ) -> guild_events.StickersUpdateEvent:
+        guild_id = snowflakes.Snowflake(payload["guild_id"])
+        stickers = [self._app.entity_factory.deserialize_guild_sticker(sticker) for sticker in payload["stickers"]]
+        return guild_events.StickersUpdateEvent(
+            app=self._app, shard=shard, guild_id=guild_id, stickers=stickers, old_stickers=old_stickers
+        )
+
     def deserialize_integration_create_event(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> guild_events.IntegrationCreateEvent:
diff --git a/hikari/impl/event_manager.py b/hikari/impl/event_manager.py
index 28467fab..0af15177 100644
--- a/hikari/impl/event_manager.py
+++ b/hikari/impl/event_manager.py
@@ -191,6 +191,7 @@ async def on_guild_create(  # noqa: C901 - Function too complex
             # We also filter here to prevent iterating over them and calling a function that won't do anything
             channels = event.channels if self._cache_enabled_for(config.CacheComponents.GUILD_CHANNELS) else None
             emojis = event.emojis if self._cache_enabled_for(config.CacheComponents.EMOJIS) else None
+            stickers = event.stickers if self._cache_enabled_for(config.CacheComponents.GUILD_STICKERS) else None
             guild = event.guild if self._cache_enabled_for(config.CacheComponents.GUILDS) else None
             guild_id = event.guild.id
             members = event.members if self._cache_enabled_for(config.CacheComponents.MEMBERS) else None
@@ -204,6 +205,7 @@ async def on_guild_create(  # noqa: C901 - Function too complex
 
             channels = gd.channels() if self._cache_enabled_for(config.CacheComponents.GUILD_CHANNELS) else None
             emojis = gd.emojis() if self._cache_enabled_for(config.CacheComponents.EMOJIS) else None
+            stickers = gd.stickers() if self._cache_enabled_for(config.CacheComponents.GUILD_STICKERS) else None
             guild = gd.guild() if self._cache_enabled_for(config.CacheComponents.GUILDS) else None
             guild_id = gd.id
             members = gd.members() if self._cache_enabled_for(config.CacheComponents.MEMBERS) else None
@@ -218,6 +220,7 @@ async def on_guild_create(  # noqa: C901 - Function too complex
 
             channels = None
             emojis = None
+            stickers = None
             guild = None
             guild_id = snowflakes.Snowflake(payload["id"])
             members = None
@@ -239,6 +242,11 @@ async def on_guild_create(  # noqa: C901 - Function too complex
                 for emoji in emojis.values():
                     self._cache.set_emoji(emoji)
 
+            if stickers:
+                self._cache.clear_stickers_for_guild(guild_id)
+                for sticker in stickers.values():
+                    self._cache.set_sticker(sticker)
+
             if roles:
                 self._cache.clear_roles_for_guild(guild_id)
                 for role in roles.values():
@@ -297,6 +305,7 @@ async def on_guild_update(self, shard: gateway_shard.GatewayShard, payload: data
 
             # We also filter here to prevent iterating over them and calling a function that won't do anything
             emojis = event.emojis if self._cache_enabled_for(config.CacheComponents.EMOJIS) else None
+            stickers = event.stickers if self._cache_enabled_for(config.CacheComponents.GUILD_STICKERS) else None
             guild = event.guild if self._cache_enabled_for(config.CacheComponents.GUILDS) else None
             roles = event.roles if self._cache_enabled_for(config.CacheComponents.ROLES) else None
 
@@ -306,6 +315,7 @@ async def on_guild_update(self, shard: gateway_shard.GatewayShard, payload: data
 
             gd = self._entity_factory.deserialize_gateway_guild(payload)
             emojis = gd.emojis() if self._cache_enabled_for(config.CacheComponents.EMOJIS) else None
+            stickers = gd.stickers() if self._cache_enabled_for(config.CacheComponents.GUILD_STICKERS) else None
             guild = gd.guild() if self._cache_enabled_for(config.CacheComponents.GUILDS) else None
             guild_id = gd.id
             roles = gd.roles() if self._cache_enabled_for(config.CacheComponents.ROLES) else None
@@ -325,6 +335,11 @@ async def on_guild_update(self, shard: gateway_shard.GatewayShard, payload: data
                 for emoji in emojis.values():
                     self._cache.set_emoji(emoji)
 
+            if stickers:
+                self._cache.clear_stickers_for_guild(guild_id)
+                for sticker in stickers.values():
+                    self._cache.set_sticker(sticker)
+
             if roles:
                 self._cache.clear_roles_for_guild(guild_id)
                 for role in roles.values():
@@ -338,6 +353,7 @@ async def on_guild_update(self, shard: gateway_shard.GatewayShard, payload: data
         config.CacheComponents.GUILDS
         | config.CacheComponents.GUILD_CHANNELS
         | config.CacheComponents.EMOJIS
+        | config.CacheComponents.GUILD_STICKERS
         | config.CacheComponents.ROLES
         | config.CacheComponents.PRESENCES
         | config.CacheComponents.VOICE_STATES
@@ -364,6 +380,7 @@ async def on_guild_delete(self, shard: gateway_shard.GatewayShard, payload: data
                 self._cache.clear_presences_for_guild(guild_id)
                 self._cache.clear_guild_channels_for_guild(guild_id)
                 self._cache.clear_emojis_for_guild(guild_id)
+                self._cache.clear_stickers_for_guild(guild_id)
                 self._cache.clear_roles_for_guild(guild_id)
 
             event = self._event_factory.deserialize_guild_leave_event(shard, payload, old_guild=old)
@@ -394,6 +411,22 @@ async def on_guild_emojis_update(self, shard: gateway_shard.GatewayShard, payloa
 
         await self.dispatch(event)
 
+    @event_manager_base.filtered(guild_events.StickersUpdateEvent, config.CacheComponents.EMOJIS)
+    async def on_guild_stickers_update(
+        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
+    ) -> None:
+        """See https://discord.com/developers/docs/topics/gateway#guild-stickers-update for more info."""
+        guild_id = snowflakes.Snowflake(payload["guild_id"])
+        old = list(self._cache.clear_stickers_for_guild(guild_id).values()) if self._cache else None
+
+        event = self._event_factory.deserialize_guild_stickers_update_event(shard, payload, old_stickers=old)
+
+        if self._cache:
+            for sticker in event.stickers:
+                self._cache.set_sticker(sticker)
+
+        await self.dispatch(event)
+
     @event_manager_base.filtered(())  # An empty sequence here means that this method will always be skipped.
     async def on_guild_integrations_update(self, _: gateway_shard.GatewayShard, __: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway#guild-integrations-update for more info."""
diff --git a/hikari/impl/rest.py b/hikari/impl/rest.py
index fac326f6..20ff9441 100644
--- a/hikari/impl/rest.py
+++ b/hikari/impl/rest.py
@@ -1046,7 +1046,7 @@ async def edit_voice_state(
         body.put("suppress", suppress)
         await self._request(route, json=body)
 
-    async def edit_permission_overwrites(
+    async def edit_permission_overwrite(
         self,
         channel: snowflakes.SnowflakeishOr[channels_.GuildChannel],
         target: typing.Union[
@@ -1078,6 +1078,28 @@ async def edit_permission_overwrites(
         body.put("deny", deny)
         await self._request(route, json=body, reason=reason)
 
+    @deprecation.deprecated("2.0.0.dev110", "edit_permission_overwrite")
+    async def edit_permission_overwrites(
+        self,
+        channel: snowflakes.SnowflakeishOr[channels_.GuildChannel],
+        target: typing.Union[
+            snowflakes.Snowflakeish, users.PartialUser, guilds.PartialRole, channels_.PermissionOverwrite
+        ],
+        *,
+        target_type: undefined.UndefinedOr[typing.Union[channels_.PermissionOverwriteType, int]] = undefined.UNDEFINED,
+        allow: undefined.UndefinedOr[permissions_.Permissions] = undefined.UNDEFINED,
+        deny: undefined.UndefinedOr[permissions_.Permissions] = undefined.UNDEFINED,
+        reason: undefined.UndefinedOr[str] = undefined.UNDEFINED,
+    ) -> None:
+        """Edit permissions for a specific entity in the given guild channel.
+
+        .. deprecated:: 2.0.0.dev110
+            Use `RESTClient.edit_permission_overwrite` instead.
+        """
+        await self.edit_permission_overwrite(
+            channel, target, target_type=target_type, allow=allow, deny=deny, reason=reason
+        )
+
     async def delete_permission_overwrite(
         self,
         channel: snowflakes.SnowflakeishOr[channels_.GuildChannel],
diff --git a/hikari/impl/special_endpoints.py b/hikari/impl/special_endpoints.py
index fc8cc2d4..cc760d72 100644
--- a/hikari/impl/special_endpoints.py
+++ b/hikari/impl/special_endpoints.py
@@ -1133,7 +1133,12 @@ def build(self, _: entity_factory_.EntityFactory, /) -> typing.MutableMapping[st
         data["name"] = self._name
         data["type"] = self.type
         data.put_snowflake("id", self._id)
-        data.put("default_member_permissions", self._default_member_permissions)
+
+        # Discord considers 0 the same thing as ADMINISTRATORS, but we make it nicer to work with
+        # by using it correctly.
+        if self._default_member_permissions != 0:
+            data.put("default_member_permissions", self._default_member_permissions)
+
         data.put("dm_permission", self._is_dm_enabled)
         return data
 
diff --git a/hikari/internal/cache.py b/hikari/internal/cache.py
index 99800347..8b534c8f 100644
--- a/hikari/internal/cache.py
+++ b/hikari/internal/cache.py
@@ -60,6 +60,7 @@
 from hikari import messages
 from hikari import presences
 from hikari import snowflakes
+from hikari import stickers as stickers_
 from hikari import undefined
 from hikari import voices
 from hikari.api import cache
@@ -69,7 +70,6 @@
 if typing.TYPE_CHECKING:
     from hikari import applications
     from hikari import channels as channels_
-    from hikari import stickers as stickers_
     from hikari import traits
     from hikari import users as users_
     from hikari.interactions import base_interactions
@@ -220,6 +220,13 @@ class GuildRecord:
     `typing.MutableSet[hikari.snowflakes.Snowflake]` of emoji IDs.
     """
 
+    stickers: typing.Optional[typing.MutableSet[snowflakes.Snowflake]] = attr.field(default=None)
+    """A sequence of sticker IDs cached for this guild.
+
+    This will be `builtins.None` if no stickers are cached for this guild else
+    `typing.Sequence[hikari.snowflakes.Snowflake]` of emoji IDs.
+    """
+
     invites: typing.Optional[typing.MutableSequence[str]] = attr.field(default=None)
     """A set of the `builtins.str` codes of the invites cached for this guild.
 
@@ -504,6 +511,55 @@ def build_entity(self, app: traits.RESTAware, /) -> emojis.KnownCustomEmoji:
         )
 
 
+@attr_extensions.with_copy
+@attr.define(kw_only=True, repr=False, hash=False, weakref_slot=False)
+class GuildStickerData(BaseData[stickers_.GuildSticker]):
+    """A data model for storing sticker data in an in-memory cache."""
+
+    id: snowflakes.Snowflake = attr.field()
+    name: str = attr.field()
+    description: typing.Optional[str] = attr.field()
+    tag: str = attr.field()
+    format_type: typing.Union[stickers_.StickerFormatType, int] = attr.field()
+    is_available: bool = attr.field()
+    guild_id: snowflakes.Snowflake = attr.field()
+    user: typing.Optional[RefCell[users_.User]] = attr.field()
+
+    @classmethod
+    def build_from_entity(
+        cls,
+        sticker: stickers_.GuildSticker,
+        /,
+        *,
+        user: typing.Optional[RefCell[users_.User]] = None,
+    ) -> GuildStickerData:
+        if not user and sticker.user:
+            user = RefCell(copy.copy(sticker.user))
+
+        return cls(
+            id=sticker.id,
+            name=sticker.name,
+            description=sticker.description,
+            guild_id=sticker.guild_id,
+            tag=sticker.tag,
+            is_available=sticker.is_available,
+            format_type=sticker.format_type,
+            user=user,
+        )
+
+    def build_entity(self, app: traits.RESTAware, /) -> stickers_.GuildSticker:
+        return stickers_.GuildSticker(
+            id=self.id,
+            name=self.name,
+            description=self.description,
+            guild_id=self.guild_id,
+            tag=self.tag,
+            is_available=self.is_available,
+            format_type=self.format_type,
+            user=self.user.copy() if self.user else None,
+        )
+
+
 @attr_extensions.with_copy
 @attr.define(kw_only=True, repr=False, hash=False, weakref_slot=False)
 class RichActivityData(BaseData[presences.RichActivity]):


Test patch:
diff --git a/tests/hikari/events/test_guild_events.py b/tests/hikari/events/test_guild_events.py
index d1d230dc..f5922659 100644
--- a/tests/hikari/events/test_guild_events.py
+++ b/tests/hikari/events/test_guild_events.py
@@ -82,6 +82,7 @@ def event(self):
             shard=object(),
             guild=mock.Mock(guilds.Guild),
             emojis={},
+            stickers={},
             roles={},
             channels={},
             members={},
@@ -105,6 +106,7 @@ def event(self):
             guild=mock.Mock(guilds.Guild),
             old_guild=mock.Mock(guilds.Guild),
             emojis={},
+            stickers={},
             roles={},
         )
 
@@ -156,3 +158,22 @@ def test_old_presence(self, event):
 
         assert event.old_presence.id == 123
         assert event.old_presence.guild_id == 456
+
+
+class TestGuildStickersUpdateEvent:
+    @pytest.fixture()
+    def event(self):
+        return guild_events.StickersUpdateEvent(
+            app=mock.Mock(),
+            shard=mock.Mock(),
+            guild_id=snowflakes.Snowflake(690),
+            old_stickers=(mock.Mock(), mock.Mock()),
+            stickers=(mock.Mock(), mock.Mock(), mock.Mock()),
+        )
+
+    async def test_fetch_stickers(self, event):
+        event.app.rest.fetch_stickers = mock.AsyncMock()
+        stickers = await event.fetch_stickers()
+
+        event.app.rest.fetch_stickers.assert_awaited_once_with(event.guild_id)
+        assert stickers is event.app.rest.fetch_stickers.return_value
diff --git a/tests/hikari/impl/test_cache.py b/tests/hikari/impl/test_cache.py
index 5ebdbc89..7e714deb 100644
--- a/tests/hikari/impl/test_cache.py
+++ b/tests/hikari/impl/test_cache.py
@@ -536,6 +536,387 @@ def test_update_emoji(self, cache_impl):
         )
         cache_impl.set_emoji.assert_called_once_with(mock_emoji)
 
+    def test__build_sticker(self, cache_impl):
+        mock_user = mock.MagicMock(users.User)
+        sticker_data = cache_utilities.GuildStickerData(
+            id=snowflakes.Snowflake(1233534234),
+            name="OKOKOKOKOK",
+            description="hi",
+            guild_id=snowflakes.Snowflake(65234123),
+            tag="lol",
+            format_type=1,
+            user=cache_utilities.RefCell(mock_user),
+            is_available=True,
+        )
+
+        sticker = cache_impl._build_sticker(sticker_data)
+
+        assert sticker.id == snowflakes.Snowflake(1233534234)
+        assert sticker.name == "OKOKOKOKOK"
+        assert sticker.guild_id == snowflakes.Snowflake(65234123)
+        assert sticker.user == mock_user
+        assert sticker.user is not mock_user
+        assert sticker.tag == "lol"
+        assert sticker.format_type == 1
+        assert sticker.is_available is True
+        assert sticker.description == "hi"
+
+    def test__build_sticker_with_no_user(self, cache_impl):
+        sticker_data = cache_utilities.GuildStickerData(
+            id=snowflakes.Snowflake(1233534234),
+            name="OKOKOKOKOK",
+            description="hi",
+            guild_id=snowflakes.Snowflake(65234123),
+            tag="lol",
+            format_type=1,
+            user=None,
+            is_available=True,
+        )
+        cache_impl._build_user = mock.Mock()
+
+        sticker = cache_impl._build_sticker(sticker_data)
+
+        cache_impl._build_user.assert_not_called()
+        assert sticker.user is None
+
+    def test_clear_stickers(self, cache_impl):
+        mock_user_1 = mock.Mock(cache_utilities.RefCell[users.User])
+        mock_user_2 = mock.Mock(cache_utilities.RefCell[users.User])
+        mock_sticker_data_1 = mock.Mock(cache_utilities.GuildStickerData, user=mock_user_1)
+        mock_sticker_data_2 = mock.Mock(cache_utilities.GuildStickerData, user=mock_user_2)
+        mock_sticker_data_3 = mock.Mock(cache_utilities.GuildStickerData, user=None)
+        mock_sticker_1 = mock.Mock(stickers.GuildSticker)
+        mock_sticker_2 = mock.Mock(stickers.GuildSticker)
+        mock_sticker_3 = mock.Mock(stickers.GuildSticker)
+        cache_impl._sticker_entries = collections.FreezableDict(
+            {
+                snowflakes.Snowflake(43123123): mock_sticker_data_1,
+                snowflakes.Snowflake(87643523): mock_sticker_data_2,
+                snowflakes.Snowflake(6873451): mock_sticker_data_3,
+            }
+        )
+        cache_impl._build_sticker = mock.Mock(side_effect=[mock_sticker_1, mock_sticker_2, mock_sticker_3])
+        cache_impl._garbage_collect_user = mock.Mock()
+
+        view = cache_impl.clear_stickers()
+
+        assert view == {
+            snowflakes.Snowflake(43123123): mock_sticker_1,
+            snowflakes.Snowflake(87643523): mock_sticker_2,
+            snowflakes.Snowflake(6873451): mock_sticker_3,
+        }
+        assert cache_impl._sticker_entries == {}
+        cache_impl._garbage_collect_user.assert_has_calls(
+            [mock.call(mock_user_1, decrement=1), mock.call(mock_user_2, decrement=1)]
+        )
+        cache_impl._build_sticker.assert_has_calls(
+            [mock.call(mock_sticker_data_1), mock.call(mock_sticker_data_2), mock.call(mock_sticker_data_3)]
+        )
+
+    def test_clear_stickers_for_guild(self, cache_impl):
+        mock_user_1 = mock.Mock(cache_utilities.RefCell[users.User])
+        mock_user_2 = mock.Mock(cache_utilities.RefCell[users.User])
+        mock_sticker_data_1 = mock.Mock(cache_utilities.GuildStickerData, user=mock_user_1)
+        mock_sticker_data_2 = mock.Mock(cache_utilities.GuildStickerData, user=mock_user_2)
+        mock_sticker_data_3 = mock.Mock(cache_utilities.GuildStickerData, user=None)
+        mock_other_sticker_data = mock.Mock(cache_utilities.GuildStickerData)
+        sticker_ids = collections.SnowflakeSet()
+        sticker_ids.add_all(
+            [snowflakes.Snowflake(43123123), snowflakes.Snowflake(87643523), snowflakes.Snowflake(6873451)]
+        )
+        mock_sticker_1 = mock.Mock(stickers.GuildSticker)
+        mock_sticker_2 = mock.Mock(stickers.GuildSticker)
+        mock_sticker_3 = mock.Mock(stickers.GuildSticker)
+        cache_impl._sticker_entries = collections.FreezableDict(
+            {
+                snowflakes.Snowflake(6873451): mock_sticker_data_1,
+                snowflakes.Snowflake(43123123): mock_sticker_data_2,
+                snowflakes.Snowflake(87643523): mock_sticker_data_3,
+                snowflakes.Snowflake(111): mock_other_sticker_data,
+            }
+        )
+        guild_record = cache_utilities.GuildRecord(stickers=sticker_ids)
+        cache_impl._guild_entries = collections.FreezableDict(
+            {
+                snowflakes.Snowflake(432123123): guild_record,
+                snowflakes.Snowflake(1): mock.Mock(cache_utilities.GuildRecord),
+            }
+        )
+        cache_impl._build_sticker = mock.Mock(side_effect=[mock_sticker_1, mock_sticker_2, mock_sticker_3])
+        cache_impl._remove_guild_record_if_empty = mock.Mock()
+        cache_impl._garbage_collect_user = mock.Mock()
+
+        sticker_mapping = cache_impl.clear_stickers_for_guild(StubModel(432123123))
+
+        cache_impl._garbage_collect_user.assert_has_calls(
+            [mock.call(mock_user_1, decrement=1), mock.call(mock_user_2, decrement=1)]
+        )
+        cache_impl._remove_guild_record_if_empty.assert_called_once_with(snowflakes.Snowflake(432123123), guild_record)
+        assert sticker_mapping == {
+            snowflakes.Snowflake(6873451): mock_sticker_1,
+            snowflakes.Snowflake(43123123): mock_sticker_2,
+            snowflakes.Snowflake(87643523): mock_sticker_3,
+        }
+        assert cache_impl._sticker_entries == collections.FreezableDict(
+            {snowflakes.Snowflake(111): mock_other_sticker_data}
+        )
+        assert cache_impl._guild_entries[snowflakes.Snowflake(432123123)].stickers is None
+        cache_impl._build_sticker.assert_has_calls(
+            [mock.call(mock_sticker_data_1), mock.call(mock_sticker_data_2), mock.call(mock_sticker_data_3)]
+        )
+
+    def test_clear_stickers_for_guild_for_unknown_sticker_cache(self, cache_impl):
+        cache_impl._sticker_entries = {snowflakes.Snowflake(3123): mock.Mock(cache_utilities.GuildStickerData)}
+        cache_impl._guild_entries = collections.FreezableDict(
+            {
+                snowflakes.Snowflake(432123123): cache_utilities.GuildRecord(),
+                snowflakes.Snowflake(1): mock.Mock(cache_utilities.GuildRecord),
+            }
+        )
+        cache_impl._build_sticker = mock.Mock()
+        cache_impl._remove_guild_record_if_empty = mock.Mock()
+        cache_impl._garbage_collect_user = mock.Mock()
+
+        sticker_mapping = cache_impl.clear_stickers_for_guild(StubModel(432123123))
+
+        cache_impl._garbage_collect_user.assert_not_called()
+        cache_impl._remove_guild_record_if_empty.assert_not_called()
+        assert sticker_mapping == {}
+        cache_impl._build_sticker.assert_not_called()
+
+    def test_clear_stickers_for_guild_for_unknown_record(self, cache_impl):
+        cache_impl._sticker_entries = {snowflakes.Snowflake(123124): mock.Mock(cache_utilities.GuildStickerData)}
+        cache_impl._guild_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(1): mock.Mock(cache_utilities.GuildRecord)}
+        )
+        cache_impl._build_sticker = mock.Mock()
+        cache_impl._remove_guild_record_if_empty = mock.Mock()
+        cache_impl._garbage_collect_user = mock.Mock()
+
+        sticker_mapping = cache_impl.clear_stickers_for_guild(StubModel(432123123))
+
+        cache_impl._garbage_collect_user.assert_not_called()
+        cache_impl._remove_guild_record_if_empty.assert_not_called()
+        assert sticker_mapping == {}
+        cache_impl._build_sticker.assert_not_called()
+
+    def test_delete_sticker(self, cache_impl):
+        mock_user = object()
+        mock_sticker_data = mock.Mock(
+            cache_utilities.GuildStickerData, user=mock_user, guild_id=snowflakes.Snowflake(123333)
+        )
+        mock_other_sticker_data = mock.Mock(cache_utilities.GuildStickerData)
+        mock_sticker = mock.Mock(stickers.GuildSticker)
+        sticker_ids = collections.SnowflakeSet()
+        sticker_ids.add_all([snowflakes.Snowflake(12354123), snowflakes.Snowflake(432123)])
+        cache_impl._sticker_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(12354123): mock_sticker_data, snowflakes.Snowflake(999): mock_other_sticker_data}
+        )
+        cache_impl._guild_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(123333): cache_utilities.GuildRecord(stickers=sticker_ids)}
+        )
+        cache_impl._garbage_collect_user = mock.Mock()
+        cache_impl._build_sticker = mock.Mock(return_value=mock_sticker)
+
+        result = cache_impl.delete_sticker(StubModel(12354123))
+
+        assert result is mock_sticker
+        assert cache_impl._sticker_entries == {snowflakes.Snowflake(999): mock_other_sticker_data}
+        assert cache_impl._guild_entries[snowflakes.Snowflake(123333)].stickers == {snowflakes.Snowflake(432123)}
+        cache_impl._build_sticker.assert_called_once_with(mock_sticker_data)
+        cache_impl._garbage_collect_user.assert_called_once_with(mock_user, decrement=1)
+
+    def test_delete_sticker_without_user(self, cache_impl):
+        mock_sticker_data = mock.Mock(
+            cache_utilities.GuildStickerData, user=None, guild_id=snowflakes.Snowflake(123333)
+        )
+        mock_other_sticker_data = mock.Mock(cache_utilities.GuildStickerData)
+        mock_sticker = mock.Mock(stickers.GuildSticker)
+        sticker_ids = collections.SnowflakeSet()
+        sticker_ids.add_all([snowflakes.Snowflake(12354123), snowflakes.Snowflake(432123)])
+        cache_impl._sticker_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(12354123): mock_sticker_data, snowflakes.Snowflake(999): mock_other_sticker_data}
+        )
+        cache_impl._guild_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(123333): cache_utilities.GuildRecord(stickers=sticker_ids)}
+        )
+        cache_impl._garbage_collect_user = mock.Mock()
+        cache_impl._build_sticker = mock.Mock(return_value=mock_sticker)
+
+        result = cache_impl.delete_sticker(StubModel(12354123))
+
+        assert result is mock_sticker
+        assert cache_impl._sticker_entries == {snowflakes.Snowflake(999): mock_other_sticker_data}
+        assert cache_impl._guild_entries[snowflakes.Snowflake(123333)].stickers == {snowflakes.Snowflake(432123)}
+        cache_impl._build_sticker.assert_called_once_with(mock_sticker_data)
+        cache_impl._garbage_collect_user.assert_not_called()
+
+    def test_delete_sticker_for_unknown_sticker(self, cache_impl):
+        cache_impl._garbage_collect_user = mock.Mock()
+        cache_impl._build_sticker = mock.Mock()
+
+        result = cache_impl.delete_sticker(StubModel(12354123))
+
+        assert result is None
+        cache_impl._build_sticker.assert_not_called()
+        cache_impl._garbage_collect_user.assert_not_called()
+
+    def test_get_sticker(self, cache_impl):
+        mock_sticker_data = mock.Mock(cache_utilities.GuildStickerData)
+        mock_sticker = mock.Mock(emojis.KnownCustomEmoji)
+        cache_impl._build_sticker = mock.Mock(return_value=mock_sticker)
+        cache_impl._sticker_entries = collections.FreezableDict({snowflakes.Snowflake(3422123): mock_sticker_data})
+
+        result = cache_impl.get_sticker(StubModel(3422123))
+
+        assert result is mock_sticker
+        cache_impl._build_sticker.assert_called_once_with(mock_sticker_data)
+
+    def test_get_sticker_with_unknown_sticker(self, cache_impl):
+        cache_impl._build_sticker = mock.Mock()
+
+        result = cache_impl.get_sticker(StubModel(3422123))
+
+        assert result is None
+        cache_impl._build_sticker.assert_not_called()
+
+    def test_get_stickers_view(self, cache_impl):
+        mock_sticker_data_1 = mock.Mock(cache_utilities.GuildStickerData)
+        mock_sticker_data_2 = mock.Mock(cache_utilities.GuildStickerData)
+        mock_sticker_1 = mock.Mock(stickers.GuildSticker)
+        mock_sticker_2 = mock.Mock(stickers.GuildSticker)
+        cache_impl._sticker_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(123123123): mock_sticker_data_1, snowflakes.Snowflake(43156234): mock_sticker_data_2}
+        )
+        cache_impl._build_sticker = mock.Mock(side_effect=[mock_sticker_1, mock_sticker_2])
+
+        result = cache_impl.get_stickers_view()
+
+        assert result == {
+            snowflakes.Snowflake(123123123): mock_sticker_1,
+            snowflakes.Snowflake(43156234): mock_sticker_2,
+        }
+        cache_impl._build_sticker.assert_has_calls([mock.call(mock_sticker_data_1), mock.call(mock_sticker_data_2)])
+
+    def test_get_stickers_view_for_guild(self, cache_impl):
+        mock_sticker_data_1 = mock.Mock(cache_utilities.GuildStickerData)
+        mock_sticker_data_2 = mock.Mock(cache_utilities.GuildStickerData)
+        mock_sticker_1 = mock.Mock(stickers.GuildSticker)
+        mock_sticker_2 = mock.Mock(stickers.GuildSticker)
+        sticker_ids = collections.SnowflakeSet()
+        sticker_ids.add_all([snowflakes.Snowflake(65123), snowflakes.Snowflake(43156234)])
+        cache_impl._sticker_entries = collections.FreezableDict(
+            {
+                snowflakes.Snowflake(65123): mock_sticker_data_1,
+                snowflakes.Snowflake(942123): mock.Mock(cache_utilities.GuildStickerData),
+                snowflakes.Snowflake(43156234): mock_sticker_data_2,
+            }
+        )
+        cache_impl._guild_entries = collections.FreezableDict(
+            {
+                snowflakes.Snowflake(99999): mock.Mock(cache_utilities.GuildRecord),
+                snowflakes.Snowflake(9342123): cache_utilities.GuildRecord(stickers=sticker_ids),
+            }
+        )
+        cache_impl._build_sticker = mock.Mock(side_effect=[mock_sticker_1, mock_sticker_2])
+
+        result = cache_impl.get_stickers_view_for_guild(StubModel(9342123))
+
+        assert result == {
+            snowflakes.Snowflake(65123): mock_sticker_1,
+            snowflakes.Snowflake(43156234): mock_sticker_2,
+        }
+        cache_impl._build_sticker.assert_has_calls([mock.call(mock_sticker_data_1), mock.call(mock_sticker_data_2)])
+
+    def test_get_stickers_view_for_guild_for_unknown_sticker_cache(self, cache_impl):
+        cache_impl._sticker_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(9999): mock.Mock(cache_utilities.GuildStickerData)}
+        )
+        cache_impl._guild_entries = collections.FreezableDict(
+            {
+                snowflakes.Snowflake(99999): mock.Mock(cache_utilities.GuildRecord),
+                snowflakes.Snowflake(9342123): cache_utilities.GuildRecord(),
+            }
+        )
+        cache_impl._build_sticker = mock.Mock()
+
+        result = cache_impl.get_stickers_view_for_guild(StubModel(9342123))
+
+        assert result == {}
+        cache_impl._build_sticker.assert_not_called()
+
+    def test_get_stickers_view_for_guild_for_unknown_record(self, cache_impl):
+        cache_impl._sticker_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(12354345): mock.Mock(cache_utilities.GuildStickerData)}
+        )
+        cache_impl._guild_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(9342123): cache_utilities.GuildRecord()}
+        )
+        cache_impl._build_sticker = mock.Mock()
+
+        result = cache_impl.get_stickers_view_for_guild(StubModel(9342123))
+
+        assert result == {}
+        cache_impl._build_sticker.assert_not_called()
+
+    def test_set_sticker(self, cache_impl):
+        mock_user = mock.Mock(users.User, id=snowflakes.Snowflake(654234))
+        mock_reffed_user = cache_utilities.RefCell(mock_user)
+        sticker = stickers.GuildSticker(
+            id=snowflakes.Snowflake(5123123),
+            name="A name",
+            guild_id=snowflakes.Snowflake(65234),
+            user=mock_user,
+            description="Jax cute",
+            tag="lul",
+            format_type=1,
+            is_available=False,
+        )
+        cache_impl._set_user = mock.Mock(return_value=mock_reffed_user)
+        cache_impl._increment_ref_count = mock.Mock()
+
+        cache_impl.set_sticker(sticker)
+
+        assert 65234 in cache_impl._guild_entries
+        assert cache_impl._guild_entries[snowflakes.Snowflake(65234)].stickers
+        assert 5123123 in cache_impl._guild_entries[snowflakes.Snowflake(65234)].stickers
+        assert 5123123 in cache_impl._sticker_entries
+        sticker_data = cache_impl._sticker_entries[snowflakes.Snowflake(5123123)]
+        cache_impl._set_user.assert_called_once_with(mock_user)
+        cache_impl._increment_ref_count.assert_called_once_with(mock_reffed_user)
+        assert sticker_data.id == snowflakes.Snowflake(5123123)
+        assert sticker_data.name == "A name"
+        assert sticker_data.guild_id == snowflakes.Snowflake(65234)
+        assert sticker_data.user is mock_reffed_user
+        assert sticker_data.is_available is False
+        assert sticker_data.format_type == 1
+        assert sticker_data.tag == "lul"
+        assert sticker_data.description == "Jax cute"
+
+    def test_set_sticker_with_pre_cached_sticker(self, cache_impl):
+        mock_user = mock.Mock(users.User, id=snowflakes.Snowflake(654234))
+        sticker = stickers.GuildSticker(
+            id=snowflakes.Snowflake(5123123),
+            name="A name",
+            guild_id=snowflakes.Snowflake(65234),
+            description="OI",
+            user=mock_user,
+            tag="lul",
+            format_type=1,
+            is_available=False,
+        )
+        cache_impl._sticker_entries = collections.FreezableDict(
+            {snowflakes.Snowflake(5123123): mock.Mock(cache_utilities.GuildStickerData)}
+        )
+        cache_impl._set_user = mock.Mock()
+        cache_impl._increment_user_ref_count = mock.Mock()
+
+        cache_impl.set_sticker(sticker)
+
+        assert 5123123 in cache_impl._sticker_entries
+        cache_impl._set_user.assert_called_once_with(mock_user)
+        cache_impl._increment_user_ref_count.assert_not_called()
+
     def test_clear_guilds_when_no_guilds_cached(self, cache_impl):
         cache_impl._guild_entries = collections.FreezableDict(
             {
@@ -2712,6 +3093,8 @@ def test_update_message_for_unknown_partial_message(self, cache_impl):
             ("clear_presences_for_guild", config_api.CacheComponents.PRESENCES, cache_utilities.EmptyCacheView()),
             ("clear_roles", config_api.CacheComponents.ROLES, cache_utilities.EmptyCacheView()),
             ("clear_roles_for_guild", config_api.CacheComponents.ROLES, cache_utilities.EmptyCacheView()),
+            ("clear_stickers", config_api.CacheComponents.GUILD_STICKERS, cache_utilities.EmptyCacheView()),
+            ("clear_stickers_for_guild", config_api.CacheComponents.GUILD_STICKERS, cache_utilities.EmptyCacheView()),
             ("clear_voice_states", config_api.CacheComponents.VOICE_STATES, cache_utilities.EmptyCacheView()),
             (
                 "clear_voice_states_for_channel",
@@ -2727,6 +3110,7 @@ def test_update_message_for_unknown_partial_message(self, cache_impl):
             ("delete_message", config_api.CacheComponents.MESSAGES, None),
             ("delete_presence", config_api.CacheComponents.PRESENCES, None),
             ("delete_role", config_api.CacheComponents.ROLES, None),
+            ("delete_sticker", config_api.CacheComponents.GUILD_STICKERS, None),
             ("delete_voice_state", config_api.CacheComponents.VOICE_STATES, None),
             ("get_available_guild", config_api.CacheComponents.GUILDS, None),
             ("get_available_guilds_view", config_api.CacheComponents.GUILDS, cache_utilities.EmptyCacheView()),
@@ -2755,6 +3139,13 @@ def test_update_message_for_unknown_partial_message(self, cache_impl):
             ("get_role", config_api.CacheComponents.ROLES, None),
             ("get_roles_view", config_api.CacheComponents.ROLES, cache_utilities.EmptyCacheView()),
             ("get_roles_view_for_guild", config_api.CacheComponents.ROLES, cache_utilities.EmptyCacheView()),
+            ("get_sticker", config_api.CacheComponents.GUILD_STICKERS, None),
+            ("get_stickers_view", config_api.CacheComponents.GUILD_STICKERS, cache_utilities.EmptyCacheView()),
+            (
+                "get_stickers_view_for_guild",
+                config_api.CacheComponents.GUILD_STICKERS,
+                cache_utilities.EmptyCacheView(),
+            ),
             ("get_unavailable_guild", config_api.CacheComponents.GUILDS, None),
             ("get_unavailable_guilds_view", config_api.CacheComponents.GUILDS, cache_utilities.EmptyCacheView()),
             ("get_voice_state", config_api.CacheComponents.VOICE_STATES, None),
@@ -2778,6 +3169,7 @@ def test_update_message_for_unknown_partial_message(self, cache_impl):
             ("set_message", config_api.CacheComponents.MESSAGES, None),
             ("set_presence", config_api.CacheComponents.PRESENCES, None),
             ("set_role", config_api.CacheComponents.ROLES, None),
+            ("set_sticker", config_api.CacheComponents.GUILD_STICKERS, None),
             ("set_voice_state", config_api.CacheComponents.VOICE_STATES, None),
             ("update_emoji", config_api.CacheComponents.EMOJIS, (None, None)),
             ("update_guild", config_api.CacheComponents.GUILDS, (None, None)),
diff --git a/tests/hikari/impl/test_entity_factory.py b/tests/hikari/impl/test_entity_factory.py
index 220d5feb..aaa9851e 100644
--- a/tests/hikari/impl/test_entity_factory.py
+++ b/tests/hikari/impl/test_entity_factory.py
@@ -2668,6 +2668,7 @@ def test_deserialize_guild_preview_with_null_fields(self, entity_factory_impl, m
     def rest_guild_payload(
         self,
         known_custom_emoji_payload,
+        guild_sticker_payload,
         guild_role_payload,
     ):
         return {
@@ -2683,6 +2684,7 @@ def rest_guild_payload(
             "embed_channel_id": "9439394949",
             "embed_enabled": True,
             "emojis": [known_custom_emoji_payload],
+            "stickers": [guild_sticker_payload],
             "explicit_content_filter": 2,
             "features": ["ANIMATED_ICON", "MORE_EMOJI", "NEWS", "SOME_UNDOCUMENTED_FEATURE"],
             "icon": "1a2b3c4d",
@@ -2716,6 +2718,7 @@ def test_deserialize_rest_guild(
         rest_guild_payload,
         known_custom_emoji_payload,
         guild_role_payload,
+        guild_sticker_payload,
     ):
         guild = entity_factory_impl.deserialize_rest_guild(rest_guild_payload)
         assert guild.app is mock_app
@@ -2746,6 +2749,9 @@ def test_deserialize_rest_guild(
                 known_custom_emoji_payload, guild_id=snowflakes.Snowflake(265828729970753537)
             )
         }
+        assert guild.stickers == {
+            749046696482439188: entity_factory_impl.deserialize_guild_sticker(guild_sticker_payload)
+        }
         assert guild.mfa_level == guild_models.GuildMFALevel.ELEVATED
         assert guild.application_id == 39494949
         assert guild.widget_channel_id == 9439394949
@@ -2779,6 +2785,7 @@ def test_deserialize_rest_guild_with_unset_fields(self, entity_factory_impl):
                 "description": "This is a server I guess, its a bit crap though",
                 "discovery_splash": "famfamFAMFAMfam",
                 "emojis": [],
+                "stickers": [],
                 "explicit_content_filter": 2,
                 "features": ["ANIMATED_ICON", "MORE_EMOJI", "NEWS", "SOME_UNDOCUMENTED_FEATURE"],
                 "icon": "1a2b3c4d",
@@ -2823,6 +2830,7 @@ def test_deserialize_rest_guild_with_null_fields(self, entity_factory_impl):
                 "embed_channel_id": None,
                 "embed_enabled": True,
                 "emojis": [],
+                "stickers": [],
                 "explicit_content_filter": 2,
                 "features": ["ANIMATED_ICON", "MORE_EMOJI", "NEWS", "SOME_UNDOCUMENTED_FEATURE"],
                 "icon": None,
@@ -4025,6 +4033,29 @@ def test_deserialize_sticker_pack(self, entity_factory_impl, sticker_pack_payloa
         assert sticker.sort_value == 96
         assert sticker.tags == ["thinking", "thonkang"]
 
+    def test_stickers(self, entity_factory_impl, guild_sticker_payload):
+        guild_definition = entity_factory_impl.deserialize_gateway_guild(
+            {"id": "265828729970753537", "stickers": [guild_sticker_payload]},
+        )
+
+        assert guild_definition.stickers() == {
+            749046696482439188: entity_factory_impl.deserialize_guild_sticker(
+                guild_sticker_payload,
+            )
+        }
+
+    def test_stickers_returns_cached_values(self, entity_factory_impl):
+        with mock.patch.object(
+            entity_factory.EntityFactoryImpl, "deserialize_guild_sticker"
+        ) as mock_deserialize_guild_sticker:
+            guild_definition = entity_factory_impl.deserialize_gateway_guild({"id": "265828729970753537"})
+
+            mock_sticker = object()
+            guild_definition._stickers = {"54545454": mock_sticker}
+
+            assert guild_definition.stickers() == {"54545454": mock_sticker}
+            mock_deserialize_guild_sticker.assert_not_called()
+
     #################
     # INVITE MODELS #
     #################
diff --git a/tests/hikari/impl/test_event_factory.py b/tests/hikari/impl/test_event_factory.py
index e269c9d0..94a59e07 100644
--- a/tests/hikari/impl/test_event_factory.py
+++ b/tests/hikari/impl/test_event_factory.py
@@ -232,6 +232,7 @@ def test_deserialize_guild_available_event(self, event_factory, mock_app, mock_s
         guild_definition = mock_app.entity_factory.deserialize_gateway_guild.return_value
         assert event.guild is guild_definition.guild.return_value
         assert event.emojis is guild_definition.emojis.return_value
+        assert event.stickers is guild_definition.stickers.return_value
         assert event.roles is guild_definition.roles.return_value
         assert event.channels is guild_definition.channels.return_value
         assert event.members is guild_definition.members.return_value
@@ -239,6 +240,7 @@ def test_deserialize_guild_available_event(self, event_factory, mock_app, mock_s
         assert event.voice_states is guild_definition.voice_states.return_value
         guild_definition.guild.assert_called_once_with()
         guild_definition.emojis.assert_called_once_with()
+        guild_definition.stickers.assert_called_once_with()
         guild_definition.roles.assert_called_once_with()
         guild_definition.channels.assert_called_once_with()
         guild_definition.members.assert_called_once_with()
@@ -345,6 +347,23 @@ def test_deserialize_guild_emojis_update_event(self, event_factory, mock_app, mo
         assert event.guild_id == 123431
         assert event.old_emojis is mock_old_emojis
 
+    def test_deserialize_guild_stickers_update_event(self, event_factory, mock_app, mock_shard):
+        mock_sticker_payload = object()
+        mock_old_stickers = object()
+        mock_payload = {"guild_id": "472", "stickers": [mock_sticker_payload]}
+
+        event = event_factory.deserialize_guild_stickers_update_event(
+            mock_shard, mock_payload, old_stickers=mock_old_stickers
+        )
+
+        mock_app.entity_factory.deserialize_guild_sticker.assert_called_once_with(mock_sticker_payload)
+        assert isinstance(event, guild_events.StickersUpdateEvent)
+        assert event.app is mock_app
+        assert event.shard is mock_shard
+        assert event.stickers == [mock_app.entity_factory.deserialize_guild_sticker.return_value]
+        assert event.guild_id == 472
+        assert event.old_stickers is mock_old_stickers
+
     def test_deserialize_integration_create_event(self, event_factory, mock_app, mock_shard):
         mock_payload = object()
 
diff --git a/tests/hikari/impl/test_event_manager.py b/tests/hikari/impl/test_event_manager.py
index b82e6c49..1374433b 100644
--- a/tests/hikari/impl/test_event_manager.py
+++ b/tests/hikari/impl/test_event_manager.py
@@ -273,6 +273,8 @@ async def test_on_guild_create_when_dispatching_and_not_caching(
         event_manager_impl._cache.set_guild_channel.assert_not_called()
         event_manager_impl._cache.clear_emojis_for_guild.assert_not_called()
         event_manager_impl._cache.set_emoji.assert_not_called()
+        event_manager_impl._cache.clear_stickers_for_guild.assert_not_called()
+        event_manager_impl._cache.set_sticker.assert_not_called()
         event_manager_impl._cache.clear_roles_for_guild.assert_not_called()
         event_manager_impl._cache.set_role.assert_not_called()
         event_manager_impl._cache.clear_members_for_guild.assert_not_called()
@@ -311,6 +313,8 @@ async def test_on_guild_create_when_not_dispatching_and_not_caching(
         event_manager_impl._cache.set_guild_channel.assert_not_called()
         event_manager_impl._cache.clear_emojis_for_guild.assert_not_called()
         event_manager_impl._cache.set_emoji.assert_not_called()
+        event_manager_impl._cache.clear_stickers_for_guild.assert_not_called()
+        event_manager_impl._cache.set_sticker.assert_not_called()
         event_manager_impl._cache.clear_roles_for_guild.assert_not_called()
         event_manager_impl._cache.set_role.assert_not_called()
         event_manager_impl._cache.clear_members_for_guild.assert_not_called()
@@ -339,6 +343,7 @@ async def test_on_guild_create_when_not_dispatching_and_caching(
         gateway_guild.voice_states.return_value = {1: "voice1", 2: "voice2"}
         gateway_guild.presences.return_value = {1: "presence1", 2: "presence2"}
         gateway_guild.members.return_value = {1: "member1", 2: "member2"}
+        gateway_guild.stickers.return_value = {1: "sticker1", 2: "sticker2"}
 
         with mock.patch.object(event_manager, "_request_guild_members") as request_guild_members:
             await event_manager_impl.on_guild_create(shard, payload)
@@ -356,6 +361,8 @@ async def test_on_guild_create_when_not_dispatching_and_caching(
         event_manager_impl._cache.set_guild_channel.assert_has_calls([mock.call("channel1"), mock.call("channel2")])
         event_manager_impl._cache.clear_emojis_for_guild.assert_called_once_with(gateway_guild.id)
         event_manager_impl._cache.set_emoji.assert_has_calls([mock.call("emoji1"), mock.call("emoji2")])
+        event_manager_impl._cache.clear_stickers_for_guild.assert_called_once_with(gateway_guild.id)
+        event_manager_impl._cache.set_sticker.assert_has_calls([mock.call("sticker1"), mock.call("sticker2")])
         event_manager_impl._cache.clear_roles_for_guild.assert_called_once_with(gateway_guild.id)
         event_manager_impl._cache.set_role.assert_has_calls([mock.call("role1"), mock.call("role2")])
         event_manager_impl._cache.clear_members_for_guild.assert_called_once_with(gateway_guild.id)
@@ -495,8 +502,11 @@ async def test_on_guild_update_stateful_and_dispatching(
         old_guild = object()
         mock_role = object()
         mock_emoji = object()
+        mock_sticker = object()
         event_manager_impl._enabled_for_event = mock.Mock(return_value=True)
-        event = mock.Mock(roles={555: mock_role}, emojis={333: mock_emoji}, guild=mock.Mock(id=123))
+        event = mock.Mock(
+            roles={555: mock_role}, emojis={333: mock_emoji}, guild=mock.Mock(id=123), stickers={444: mock_sticker}
+        )
 
         event_factory.deserialize_guild_update_event.return_value = event
         event_manager_impl._cache.get_guild.return_value = old_guild
@@ -510,6 +520,8 @@ async def test_on_guild_update_stateful_and_dispatching(
         event_manager_impl._cache.set_role.assert_called_once_with(mock_role)
         event_manager_impl._cache.clear_emojis_for_guild.assert_called_once_with(123)
         event_manager_impl._cache.set_emoji.assert_called_once_with(mock_emoji)
+        event_manager_impl._cache.clear_stickers_for_guild.assert_called_once_with(123)
+        event_manager_impl._cache.set_sticker.assert_called_once_with(mock_sticker)
         entity_factory.deserialize_gateway_guild.assert_not_called()
         event_factory.deserialize_guild_update_event.assert_called_once_with(shard, payload, old_guild=old_guild)
         event_manager_impl.dispatch.assert_awaited_once_with(event)
@@ -521,11 +533,13 @@ async def test_on_guild_update_all_cache_components_and_not_dispatching(
         payload = {"id": 123}
         mock_role = object()
         mock_emoji = object()
+        mock_sticker = object()
         event_manager_impl._enabled_for_event = mock.Mock(return_value=False)
         guild_definition = entity_factory.deserialize_gateway_guild.return_value
         guild_definition.id = 123
         guild_definition.emojis.return_value = {0: mock_emoji}
         guild_definition.roles.return_value = {1: mock_role}
+        guild_definition.stickers.return_value = {4: mock_sticker}
 
         await event_manager_impl.on_guild_update(shard, payload)
 
@@ -534,6 +548,8 @@ async def test_on_guild_update_all_cache_components_and_not_dispatching(
         event_manager_impl._cache.update_guild.assert_called_once_with(guild_definition.guild.return_value)
         event_manager_impl._cache.clear_emojis_for_guild.assert_called_once_with(123)
         event_manager_impl._cache.set_emoji.assert_called_once_with(mock_emoji)
+        event_manager_impl._cache.clear_stickers_for_guild.assert_called_once_with(123)
+        event_manager_impl._cache.set_sticker.assert_called_once_with(mock_sticker)
         event_manager_impl._cache.clear_roles_for_guild.assert_called_once_with(123)
         event_manager_impl._cache.set_role.assert_called_once_with(mock_role)
         event_factory.deserialize_guild_update_event.assert_not_called()
@@ -558,6 +574,8 @@ async def test_on_guild_update_no_cache_components_and_not_dispatching(
         event_manager_impl._cache.update_guild.assert_not_called()
         event_manager_impl._cache.clear_emojis_for_guild.assert_not_called()
         event_manager_impl._cache.set_emoji.assert_not_called()
+        event_manager_impl._cache.clear_stickers_for_guild.assert_not_called()
+        event_manager_impl._cache.set_sticker.assert_not_called()
         event_manager_impl._cache.clear_roles_for_guild.assert_not_called()
         event_manager_impl._cache.set_role.assert_not_called()
         event_factory.deserialize_guild_update_event.assert_not_called()
@@ -598,6 +616,7 @@ async def test_on_guild_delete_stateful_when_available(self, event_manager_impl,
         event_manager_impl._cache.clear_presences_for_guild.assert_called_once_with(123)
         event_manager_impl._cache.clear_guild_channels_for_guild.assert_called_once_with(123)
         event_manager_impl._cache.clear_emojis_for_guild.assert_called_once_with(123)
+        event_manager_impl._cache.clear_stickers_for_guild.assert_called_once_with(123)
         event_manager_impl._cache.clear_roles_for_guild.assert_called_once_with(123)
         event_factory.deserialize_guild_leave_event.assert_called_once_with(
             shard, payload, old_guild=event_manager_impl._cache.delete_guild.return_value
@@ -691,6 +710,36 @@ async def test_on_guild_emojis_update_stateless(self, stateless_event_manager_im
             event_factory.deserialize_guild_emojis_update_event.return_value
         )
 
+    @pytest.mark.asyncio()
+    async def test_on_guild_stickers_update_stateful(self, event_manager_impl, shard, event_factory):
+        payload = {"guild_id": 720}
+        old_stickers = {700: 123}
+        mock_sticker = object()
+        event = mock.Mock(stickers=[mock_sticker], guild_id=123)
+
+        event_factory.deserialize_guild_stickers_update_event.return_value = event
+        event_manager_impl._cache.clear_stickers_for_guild.return_value = old_stickers
+
+        await event_manager_impl.on_guild_stickers_update(shard, payload)
+
+        event_manager_impl._cache.clear_stickers_for_guild.assert_called_once_with(720)
+        event_manager_impl._cache.set_sticker.assert_called_once_with(mock_sticker)
+        event_factory.deserialize_guild_stickers_update_event.assert_called_once_with(
+            shard, payload, old_stickers=[123]
+        )
+        event_manager_impl.dispatch.assert_awaited_once_with(event)
+
+    @pytest.mark.asyncio()
+    async def test_on_guild_stickers_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+        payload = {"guild_id": 123}
+
+        await stateless_event_manager_impl.on_guild_stickers_update(shard, payload)
+
+        event_factory.deserialize_guild_stickers_update_event.assert_called_once_with(shard, payload, old_stickers=None)
+        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+            event_factory.deserialize_guild_stickers_update_event.return_value
+        )
+
     @pytest.mark.asyncio()
     async def test_on_guild_integrations_update(self, event_manager_impl, shard):
         with pytest.raises(NotImplementedError):
diff --git a/tests/hikari/impl/test_rest.py b/tests/hikari/impl/test_rest.py
index be1e20ae..83abb268 100644
--- a/tests/hikari/impl/test_rest.py
+++ b/tests/hikari/impl/test_rest.py
@@ -2158,13 +2158,13 @@ async def test_edit_voice_state_without_optional_arguments(self, rest_client):
         assert result is None
         rest_client._request.assert_awaited_once_with(expected_route, json={"channel_id": "321"})
 
-    async def test_edit_permission_overwrites(self, rest_client):
+    async def test_edit_permission_overwrite(self, rest_client):
         target = StubModel(456)
         expected_route = routes.PUT_CHANNEL_PERMISSIONS.compile(channel=123, overwrite=456)
         rest_client._request = mock.AsyncMock()
         expected_json = {"type": 1, "allow": 4, "deny": 1}
 
-        await rest_client.edit_permission_overwrites(
+        await rest_client.edit_permission_overwrite(
             StubModel(123),
             target,
             target_type=channels.PermissionOverwriteType.MEMBER,
@@ -2174,6 +2174,26 @@ async def test_edit_permission_overwrites(self, rest_client):
         )
         rest_client._request.assert_awaited_once_with(expected_route, json=expected_json, reason="cause why not :)")
 
+    async def test_edit_permission_overwrites(self, rest_client):
+        with mock.patch.object(rest_client, "edit_permission_overwrite") as edit_permission_overwrite:
+            await rest_client.edit_permission_overwrites(
+                StubModel(123),
+                StubModel(456),
+                target_type=channels.PermissionOverwriteType.MEMBER,
+                allow=permissions.Permissions.BAN_MEMBERS,
+                deny=permissions.Permissions.CREATE_INSTANT_INVITE,
+                reason="cause why not :)",
+            )
+
+        edit_permission_overwrite.assert_awaited_once_with(
+            StubModel(123),
+            StubModel(456),
+            target_type=channels.PermissionOverwriteType.MEMBER,
+            allow=permissions.Permissions.BAN_MEMBERS,
+            deny=permissions.Permissions.CREATE_INSTANT_INVITE,
+            reason="cause why not :)",
+        )
+
     @pytest.mark.parametrize(
         ("target", "expected_type"),
         [
@@ -2218,17 +2238,17 @@ async def test_edit_permission_overwrites(self, rest_client):
             ),
         ],
     )
-    async def test_edit_permission_overwrites_when_target_undefined(self, rest_client, target, expected_type):
+    async def test_edit_permission_overwrite_when_target_undefined(self, rest_client, target, expected_type):
         expected_route = routes.PUT_CHANNEL_PERMISSIONS.compile(channel=123, overwrite=456)
         rest_client._request = mock.AsyncMock()
         expected_json = {"type": expected_type}
 
-        await rest_client.edit_permission_overwrites(StubModel(123), target)
+        await rest_client.edit_permission_overwrite(StubModel(123), target)
         rest_client._request.assert_awaited_once_with(expected_route, json=expected_json, reason=undefined.UNDEFINED)
 
-    async def test_edit_permission_overwrites_when_cant_determine_target_type(self, rest_client):
+    async def test_edit_permission_overwrite_when_cant_determine_target_type(self, rest_client):
         with pytest.raises(TypeError):
-            await rest_client.edit_permission_overwrites(StubModel(123), StubModel(123))
+            await rest_client.edit_permission_overwrite(StubModel(123), StubModel(123))
 
     async def test_delete_permission_overwrite(self, rest_client):
         expected_route = routes.DELETE_CHANNEL_PERMISSIONS.compile(channel=123, overwrite=456)
diff --git a/tests/hikari/internal/test_cache.py b/tests/hikari/internal/test_cache.py
new file mode 100644
index 00000000..7360c3d5
--- /dev/null
+++ b/tests/hikari/internal/test_cache.py
@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2020 Nekokatt
+# Copyright (c) 2021-present davfsa
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+import copy
+import mock
+
+from hikari import snowflakes
+from hikari import stickers
+from hikari.internal import cache
+
+
+class TestStickerData:
+    def test_from_entity(self) -> None:
+        mock_user = object()
+        mock_sticker = stickers.GuildSticker(
+            id=snowflakes.Snowflake(69420),
+            name="lulzor",
+            format_type=123,
+            description="Fake sticker",
+            guild_id=snowflakes.Snowflake(42069),
+            is_available=True,
+            tag="some tag",
+            user=None,
+        )
+
+        data = cache.GuildStickerData.build_from_entity(mock_sticker, user=mock_user)
+
+        assert data.id is mock_sticker.id
+        assert data.name is mock_sticker.name
+        assert data.format_type is mock_sticker.format_type
+        assert data.description is mock_sticker.description
+        assert data.guild_id is mock_sticker.guild_id
+        assert data.is_available is mock_sticker.is_available
+        assert data.tag is mock_sticker.tag
+        assert data.user is mock_user
+
+    def test_from_entity_when_user_not_passed(self) -> None:
+        mock_user = object()
+        mock_sticker = mock_sticker = stickers.GuildSticker(
+            id=snowflakes.Snowflake(69420),
+            name="lulzor",
+            format_type=123,
+            description="Fake sticker",
+            guild_id=snowflakes.Snowflake(42069),
+            is_available=True,
+            tag="some tag",
+            user=mock_user,
+        )
+
+        with mock.patch.object(copy, "copy") as mock_copy:
+            with mock.patch.object(cache, "RefCell") as refcell:
+                data = cache.GuildStickerData.build_from_entity(mock_sticker)
+
+        assert data.user is refcell.return_value
+        mock_copy.assert_called_once_with(mock_user)
+        refcell.assert_called_once_with(mock_copy.return_value)
diff --git a/tests/hikari/test_channels.py b/tests/hikari/test_channels.py
index 4a4b226e..7121eac1 100644
--- a/tests/hikari/test_channels.py
+++ b/tests/hikari/test_channels.py
@@ -340,7 +340,7 @@ def test_mention_property(self, model):
 
     @pytest.mark.asyncio()
     async def test_edit_overwrite(self, model):
-        model.app.rest.edit_permission_overwrites = mock.AsyncMock()
+        model.app.rest.edit_permission_overwrite = mock.AsyncMock()
         user = mock.Mock(users.PartialUser)
         await model.edit_overwrite(
             333,
@@ -350,7 +350,7 @@ async def test_edit_overwrite(self, model):
             reason="vrooom vroom",
         )
 
-        model.app.rest.edit_permission_overwrites.assert_called_once_with(
+        model.app.rest.edit_permission_overwrite.assert_called_once_with(
             69420,
             333,
             target_type=user,
@@ -361,13 +361,13 @@ async def test_edit_overwrite(self, model):
 
     @pytest.mark.asyncio()
     async def test_edit_overwrite_target_type_none(self, model):
-        model.app.rest.edit_permission_overwrites = mock.AsyncMock()
+        model.app.rest.edit_permission_overwrite = mock.AsyncMock()
         user = mock.Mock(users.PartialUser)
         await model.edit_overwrite(
             user, allow=permissions.Permissions.BAN_MEMBERS, deny=permissions.Permissions.CONNECT, reason="vrooom vroom"
         )
 
-        model.app.rest.edit_permission_overwrites.assert_called_once_with(
+        model.app.rest.edit_permission_overwrite.assert_called_once_with(
             69420,
             user,
             allow=permissions.Permissions.BAN_MEMBERS,
diff --git a/tests/hikari/test_guilds.py b/tests/hikari/test_guilds.py
index 551481e1..063d1bf7 100644
--- a/tests/hikari/test_guilds.py
+++ b/tests/hikari/test_guilds.py
@@ -485,11 +485,7 @@ def test_display_name_property_when_no_nickname(self, model, mock_user):
         model.nickname = None
         assert model.display_name is mock_user.username
 
-    def test_mention_property_when_nickname(self, model):
-        assert model.mention == "<@!123>"
-
-    def test_mention_property_when_no_nickname(self, model, mock_user):
-        model.nickname = None
+    def test_mention_property(self, model, mock_user):
         assert model.mention == mock_user.mention
 
     def test_get_guild(self, model):
@@ -1057,6 +1053,22 @@ def test_emojis_when_no_cache_trait(self, model):
         model.app = object()
         assert model.get_emojis() == {}
 
+    def test_get_sticker(self, model):
+        assert model.get_sticker(456) is model.app.cache.get_sticker.return_value
+        model.app.cache.get_sticker.assert_called_once_with(456)
+
+    def test_get_sticker_when_no_cache_trait(self, model):
+        model.app = object()
+        assert model.get_sticker(1234) is None
+
+    def test_get_stickers(self, model):
+        assert model.get_stickers() is model.app.cache.get_stickers_view_for_guild.return_value
+        model.app.cache.get_stickers_view_for_guild.assert_called_once_with(123)
+
+    def test_get_stickers_when_no_cache_trait(self, model):
+        model.app = object()
+        assert model.get_stickers() == {}
+
     def test_roles(self, model):
         assert model.get_roles() is model.app.cache.get_roles_view_for_guild.return_value
         model.app.cache.get_roles_view_for_guild.assert_called_once_with(123)
@@ -1353,6 +1365,7 @@ def model(self, mock_app):
             widget_channel_id=None,
             system_channel_flags=guilds.GuildSystemChannelFlag.SUPPRESS_PREMIUM_SUBSCRIPTION,
             emojis={},
+            stickers={},
             roles={},
             approximate_active_member_count=1000,
             approximate_member_count=100,