Full example

using BepInEx;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using TechTree.Api;

namespace ExampleTechTreeMod;

[BepInPlugin(Guid, "Example Tech Tree Mod", "1.0.0")]
[BepInDependency(TechTreeApi.ModGuid)]
public sealed class Plugin : BasePlugin
{
    public const string Guid = "ExampleTechTreeMod";

    // Ids are the key in the save file: never change them after release.
    public const string BulkDiscount  = "ttexample.bulk_discount";
    public const string LoyalShoppers = "ttexample.loyal_shoppers";

    // One source for the effect strength: the text the player reads and the code
    // that pays out both come from here, so they cannot drift apart.
    public const float DiscountPerLevel = 0.05f;
    public const float BonusPerLevel    = 0.03f;

    internal static new ManualLogSource Log;

    public override void Load()
    {
        Log = base.Log;

        // One call, once. "Example" is the label of your sub-tab inside the Mods
        // tab, and it is the only thing you ever say about where your nodes go.
        var tree = TechTreeApi.ForPlugin(Guid, "Example");

        // MaxLevel 3 means Tech Tree draws three chained circles, not one, and the
        // player buys them top to bottom. 1200 x 1.8 prices them 1200 / 2160 / 3888.
        var bulk = tree.Register(new UpgradeDefinition
        {
            Id             = BulkDiscount,
            DisplayName    = "Bulk Discount",
            MaxLevel       = 3,
            BaseCost       = 1200,
            CostMultiplier = 1.8f,
            SortOrder      = 0,
            Icon           = UpgradeIcon.Builtin("truck"),

            // Called with the level, every time the hover card is drawn.
            DescribeLevel  = lvl => $"{lvl * DiscountPerLevel * 100:0}% back on supply costs",
        });

        // Register never throws - it runs inside YOUR Load, and an exception here
        // would abort YOUR plugin over a typo. Checking the result is the only way
        // to find out something went wrong.
        if (!bulk.Success) Log.LogError($"Bulk Discount refused: {bulk.Result}");

        var loyal = tree.Register(new UpgradeDefinition
        {
            Id             = LoyalShoppers,
            DisplayName    = "Loyal Shoppers",
            MaxLevel       = 2,
            BaseCost       = 2500,
            CostMultiplier = 2f,
            SortOrder      = 1,
            Icon           = UpgradeIcon.FromPng(IconData.Heart),
            DescribeLevel  = lvl => $"+{lvl * BonusPerLevel * 100:0}% on every sale",

            // The gate. Note what it does NOT need: any knowledge of the game's
            // internals. It asks the public API about another node, and that is
            // the whole dependency.
            IsUnlocked     = () => TechTreeApi.GetLevel(BulkDiscount) > 0,
            LockedReason   = () => "Buy Bulk Discount first",
            OnLevelChanged = lvl => Log.LogInfo($"Loyal Shoppers is now level {lvl}"),
        });

        if (!loyal.Success) Log.LogError($"Loyal Shoppers refused: {loyal.Result}");

        // Optional. Without this the English DisplayName is what every language
        // gets. The key is the one Tech Tree built from the id: "<id>.name".
        tree.AddTranslations("pt-BR", new Dictionary<string, string>
        {
            [BulkDiscount  + ".name"] = "Desconto por Volume",
            [LoyalShoppers + ".name"] = "Clientes Fiéis",
        });

        // The cashback is paid a beat after the purchase, and a Harmony patch has
        // no way to wait - so the delay lives in an injected MonoBehaviour.
        ClassInjector.RegisterTypeInIl2Cpp<CashbackScheduler>();
        CashbackScheduler.Create();

        // Nothing to do with Tech Tree: this installs the patch in Effects.cs,
        // which is where the levels above actually do something.
        var harmony = new Harmony(Guid);
        harmony.PatchAll(typeof(Plugin).Assembly);

        // Worth logging what actually got patched. A patch that fails to install
        // is silent otherwise: the node works, the effect never fires, and there
        // is nothing in the log pointing at the cause.
        var names = new List<string>();
        foreach (var m in harmony.GetPatchedMethods())
            names.Add($"{m.DeclaringType?.Name}.{m.Name}");
        Log.LogInfo($"Loaded. Applied {names.Count} Harmony patch(es): {string.Join(", ", names)}");
    }
}

using HarmonyLib;
using TechTree.Api;

namespace ExampleTechTreeMod;

// This file is the actual mod. Plugin.cs only draws buttons.
//
// It is a POSTFIX and a refund, not a Prefix that shrinks the bill. The obvious
// version does not work in this game - see the note under the code.
[HarmonyPatch(typeof(MoneyManager), nameof(MoneyManager.MoneyTransition))]
internal static class MoneyPatch
{
    // Our own refund goes through MoneyTransition too, which lands right back in
    // this postfix. Without this flag that is infinite recursion and a hung game.
    private static bool _refunding;

    private static void Postfix(float amount, MoneyManager.TransitionType type)
    {
        if (_refunding) return;

        float back = 0f;

        // Buying stock arrives NEGATIVE. Flipping the sign gives what the player
        // just paid, and we hand a slice of it back.
        if (type == MoneyManager.TransitionType.SUPPLY_COSTS && amount < 0f)
        {
            int lvl = TechTreeApi.GetLevel(Plugin.BulkDiscount);
            if (lvl > 0) back = -amount * Plugin.DiscountPerLevel * lvl;
        }
        // A sale arrives POSITIVE, so this one is a straight bonus on top.
        else if (type == MoneyManager.TransitionType.CHECKOUT_INCOME && amount > 0f)
        {
            int lvl = TechTreeApi.GetLevel(Plugin.LoyalShoppers);
            if (lvl > 0) back = amount * Plugin.BonusPerLevel * lvl;
        }

        // The game fires transactions with amount 0, and below a cent nothing
        // changes on screen.
        if (back < 0.01f) return;

        // Queued, not paid here: paying inside this postfix lands while the game
        // is still animating the money counter, and the refund gets swallowed.
        CashbackScheduler.Schedule(back, type);
    }

    // Called by the scheduler about a second later.
    internal static void Pay(float amount, MoneyManager.TransitionType type)
    {
        if (!MoneyManager.HasInstance) return;

        _refunding = true;
        try
        {
            // Same transaction type on purpose, so the refund lands under the
            // same heading in the end-of-day statistics.
            MoneyManager.Instance.MoneyTransition(amount, type, true);
        }
        catch (System.Exception e)
        {
            Plugin.Log?.LogWarning($"cashback failed: {e.Message}");
        }
        finally
        {
            // Must always run: a stuck flag kills the effect silently until the
            // game restarts.
            _refunding = false;
        }
    }
}

internal sealed class CashbackScheduler : MonoBehaviour
{
    // Every MonoBehaviour injected into IL2CPP needs this constructor. Without it
    // the type registers but the runtime cannot build an instance.
    public CashbackScheduler(IntPtr ptr) : base(ptr) { }

    internal const float Delay = 1.25f;

    private sealed class Pending
    {
        public float At;
        public float Amount;
        public MoneyManager.TransitionType Type;
    }

    // A queue, not a single pending value: the player can order twice in a row,
    // or a sale can land mid-wait. One variable would drop the first one.
    private static readonly List<Pending> Queue = new();
    private static CashbackScheduler _instance;

    internal static void Create()
    {
        if (_instance != null) return;

        var host = new GameObject("ExampleCashbackScheduler");
        // Without this the object dies on the menu -> store scene change and
        // Update silently stops running.
        UnityEngine.Object.DontDestroyOnLoad(host);
        host.hideFlags = HideFlags.HideAndDontSave;
        _instance = host.AddComponent<CashbackScheduler>();
    }

    internal static void Schedule(float amount, MoneyManager.TransitionType type)
    {
        if (amount < 0.01f) return;
        // unscaledTime: if anything pauses or slows the game, the payment still
        // goes out instead of getting stuck in the queue.
        Queue.Add(new Pending { At = Time.unscaledTime + Delay, Amount = amount, Type = type });
    }

    private void Update()
    {
        // This runs 60+ times a second for the whole session and almost always
        // has nothing to do.
        if (Queue.Count == 0) return;

        float now = Time.unscaledTime;

        // Backwards, because entries are removed while walking the list. Forwards,
        // removing index 0 shifts everything down and the loop skips an item.
        for (int i = Queue.Count - 1; i >= 0; i--)
        {
            var p = Queue[i];
            if (now < p.At) continue;

            // Removed before paying: if the payment throws, it does not sit in
            // the queue retrying every frame forever.
            Queue.RemoveAt(i);
            MoneyPatch.Pay(p.Amount, p.Type);
        }
    }
}

using System;

namespace ExampleTechTreeMod;

internal static class IconData
{
    private static byte[] _bytes;

    public static byte[] Heart => _bytes ??= Convert.FromBase64String(Base64);

    // White artwork with alpha: Tech Tree tints the icon through Image.color,
    // so a coloured PNG would come out multiplied and wrong.
    private const string Base64 =
        "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAB9klEQVR42u3cUW7DMAwE0azR" +
        "...";
}