How to make a Rust quarry and excavator multiplier plugin (separate rates)

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

namespace Oxide.Plugins
{
    [Info("Quarry Excavator Multiplier", "RustPluginGenerator", "1.0.0")]
    [Description("Multiplies quarry, pump jack and giant excavator output with separate configurable rates.")]
    public class QuarryExcavatorMultiplier : RustPlugin
    {
        private const string PermUse = "quarryexcavatormultiplier.use";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Quarry multiplier")]
            public float QuarryMultiplier = 2.0f;

            [JsonProperty("Excavator multiplier")]
            public float ExcavatorMultiplier = 2.0f;

            [JsonProperty("Per-resource multipliers (shortname = multiplier, 0 disables)")]
            public Dictionary<string, float> PerResource = new Dictionary<string, float>
            {
                ["sulfur.ore"] = 2.0f,
                ["hq.metal.ore"] = 1.5f
            };

            [JsonProperty("Limits")]
            public LimitsConfig Limits = new LimitsConfig();

            [JsonProperty("Permissions")]
            public PermissionsConfig Permissions = new PermissionsConfig();
        }

        private class LimitsConfig
        {
            [JsonProperty("Max amount per drop (0 = no limit)")]
            public int MaxAmountPerDrop = 1000;
        }

        private class PermissionsConfig
        {
            [JsonProperty("Require permission for full multiplier")]
            public bool RequireToUse = true;

            [JsonProperty("Multiplier for players without permission")]
            public float LimitedMultiplier = 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();
            }
            SaveConfig();
        }

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

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

        private object OnQuarryGather(MiningQuarry miningQuarry, Item item)
        {
            return Multiply(miningQuarry, item, config.QuarryMultiplier, true);
        }

        private object OnExcavatorGather(ExcavatorArm excavatorArm, Item item)
        {
            return Multiply(excavatorArm, item, config.ExcavatorMultiplier, false);
        }

        private object Multiply(BaseEntity machine, Item item, float baseMultiplier, bool isQuarry)
        {
            if (machine == null || item == null || item.info == null)
                return null;

            float multiplier = baseMultiplier;
            float overrideValue;
            if (config.PerResource != null && config.PerResource.TryGetValue(item.info.shortname, out overrideValue))
                multiplier = overrideValue;

            if (multiplier <= 0f)
                return null;

            if (config.Permissions.RequireToUse)
            {
                BasePlayer owner = machine.OwnerID == 0 ? null : BasePlayer.FindByID(machine.OwnerID);
                if (owner == null || !permission.UserHasPermission(owner.UserIDString, PermUse))
                    multiplier = Mathf.Min(multiplier, config.Permissions.LimitedMultiplier);
            }

            if (Mathf.Approximately(multiplier, 1f))
                return null;

            int original = item.amount;
            int extra = Mathf.RoundToInt(original * (multiplier - 1f));
            if (extra <= 0)
                return null;

            int cap = config.Limits == null ? 0 : config.Limits.MaxAmountPerDrop;
            int max = item.info.stackable > 0 ? item.info.stackable : int.MaxValue;
            if (cap > 0) max = Mathf.Min(max, cap);

            int newAmount = Mathf.Min(original + extra, max);
            if (newAmount <= original)
                return null;

            item.amount = newAmount;
            item.MarkDirty();
            return item;
        }
    }
}