How to make a Rust kill rewards plugin (scrap per kill, Oxide)

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;

namespace Oxide.Plugins
{
    [Info("KillRewards", "RustPluginGenerator", "1.0.0")]
    [Description("Awards a configurable item to the killer on every player kill, with an optional headshot bonus.")]
    public class KillRewards : RustPlugin
    {
        private const string PermUse = "killrewards.use";

        private PluginConfig config;
        private bool warnedInvalidItem;

        private class PluginConfig
        {
            [JsonProperty("Reward Shortname")]
            public string RewardShortname { get; set; } = "scrap";

            [JsonProperty("Reward Amount")]
            public int RewardAmount { get; set; } = 25;

            [JsonProperty("Headshot Bonus Amount")]
            public int HeadshotBonusAmount { get; set; } = 25;

            [JsonProperty("Require Permission")]
            public bool RequirePermission { get; set; } = false;

            [JsonProperty("Message Killer")]
            public bool MessageKiller { get; set; } = true;

            [JsonProperty("Announce To Server")]
            public bool AnnounceToServer { get; set; } = false;
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Reward"] = "You received {0} x {1} for killing {2}.",
                ["RewardHeadshot"] = "You received {0} x {1} for a headshot kill on {2}.",
                ["Announce"] = "{0} was killed by {1}.",
                ["InvalidItem"] = "KillRewards: the reward shortname '{0}' is not a valid item."
            }, this);
        }

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
        }

        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            if (entity == null || info == null) return;

            var victim = entity as BasePlayer;
            if (victim == null || victim.IsNpc || !victim.IsConnected) return;

            var killer = info.InitiatorPlayer;
            if (killer == null || killer.IsNpc || !killer.IsConnected) return;
            if (killer.userID == victim.userID) return;

            // Team check: same non-zero team id means a team kill.
            if (killer.currentTeam != 0 && killer.currentTeam == victim.currentTeam) return;

            if (config.RequirePermission && !permission.UserHasPermission(killer.UserIDString, PermUse)) return;

            GiveReward(killer, victim, info.isHeadshot);
        }

        private void GiveReward(BasePlayer killer, BasePlayer victim, bool headshot)
        {
            int amount = config.RewardAmount;
            if (headshot) amount += config.HeadshotBonusAmount;
            if (amount <= 0) return;

            var item = ItemManager.CreateByName(config.RewardShortname, amount, 0);
            if (item == null)
            {
                if (!warnedInvalidItem)
                {
                    warnedInvalidItem = true;
                    PrintWarning($"Invalid reward shortname '{config.RewardShortname}', no rewards will be given until it is fixed.");
                }
                return;
            }

            killer.GiveItem(item);

            if (config.MessageKiller)
            {
                string key = headshot ? "RewardHeadshot" : "Reward";
                SendReply(killer, Msg(key, killer.UserIDString, amount, item.info.displayName.english, victim.displayName));
            }

            if (config.AnnounceToServer)
            {
                Server.Broadcast(Msg("Announce", null, victim.displayName, killer.displayName));
            }
        }

        private string Msg(string key, string userId = null, params object[] args) =>
            string.Format(lang.GetMessage(key, this, userId), args);
    }
}