discordrb 3.1.1 → 3.4.0

data/lib/discordrb/allowed_mentions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'discordrb/id_object'
+
+module Discordrb
+  # Builder class for `allowed_mentions` when sending messages.
+  class AllowedMentions
+    # @return [Array<"users", "roles", "everyone">, nil]
+    attr_accessor :parse
+
+    # @return [Array<String, Integer>, nil]
+    attr_accessor :users
+
+    # @return [Array<String, Integer>, nil]
+    attr_accessor :roles
+
+    # @param parse [Array<"users", "roles", "everyone">] Mention types that can be inferred from the message.
+    #   `users` and `roles` allow for all mentions of the respective type to ping. `everyone` allows usage of `@everyone` and `@here`
+    # @param users [Array<User, String, Integer>] Users or user IDs that can be pinged. Cannot be used in conjunction with `"users"` in `parse`
+    # @param roles [Array<Role, String, Integer>] Roles or role IDs that can be pinged. Cannot be used in conjunction with `"roles"` in `parse`
+    def initialize(parse: nil, users: nil, roles: nil)
+      @parse = parse
+      @users = users
+      @roles = roles
+    end
+
+    # @!visibility private
+    def to_hash
+      {
+        parse: @parse,
+        users: @users&.map { |user| user.is_a?(IDObject) ? user.id : user },
+        roles: @roles&.map { |role| role.is_a?(IDObject) ? role.id : role }
+      }.compact
+    end
+  end
+end

data/lib/discordrb/api.rb

@@ -9,7 +9,10 @@ require 'discordrb/errors'
 # List of methods representing endpoints in Discord's API
 module Discordrb::API
   # The base URL of the Discord REST API.
-  APIBASE = 'https://discordapp.com/api/v6'.freeze
+  APIBASE = 'https://discord.com/api/v6'
+
+  # The URL of Discord's CDN
+  CDN_URL = 'https://cdn.discordapp.com'
 
   module_function
 
@@ -23,23 +26,35 @@ module Discordrb::API
     @api_base = value
   end
 
-  # @return [String] the bot name, previously specified using #bot_name=.
+  # @return [String] the currently used CDN url
+  def cdn_url
+    @cdn_url || CDN_URL
+  end
+
+  # @return [String] the bot name, previously specified using {.bot_name=}.
   def bot_name
     @bot_name
   end
 
-  # Sets the bot name to something.
+  # Sets the bot name to something. Used in {.user_agent}. For the bot's username, see {Profile#username=}.
   def bot_name=(value)
     @bot_name = value
   end
 
+  # Changes the rate limit tracing behaviour. If rate limit tracing is on, a full backtrace will be logged on every RL
+  # hit.
+  # @param value [true, false] whether or not to enable rate limit tracing
+  def trace=(value)
+    @trace = value
+  end
+
   # Generate a user agent identifying this requester as discordrb.
   def user_agent
     # This particular string is required by the Discord devs.
-    required = "DiscordBot (https://github.com/meew0/discordrb, v#{Discordrb::VERSION})"
+    required = "DiscordBot (https://github.com/shardlab/discordrb, v#{Discordrb::VERSION})"
     @bot_name ||= ''
 
-    "rest-client/#{RestClient::VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} discordrb/#{Discordrb::VERSION} #{required} #{@bot_name}"
+    "#{required} rest-client/#{RestClient::VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} discordrb/#{Discordrb::VERSION} #{@bot_name}"
   end
 
   # Resets all rate limit mutexes
@@ -64,8 +79,11 @@ module Discordrb::API
   # @param attributes [Array] The attributes for the request.
   def raw_request(type, attributes)
     RestClient.send(type, *attributes)
-  rescue RestClient::Forbidden
-    raise Discordrb::Errors::NoPermission, "The bot doesn't have the required permission to do this!"
+  rescue RestClient::Forbidden => e
+    # HACK: for #request, dynamically inject restclient's response into NoPermission - this allows us to rate limit
+    noprm = Discordrb::Errors::NoPermission.new
+    noprm.define_singleton_method(:_rc_response) { e.response }
+    raise noprm, "The bot doesn't have the required permission to do this!"
   rescue RestClient::BadGateway
     Discordrb::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
     retry
@@ -76,6 +94,9 @@ module Discordrb::API
     # Add a custom user agent
     attributes.last[:user_agent] = user_agent if attributes.last.is_a? Hash
 
+    # Specify RateLimit precision
+    attributes.last[:x_ratelimit_precision] = 'millisecond'
+
     # The most recent Discord rate limit requirements require the support of major parameters, where a particular route
     # and major parameter combination (*not* the HTTP method) uniquely identifies a RL bucket.
     key = [key, major_parameter].freeze
@@ -83,24 +104,32 @@ module Discordrb::API
     begin
       mutex = @mutexes[key] ||= Mutex.new
 
-      # Lock and unlock, i. e. wait for the mutex to unlock and don't do anything with it afterwards
+      # Lock and unlock, i.e. wait for the mutex to unlock and don't do anything with it afterwards
       mutex_wait(mutex)
 
       # If the global mutex happens to be locked right now, wait for that as well.
       mutex_wait(@global_mutex) if @global_mutex.locked?
 
-      response = raw_request(type, attributes)
-
-      if response.headers[:x_ratelimit_remaining] == '0' && !mutex.locked?
-        Discordrb::LOGGER.debug "RL bucket depletion detected! Date: #{response.headers[:date]} Reset: #{response.headers[:x_ratelimit_reset]}"
-
-        now = Time.rfc2822(response.headers[:date])
-        reset = Time.at(response.headers[:x_ratelimit_reset].to_i)
-
-        delta = reset - now
-
-        Discordrb::LOGGER.warn("Locking RL mutex (key: #{key}) for #{delta} seconds preemptively")
-        sync_wait(delta, mutex)
+      response = nil
+      begin
+        response = raw_request(type, attributes)
+      rescue RestClient::Exception => e
+        response = e.response
+        raise e
+      rescue Discordrb::Errors::NoPermission => e
+        if e.respond_to?(:_rc_response)
+          response = e._rc_response
+        else
+          Discordrb::LOGGER.warn("NoPermission doesn't respond_to? _rc_response!")
+        end
+
+        raise e
+      ensure
+        if response
+          handle_preemptive_rl(response.headers, mutex, key) if response.headers[:x_ratelimit_remaining] == '0' && !mutex.locked?
+        else
+          Discordrb::LOGGER.ratelimit('Response was nil before trying to preemptively rate limit!')
+        end
       end
     rescue RestClient::TooManyRequests => e
       # If the 429 is from the global RL, then we have to use the global mutex instead.
@@ -109,7 +138,8 @@ module Discordrb::API
       unless mutex.locked?
         response = JSON.parse(e.response)
         wait_seconds = response['retry_after'].to_i / 1000.0
-        Discordrb::LOGGER.warn("Locking RL mutex (key: #{key}) for #{wait_seconds} seconds due to Discord rate limiting")
+        Discordrb::LOGGER.ratelimit("Locking RL mutex (key: #{key}) for #{wait_seconds} seconds due to Discord rate limiting")
+        trace("429 #{key.join(' ')}")
 
         # Wait the required time synchronized by the mutex (so other incoming requests have to wait) but only do it if
         # the mutex isn't locked already so it will only ever wait once
@@ -122,14 +152,39 @@ module Discordrb::API
     response
   end
 
+  # Handles pre-emptive rate limiting by waiting the given mutex by the difference of the Date header to the
+  # X-Ratelimit-Reset header, thus making sure we don't get 429'd in any subsequent requests.
+  def handle_preemptive_rl(headers, mutex, key)
+    Discordrb::LOGGER.ratelimit "RL bucket depletion detected! Date: #{headers[:date]} Reset: #{headers[:x_ratelimit_reset]}"
+    delta = headers[:x_ratelimit_reset_after].to_f
+    Discordrb::LOGGER.warn("Locking RL mutex (key: #{key}) for #{delta} seconds pre-emptively")
+    sync_wait(delta, mutex)
+  end
+
+  # Perform rate limit tracing. All this method does is log the current backtrace to the console with the `:ratelimit`
+  # level.
+  # @param reason [String] the reason to include with the backtrace.
+  def trace(reason)
+    unless @trace
+      Discordrb::LOGGER.debug("trace was called with reason #{reason}, but tracing is not enabled")
+      return
+    end
+
+    Discordrb::LOGGER.ratelimit("Trace (#{reason}):")
+
+    caller.each do |str|
+      Discordrb::LOGGER.ratelimit(" #{str}")
+    end
+  end
+
   # Make an icon URL from server and icon IDs
-  def icon_url(server_id, icon_id)
-    "#{api_base}/guilds/#{server_id}/icons/#{icon_id}.jpg"
+  def icon_url(server_id, icon_id, format = 'webp')
+    "#{cdn_url}/icons/#{server_id}/#{icon_id}.#{format}"
   end
 
   # Make an icon URL from application and icon IDs
-  def app_icon_url(app_id, icon_id)
-    "https://cdn.discordapp.com/app-icons/#{app_id}/#{icon_id}.jpg"
+  def app_icon_url(app_id, icon_id, format = 'webp')
+    "#{cdn_url}/app-icons/#{app_id}/#{icon_id}.#{format}"
   end
 
   # Make a widget picture URL from server ID
@@ -137,9 +192,29 @@ module Discordrb::API
     "#{api_base}/guilds/#{server_id}/widget.png?style=#{style}"
   end
 
+  # Make a splash URL from server and splash IDs
+  def splash_url(server_id, splash_id, format = 'webp')
+    "#{cdn_url}/splashes/#{server_id}/#{splash_id}.#{format}"
+  end
+
+  # Make a banner URL from server and banner IDs
+  def banner_url(server_id, banner_id, format = 'webp')
+    "#{cdn_url}/banners/#{server_id}/#{banner_id}.#{format}"
+  end
+
   # Make an emoji icon URL from emoji ID
-  def emoji_icon_url(emoji_id)
-    "https://cdn.discordapp.com/emojis/#{emoji_id}.png"
+  def emoji_icon_url(emoji_id, format = 'webp')
+    "#{cdn_url}/emojis/#{emoji_id}.#{format}"
+  end
+
+  # Make an asset URL from application and asset IDs
+  def asset_url(application_id, asset_id, format = 'webp')
+    "#{cdn_url}/app-assets/#{application_id}/#{asset_id}.#{format}"
+  end
+
+  # Make an achievement icon URL from application ID, achievement ID, and icon hash
+  def achievement_icon_url(application_id, achievement_id, icon_hash, format = 'webp')
+    "#{cdn_url}/app-assets/#{application_id}/achievements/#{achievement_id}/icons/#{icon_hash}.#{format}"
   end
 
   # Login to the server
@@ -228,6 +303,18 @@ module Discordrb::API
     )
   end
 
+  # Get the gateway to be used, with additional information for sharding and
+  # session start limits
+  def gateway_bot(token)
+    request(
+      :gateway_bot,
+      nil,
+      :get,
+      "#{api_base}/gateway/bot",
+      Authorization: token
+    )
+  end
+
   # Validate a token (this request will fail if the token is invalid)
   def validate_token(token)
     request(
@@ -240,6 +327,18 @@ module Discordrb::API
       content_type: :json
     )
   end
+
+  # Get a list of available voice regions
+  def voice_regions(token)
+    request(
+      :voice_regions,
+      nil,
+      :get,
+      "#{api_base}/voice/regions",
+      Authorization: token,
+      content_type: :json
+    )
+  end
 end
 
 Discordrb::API.reset_mutexes

data/lib/discordrb/api/channel.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 # API calls for Channel
 module Discordrb::API::Channel
   module_function
 
   # Get a channel's data
-  # https://discordapp.com/developers/docs/resources/channel#get-channel
+  # https://discord.com/developers/docs/resources/channel#get-channel
   def resolve(token, channel_id)
     Discordrb::API.request(
       :channels_cid,
@@ -15,45 +17,49 @@ module Discordrb::API::Channel
   end
 
   # Update a channel's data
-  # https://discordapp.com/developers/docs/resources/channel#modify-channel
-  def update(token, channel_id, name, topic, position, bitrate, user_limit)
+  # https://discord.com/developers/docs/resources/channel#modify-channel
+  def update(token, channel_id, name, topic, position, bitrate, user_limit, nsfw, permission_overwrites = nil, parent_id = nil, rate_limit_per_user = nil, reason = nil)
+    data = { name: name, position: position, topic: topic, bitrate: bitrate, user_limit: user_limit, nsfw: nsfw, parent_id: parent_id, rate_limit_per_user: rate_limit_per_user }
+    data[:permission_overwrites] = permission_overwrites unless permission_overwrites.nil?
     Discordrb::API.request(
       :channels_cid,
       channel_id,
       :patch,
       "#{Discordrb::API.api_base}/channels/#{channel_id}",
-      { name: name, position: position, topic: topic, bitrate: bitrate, user_limit: user_limit }.to_json,
+      data.to_json,
       Authorization: token,
-      content_type: :json
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
     )
   end
 
   # Delete a channel
-  # https://discordapp.com/developers/docs/resources/channel#deleteclose-channel
-  def delete(token, channel_id)
+  # https://discord.com/developers/docs/resources/channel#deleteclose-channel
+  def delete(token, channel_id, reason = nil)
     Discordrb::API.request(
       :channels_cid,
       channel_id,
       :delete,
       "#{Discordrb::API.api_base}/channels/#{channel_id}",
-      Authorization: token
+      Authorization: token,
+      'X-Audit-Log-Reason': reason
     )
   end
 
   # Get a list of messages from a channel's history
-  # https://discordapp.com/developers/docs/resources/channel#get-channel-messages
-  def messages(token, channel_id, amount, before = nil, after = nil)
+  # https://discord.com/developers/docs/resources/channel#get-channel-messages
+  def messages(token, channel_id, amount, before = nil, after = nil, around = nil)
     Discordrb::API.request(
       :channels_cid_messages,
       channel_id,
       :get,
-      "#{Discordrb::API.api_base}/channels/#{channel_id}/messages?limit=#{amount}#{"&before=#{before}" if before}#{"&after=#{after}" if after}",
+      "#{Discordrb::API.api_base}/channels/#{channel_id}/messages?limit=#{amount}#{"&before=#{before}" if before}#{"&after=#{after}" if after}#{"&around=#{around}" if around}",
       Authorization: token
     )
   end
 
   # Get a single message from a channel's history by id
-  # https://discordapp.com/developers/docs/resources/channel#get-channel-message
+  # https://discord.com/developers/docs/resources/channel#get-channel-message
   def message(token, channel_id, message_id)
     Discordrb::API.request(
       :channels_cid_messages_mid,
@@ -66,22 +72,37 @@ module Discordrb::API::Channel
 
   # Send a message to a channel
   # https://discordapp.com/developers/docs/resources/channel#create-message
-  def create_message(token, channel_id, message, mentions = [], tts = false, _server_id = nil) # send message
+  # @param attachments [Array<File>, nil] Attachments to use with `attachment://` in embeds. See
+  #   https://discord.com/developers/docs/resources/channel#create-message-using-attachments-within-embeds
+  def create_message(token, channel_id, message, tts = false, embed = nil, nonce = nil, attachments = nil, allowed_mentions = nil, message_reference = nil)
+    body = { content: message, tts: tts, embed: embed, nonce: nonce, allowed_mentions: allowed_mentions, message_reference: message_reference }
+    body = if attachments
+             files = [*0...attachments.size].zip(attachments).to_h
+             { **files, payload_json: body.to_json }
+           else
+             body.to_json
+           end
+
+    headers = { Authorization: token }
+    headers[:content_type] = :json unless attachments
+
     Discordrb::API.request(
       :channels_cid_messages_mid,
       channel_id,
       :post,
       "#{Discordrb::API.api_base}/channels/#{channel_id}/messages",
-      { content: message, mentions: mentions, tts: tts }.to_json,
-      Authorization: token,
-      content_type: :json
+      body,
+      **headers
     )
-  rescue RestClient::InternalServerError
-    raise Discordrb::Errors::MessageTooLong, "Message over the character limit (#{message.length} > 2000)"
+  rescue RestClient::BadRequest => e
+    parsed = JSON.parse(e.response.body)
+    raise Discordrb::Errors::MessageTooLong, "Message over the character limit (#{message.length} > 2000)" if parsed['content'].is_a?(Array) && parsed['content'].first == 'Must be 2000 or fewer in length.'
+
+    raise
   end
 
   # Send a file as a message to a channel
-  # https://discordapp.com/developers/docs/resources/channel#upload-file
+  # https://discord.com/developers/docs/resources/channel#upload-file
   def upload_file(token, channel_id, file, caption: nil, tts: false)
     Discordrb::API.request(
       :channels_cid_messages_mid,
@@ -94,14 +115,14 @@ module Discordrb::API::Channel
   end
 
   # Edit a message
-  # https://discordapp.com/developers/docs/resources/channel#edit-message
-  def edit_message(token, channel_id, message_id, message, mentions = [])
+  # https://discord.com/developers/docs/resources/channel#edit-message
+  def edit_message(token, channel_id, message_id, message, mentions = [], embed = nil)
     Discordrb::API.request(
       :channels_cid_messages_mid,
       channel_id,
       :patch,
       "#{Discordrb::API.api_base}/channels/#{channel_id}/messages/#{message_id}",
-      { content: message, mentions: mentions }.to_json,
+      { content: message, mentions: mentions, embed: embed }.to_json,
       Authorization: token,
       content_type: :json
     )
@@ -109,33 +130,102 @@ module Discordrb::API::Channel
 
   # Delete a message
   # https://discordapp.com/developers/docs/resources/channel#delete-message
-  def delete_message(token, channel_id, message_id)
+  def delete_message(token, channel_id, message_id, reason = nil)
     Discordrb::API.request(
       :channels_cid_messages_mid,
       channel_id,
       :delete,
       "#{Discordrb::API.api_base}/channels/#{channel_id}/messages/#{message_id}",
-      Authorization: token
+      Authorization: token,
+      'X-Audit-Log-Reason': reason
     )
   end
 
   # Delete messages in bulk
   # https://discordapp.com/developers/docs/resources/channel#bulk-delete-messages
-  def bulk_delete_messages(token, channel_id, messages = [])
+  def bulk_delete_messages(token, channel_id, messages = [], reason = nil)
     Discordrb::API.request(
       :channels_cid_messages_bulk_delete,
       channel_id,
       :post,
-      "#{Discordrb::API.api_base}/channels/#{channel_id}/messages/bulk_delete",
+      "#{Discordrb::API.api_base}/channels/#{channel_id}/messages/bulk-delete",
       { messages: messages }.to_json,
       Authorization: token,
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # Create a reaction on a message using this client
+  # https://discord.com/developers/docs/resources/channel#create-reaction
+  def create_reaction(token, channel_id, message_id, emoji)
+    emoji = URI.encode_www_form_component(emoji) unless emoji.ascii_only?
+    Discordrb::API.request(
+      :channels_cid_messages_mid_reactions_emoji_me,
+      channel_id,
+      :put,
+      "#{Discordrb::API.api_base}/channels/#{channel_id}/messages/#{message_id}/reactions/#{emoji}/@me",
+      nil,
+      Authorization: token,
       content_type: :json
     )
   end
 
+  # Delete this client's own reaction on a message
+  # https://discord.com/developers/docs/resources/channel#delete-own-reaction
+  def delete_own_reaction(token, channel_id, message_id, emoji)
+    emoji = URI.encode_www_form_component(emoji) unless emoji.ascii_only?
+    Discordrb::API.request(
+      :channels_cid_messages_mid_reactions_emoji_me,
+      channel_id,
+      :delete,
+      "#{Discordrb::API.api_base}/channels/#{channel_id}/messages/#{message_id}/reactions/#{emoji}/@me",
+      Authorization: token
+    )
+  end
+
+  # Delete another client's reaction on a message
+  # https://discord.com/developers/docs/resources/channel#delete-user-reaction
+  def delete_user_reaction(token, channel_id, message_id, emoji, user_id)
+    emoji = URI.encode_www_form_component(emoji) unless emoji.ascii_only?
+    Discordrb::API.request(
+      :channels_cid_messages_mid_reactions_emoji_uid,
+      channel_id,
+      :delete,
+      "#{Discordrb::API.api_base}/channels/#{channel_id}/messages/#{message_id}/reactions/#{emoji}/#{user_id}",
+      Authorization: token
+    )
+  end
+
+  # Get a list of clients who reacted with a specific reaction on a message
+  # https://discord.com/developers/docs/resources/channel#get-reactions
+  def get_reactions(token, channel_id, message_id, emoji, before_id, after_id, limit = 100)
+    emoji = URI.encode_www_form_component(emoji) unless emoji.ascii_only?
+    query_string = "limit=#{limit}#{"&before=#{before_id}" if before_id}#{"&after=#{after_id}" if after_id}"
+    Discordrb::API.request(
+      :channels_cid_messages_mid_reactions_emoji,
+      channel_id,
+      :get,
+      "#{Discordrb::API.api_base}/channels/#{channel_id}/messages/#{message_id}/reactions/#{emoji}?#{query_string}",
+      Authorization: token
+    )
+  end
+
+  # Deletes all reactions on a message from all clients
+  # https://discord.com/developers/docs/resources/channel#delete-all-reactions
+  def delete_all_reactions(token, channel_id, message_id)
+    Discordrb::API.request(
+      :channels_cid_messages_mid_reactions,
+      channel_id,
+      :delete,
+      "#{Discordrb::API.api_base}/channels/#{channel_id}/messages/#{message_id}/reactions",
+      Authorization: token
+    )
+  end
+
   # Update a channels permission for a role or member
-  # https://discordapp.com/developers/docs/resources/channel#edit-channel-permissions
-  def update_permission(token, channel_id, overwrite_id, allow, deny, type)
+  # https://discord.com/developers/docs/resources/channel#edit-channel-permissions
+  def update_permission(token, channel_id, overwrite_id, allow, deny, type, reason = nil)
     Discordrb::API.request(
       :channels_cid_permissions_oid,
       channel_id,
@@ -143,12 +233,13 @@ module Discordrb::API::Channel
       "#{Discordrb::API.api_base}/channels/#{channel_id}/permissions/#{overwrite_id}",
       { type: type, id: overwrite_id, allow: allow, deny: deny }.to_json,
       Authorization: token,
-      content_type: :json
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
     )
   end
 
   # Get a channel's invite list
-  # https://discordapp.com/developers/docs/resources/channel#get-channel-invites
+  # https://discord.com/developers/docs/resources/channel#get-channel-invites
   def invites(token, channel_id)
     Discordrb::API.request(
       :channels_cid_invites,
@@ -160,33 +251,35 @@ module Discordrb::API::Channel
   end
 
   # Create an instant invite from a server or a channel id
-  # https://discordapp.com/developers/docs/resources/channel#create-channel-invite
-  def create_invite(token, channel_id, max_age = 0, max_uses = 0, temporary = false)
+  # https://discord.com/developers/docs/resources/channel#create-channel-invite
+  def create_invite(token, channel_id, max_age = 0, max_uses = 0, temporary = false, unique = false, reason = nil)
     Discordrb::API.request(
       :channels_cid_invites,
       channel_id,
       :post,
       "#{Discordrb::API.api_base}/channels/#{channel_id}/invites",
-      { max_age: max_age, max_uses: max_uses, temporary: temporary }.to_json,
+      { max_age: max_age, max_uses: max_uses, temporary: temporary, unique: unique }.to_json,
       Authorization: token,
-      content_type: :json
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
     )
   end
 
   # Delete channel permission
-  # https://discordapp.com/developers/docs/resources/channel#delete-channel-permission
-  def delete_permission(token, channel_id, overwrite_id)
+  # https://discord.com/developers/docs/resources/channel#delete-channel-permission
+  def delete_permission(token, channel_id, overwrite_id, reason = nil)
     Discordrb::API.request(
       :channels_cid_permissions_oid,
       channel_id,
       :delete,
       "#{Discordrb::API.api_base}/channels/#{channel_id}/permissions/#{overwrite_id}",
-      Authorization: token
+      Authorization: token,
+      'X-Audit-Log-Reason': reason
     )
   end
 
   # Start typing (needs to be resent every 5 seconds to keep up the typing)
-  # https://discordapp.com/developers/docs/resources/channel#trigger-typing-indicator
+  # https://discord.com/developers/docs/resources/channel#trigger-typing-indicator
   def start_typing(token, channel_id)
     Discordrb::API.request(
       :channels_cid_typing,
@@ -199,7 +292,7 @@ module Discordrb::API::Channel
   end
 
   # Get a list of pinned messages in a channel
-  # https://discordapp.com/developers/docs/resources/channel#get-pinned-messages
+  # https://discord.com/developers/docs/resources/channel#get-pinned-messages
   def pinned_messages(token, channel_id)
     Discordrb::API.request(
       :channels_cid_pins,
@@ -212,26 +305,28 @@ module Discordrb::API::Channel
 
   # Pin a message
   # https://discordapp.com/developers/docs/resources/channel#add-pinned-channel-message
-  def pin_message(token, channel_id, message_id)
+  def pin_message(token, channel_id, message_id, reason = nil)
     Discordrb::API.request(
       :channels_cid_pins_mid,
       channel_id,
       :put,
       "#{Discordrb::API.api_base}/channels/#{channel_id}/pins/#{message_id}",
       nil,
-      Authorization: token
+      Authorization: token,
+      'X-Audit-Log-Reason': reason
     )
   end
 
   # Unpin a message
   # https://discordapp.com/developers/docs/resources/channel#delete-pinned-channel-message
-  def unpin_message(token, channel_id, message_id)
+  def unpin_message(token, channel_id, message_id, reason = nil)
     Discordrb::API.request(
       :channels_cid_pins_mid,
       channel_id,
       :delete,
       "#{Discordrb::API.api_base}/channels/#{channel_id}/pins/#{message_id}",
-      Authorization: token
+      Authorization: token,
+      'X-Audit-Log-Reason': reason
     )
   end
 
@@ -303,4 +398,31 @@ module Discordrb::API::Channel
       content_type: :json
     )
   end
+
+  # Create a webhook
+  # https://discord.com/developers/docs/resources/webhook#create-webhook
+  def create_webhook(token, channel_id, name, avatar = nil, reason = nil)
+    Discordrb::API.request(
+      :channels_cid_webhooks,
+      channel_id,
+      :post,
+      "#{Discordrb::API.api_base}/channels/#{channel_id}/webhooks",
+      { name: name, avatar: avatar }.to_json,
+      Authorization: token,
+      content_type: :json,
+      'X-Audit-Log-Reason': reason
+    )
+  end
+
+  # Get channel webhooks
+  # https://discord.com/developers/docs/resources/webhook#get-channel-webhooks
+  def webhooks(token, channel_id)
+    Discordrb::API.request(
+      :channels_cid_webhooks,
+      channel_id,
+      :get,
+      "#{Discordrb::API.api_base}/channels/#{channel_id}/webhooks",
+      Authorization: token
+    )
+  end
 end