How to make a Rust server currency plugin (Oxide balances + /pay)

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

namespace Oxide.Plugins
{
    [Info("Money Plugin", "RustPluginGenerator", "1.0.0")]
    [Description("Virtual currency with balances, /pay, admin grants and an API for other plugins.")]
    public class MoneyPlugin : RustPlugin
    {
        private const string PermUse = "moneyplugin.use";
        private const string PermPay = "moneyplugin.pay";
        private const string PermAdmin = "moneyplugin.admin";
        private const string DataFile = "MoneyPlugin";

        private PluginConfig config;
        private Dictionary<string, long> balances = new Dictionary<string, long>();
        private bool dirty;

        private class PluginConfig
        {
            [JsonProperty("Starting Balance")]
            public long StartingBalance { get; set; } = 100;

            [JsonProperty("Max Transfer")]
            public long MaxTransfer { get; set; } = 50000;

            [JsonProperty("Currency Symbol")]
            public string CurrencySymbol { get; set; } = "$";

            [JsonProperty("Show Balance On Respawn")]
            public bool ShowBalanceOnRespawn { get; set; } = true;
        }

        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>
            {
                ["Balance"] = "Your balance: {0}{1}",
                ["NoPermission"] = "You do not have permission to do that.",
                ["Usage"] = "Usage: {0}",
                ["PlayerNotFound"] = "Player '{0}' was not found.",
                ["SelfPay"] = "You cannot pay yourself.",
                ["InvalidAmount"] = "That is not a valid amount.",
                ["MaxTransfer"] = "The maximum single transfer is {0}{1}.",
                ["NotEnough"] = "You do not have enough money. Balance: {0}{1}",
                ["Paid"] = "You sent {0}{1} to {2}.",
                ["Received"] = "{0} sent you {1}{2}."
            }, this);
        }

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

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

        private void OnServerInitialized()
        {
            LoadData();
        }

        private void LoadData()
        {
            try
            {
                balances = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<string, long>>(DataFile)
                           ?? new Dictionary<string, long>();
            }
            catch
            {
                PrintWarning("Money data file is invalid, starting empty");
                balances = new Dictionary<string, long>();
            }
            dirty = false;
        }

        private void SaveData()
        {
            if (!dirty) return;
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, balances);
            dirty = false;
        }

        private void OnServerSave() => SaveData();

        private void Unload() => SaveData();

        private void OnPlayerConnected(BasePlayer player)
        {
            if (player == null) return;
            EnsureAccount(player.UserIDString);
        }

        private void OnPlayerRespawned(BasePlayer player)
        {
            if (player == null || !config.ShowBalanceOnRespawn) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse)) return;
            player.ChatMessage(Msg("Balance", player.UserIDString, config.CurrencySymbol, GetBalance(player.UserIDString)));
        }

        private void EnsureAccount(string userId)
        {
            if (!balances.ContainsKey(userId))
            {
                balances[userId] = config.StartingBalance;
                dirty = true;
            }
        }

        private long GetBalance(string userId)
        {
            long value;
            return balances.TryGetValue(userId, out value) ? value : config.StartingBalance;
        }

        private void AddBalance(string userId, long amount)
        {
            EnsureAccount(userId);
            balances[userId] = Math.Max(0, balances[userId] + amount);
            dirty = true;
        }

        private bool RemoveBalance(string userId, long amount)
        {
            long current = GetBalance(userId);
            if (current < amount) return false;
            AddBalance(userId, -amount);
            return true;
        }

        // Public API: other plugins call these with Plugin.Call
        public long GetBalance(ulong userId) => GetBalance(userId.ToString());

        public long Deposit(ulong userId, long amount)
        {
            if (amount <= 0) return GetBalance(userId);
            AddBalance(userId.ToString(), amount);
            return GetBalance(userId);
        }

        public bool Withdraw(ulong userId, long amount)
        {
            if (amount <= 0) return false;
            return RemoveBalance(userId.ToString(), amount);
        }

        [ChatCommand("balance")]
        private void CmdBalance(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            player.ChatMessage(Msg("Balance", player.UserIDString, config.CurrencySymbol, GetBalance(player.UserIDString)));
        }

        [ChatCommand("pay")]
        private void CmdPay(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermPay))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args.Length < 2)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString, "/pay <player|steamid> <amount>"));
                return;
            }

            BasePlayer target = FindPlayer(args[0]);
            if (target == null)
            {
                player.ChatMessage(Msg("PlayerNotFound", player.UserIDString, args[0]));
                return;
            }
            if (target == player)
            {
                player.ChatMessage(Msg("SelfPay", player.UserIDString));
                return;
            }

            long amount;
            if (!long.TryParse(args[1], out amount) || amount <= 0)
            {
                player.ChatMessage(Msg("InvalidAmount", player.UserIDString));
                return;
            }
            if (config.MaxTransfer > 0 && amount > config.MaxTransfer)
            {
                player.ChatMessage(Msg("MaxTransfer", player.UserIDString, config.CurrencySymbol, config.MaxTransfer));
                return;
            }
            if (GetBalance(player.UserIDString) < amount)
            {
                player.ChatMessage(Msg("NotEnough", player.UserIDString, config.CurrencySymbol, GetBalance(player.UserIDString)));
                return;
            }

            RemoveBalance(player.UserIDString, amount);
            AddBalance(target.UserIDString, amount);

            player.ChatMessage(Msg("Paid", player.UserIDString, config.CurrencySymbol, amount, target.displayName));
            target.ChatMessage(Msg("Received", target.UserIDString, player.displayName, config.CurrencySymbol, amount));
        }

        [ConsoleCommand("money.give")]
        private void CcmdGive(ConsoleSystem.Arg arg)
        {
            if (!IsAdminArg(arg)) return;
            if (arg.Args == null || arg.Args.Length < 2)
            {
                arg.ReplyWith("Usage: money.give <player|steamid> <amount>");
                return;
            }
            BasePlayer target = FindPlayer(arg.Args[0].ToString());
            if (target == null)
            {
                arg.ReplyWith($"Player '{arg.Args[0]}' not found");
                return;
            }
            long amount;
            if (!long.TryParse(arg.Args[1].ToString(), out amount) || amount <= 0)
            {
                arg.ReplyWith("Invalid amount");
                return;
            }
            AddBalance(target.UserIDString, amount);
            arg.ReplyWith($"{config.CurrencySymbol}{amount} added to {target.displayName}, new balance {GetBalance(target.UserIDString)}");
        }

        [ConsoleCommand("money.take")]
        private void CcmdTake(ConsoleSystem.Arg arg)
        {
            if (!IsAdminArg(arg)) return;
            if (arg.Args == null || arg.Args.Length < 2)
            {
                arg.ReplyWith("Usage: money.take <player|steamid> <amount>");
                return;
            }
            BasePlayer target = FindPlayer(arg.Args[0].ToString());
            if (target == null)
            {
                arg.ReplyWith($"Player '{arg.Args[0]}' not found");
                return;
            }
            long amount;
            if (!long.TryParse(arg.Args[1].ToString(), out amount) || amount <= 0)
            {
                arg.ReplyWith("Invalid amount");
                return;
            }
            long current = GetBalance(target.UserIDString);
            if (amount > current) amount = current;
            AddBalance(target.UserIDString, -amount);
            arg.ReplyWith($"{config.CurrencySymbol}{amount} taken from {target.displayName}, new balance {GetBalance(target.UserIDString)}");
        }

        [ConsoleCommand("money.balance")]
        private void CcmdShowBalance(ConsoleSystem.Arg arg)
        {
            if (!IsAdminArg(arg)) return;
            if (arg.Args == null || arg.Args.Length < 1)
            {
                arg.ReplyWith("Usage: money.balance <player|steamid>");
                return;
            }
            BasePlayer target = FindPlayer(arg.Args[0].ToString());
            if (target == null)
            {
                arg.ReplyWith($"Player '{arg.Args[0]}' not found");
                return;
            }
            arg.ReplyWith($"{target.displayName}'s balance: {config.CurrencySymbol}{GetBalance(target.UserIDString)}");
        }

        private bool IsAdminArg(ConsoleSystem.Arg arg)
        {
            if (arg == null || !arg.IsAdmin)
            {
                arg?.ReplyWith("You do not have permission to do that");
                return false;
            }
            return true;
        }

        private BasePlayer FindPlayer(string nameOrId)
        {
            if (string.IsNullOrEmpty(nameOrId)) return null;
            ulong id;
            if (ulong.TryParse(nameOrId, out id))
            {
                BasePlayer byId = BasePlayer.FindByID(id);
                if (byId != null) return byId;
            }
            return BasePlayer.FindAwakeOrSleeping(nameOrId);
        }
    }
}