How to make a Rust recycler output multiplier plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("Recycler Multiplier", "RustPluginGenerator", "1.0.0")]
    [Description("Multiplies recycler output with a global multiplier and per-item overrides.")]
    public class RecyclerMultiplier : RustPlugin
    {
        private const float MinimumAmount = 1f;

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Global multiplier")]
            public float GlobalMultiplier { get; set; } = 1.0f;

            [JsonProperty("Per-item overrides (shortname -> multiplier)")]
            public Dictionary<string, float> Overrides { get; set; } = new Dictionary<string, float>
            {
                ["scrap"] = 1.0f
            };
        }

        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();
            }

            // Sanitize multipliers so a mistyped value cannot zero out recycling.
            if (config.Overrides == null)
            {
                config.Overrides = new Dictionary<string, float>();
            }

            if (config.GlobalMultiplier <= 0f)
            {
                PrintWarning("Global multiplier must be greater than 0, resetting to 1.0");
                config.GlobalMultiplier = 1.0f;
            }

            foreach (var key in new List<string>(config.Overrides.Keys))
            {
                if (config.Overrides[key] <= 0f)
                {
                    PrintWarning($"Override for '{key}' must be greater than 0, resetting to 1.0");
                    config.Overrides[key] = 1.0f;
                }
            }

            SaveConfig();
        }

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

        private object OnItemRecycleAmount(Item slot, int num3, Recycler recycler)
        {
            if (slot == null || slot.info == null) return null;
            if (num3 <= 0) return null;

            float multiplier = config.GlobalMultiplier;

            float overrideValue;
            if (config.Overrides.TryGetValue(slot.info.shortname, out overrideValue))
            {
                multiplier = overrideValue;
            }

            if (Math.Abs(multiplier - 1f) < 0.0001f) return null;

            float result = num3 * multiplier;
            int amount = (int)Math.Round(result, MidpointRounding.AwayFromZero);

            if (amount < MinimumAmount) amount = (int)MinimumAmount;

            return amount;
        }
    }
}