RevFramework: Currency & Economy

💸 RevFramework — Currency & Economy

If something fails, it tells you why.

That's the rule every RevFramework system is built around.

Explicit APIs. Deterministic behaviour. Real failure codes. No hidden state. No guesswork.

RevFramework gives you production-ready Currency and Economy systems — with the documentation, testing, and debugging infrastructure to match.

⚠️ Requires C# scripting knowledge. This is not a no-code tool or drag-and-drop economy kit.

--------------------------------------------------------

🧩 What You Actually Get

Two runtime systems built for developers who need financial infrastructure they can trust:

💸 Currency — credit, debit, transfer, escrow, exchange, rollback-safe transactions, authority-aware mutations

🧠 Economy — shop services, crafting cost integration, reward distribution, atomic item delivery, rollback on failure

Both systems work independently. Neither requires the other.

This is not a shop template. It's financial infrastructure for gameplay systems.

Plus the infrastructure most assets skip:

• 15 YouTube tutorials
• Public MkDocs documentation site — freely accessible before you buy. Read it before you decide.
• Interactive teachable panels that call real APIs and show live results
• Folder-level READMEs across the entire codebase

The full documentation site is publicly accessible — no purchase required. Read it before you decide.

📚 Documentation

https://revandrab.github.io/RevFramework/SKUs/CurrencyEconomy/

--------------------------------------------------------

🔥 Why It's Different

Most Unity economy assets give you UI and hope the numbers add up.

RevFramework gives you correctness.

Instead of fragile flows like "deduct currency, give item, hope nothing breaks" — every operation in RevFramework is deterministic, rollback-safe, and explicit about what happened and why.

If a transaction fails, you know why. If rollback occurs, you can trace it. If authority validation fails, it's explicit.

There are no black boxes here.

--------------------------------------------------------

💸 Currency System

A deterministic currency pipeline with overflow-safe execution and rollback-safe transaction staging.

• Credit, debit, and transfer operations
• Overflow-safe execution
• Result-based APIs — every operation returns a CurOpResult with success flag, reason code, and message
• Policy enforcement
• Audit metadata support
• Authority-aware mutations with clear rejection codes
• Escrow and hold systems with commit, release, and TTL expiry
• Rollback-safe transaction staging
• Request ID replay protection for safe multiplayer transaction flows

--------------------------------------------------------

💱 Exchange & Transactions

• Currency exchange rates with fees and limits
• Quote and execute workflows
• Deterministic rounding
• Rollback-safe execution
• Atomic batch operations
• Structured transaction logs and audit buffers
• Event hooks
• Async and coroutine support

--------------------------------------------------------

🧠 Economy Layer

Built on top of the Currency system. Handles the flows where currency meets gameplay.

Shop Services

• Buy and sell pipelines
• Atomic item delivery
• Rollback on failure
• Deterministic transaction flow

Crafting Integration

• Currency and item cost bundles
• Refund and restore support
• Deterministic crafting costs

Reward Services

• Currency payouts
• Reward distribution flows
• Explicit failure handling

Every operation returns a result code, reason, and message — ideal for debugging, analytics, multiplayer logging, and validation.

--------------------------------------------------------

🌐 Multiplayer & Networking

RevFramework is netcode-agnostic by design.

Authority binders let you gate mutations through your own ownership and permission rules — whether that's NGO, Mirror, Photon, Fusion, or a custom solution.

Replication, prediction, and rollback are yours to implement.

We give you the rules — your netcode drives the simulation.

--------------------------------------------------------

🎓 Learning Infrastructure

This is where RevFramework is genuinely different from other assets.

Teachable Panels

Interactive panels built directly into the framework. Each one:

• Calls real public APIs — no shortcuts, no internals
• Shows live transaction results and reason codes in the scene
• Demonstrates rollback behaviour and failure paths directly
• Proves the public API works by being a hostile consumer of it

If the teachable panels compile and run correctly, the public API works. Not just documented — actually usable.

Documentation

• Public MkDocs site — freely accessible before you buy
• Every system has: Overview, Mental Model, Integration Surfaces, Public API, System Guarantees Matrix, Testing Philosophy, System Boundaries, and FAQ
• 400+ folder-level READMEs explaining intent and reasoning, not just "this does this"
• Eight dedicated onboarding documents per system

Videos

• 15 YouTube tutorials covering every teachable panel
• 4 core onboarding videos covering scope, teachables, documentation, and modularity
• Each video shows real behaviour in a real scene

--------------------------------------------------------

🧪 Testing & Reliability

RevFramework testswith 1600+ tests across the full framework.

The goal was never coverage percentages.

The goal was predictable architectural behaviour.

Hostile Consumer Tests

Validate the public API the way a real project would — through supported surfaces only, with no access to internals. If these pass, the contract holds.

Internal Truth Tests

Lock down framework assumptions so future refactors don't silently change behaviour. Transaction rollback paths, authority rejection, audit semantics, escrow behaviour.

PlayMode Smoke Tests

Catch Unity lifecycle failures that EditMode tests can't reach.

Test assemblies are not shipped with the framework. You get clean runtime, editor, sample, and teaching assemblies — no NUnit dependencies, no compile overhead.

--------------------------------------------------------

🎮 Built for Both 2D and 3D

All systems are fully dimension-agnostic.

• No physics assumptions
• No controller requirements
• No camera dependencies
• Works in any genre or project structure

--------------------------------------------------------

🧱 What's Included

Runtime Systems

• Currency core
• Escrow and exchange systems
• Economy services
• Shop services
• Reward systems

Learning & Debugging

• Teachable panels
• Demo scenes
• Reference UI examples
• Example integrations

Documentation

• Full MkDocs site
• Folder-level READMEs
• 15 YouTube tutorials

--------------------------------------------------------

🚫 What This Is Not

• Not a shop UI prefab pack
• Not a visual economy editor
• Not a networking implementation
• Not a progression system
• Not a drag-and-drop economy builder
• Not a locked UI workflow

RevFramework is financial infrastructure for gameplay systems — not a game template.

--------------------------------------------------------

🎨 UI

Reference UI is included for Currency and Economy.

It shows you how to talk to the systems correctly.

It is not your game UI.

Build your own using Unity Canvas, UI Toolkit, or whatever fits your project. RevFramework puts no constraints on how you present its systems to players.

--------------------------------------------------------

🔗 Other RevFramework Modules

• Inventory, Pickups & Crafting
• Health & Status Effects
• RevFramework Complete — all systems together

All modules share the same architecture, documentation standard, and testing philosophy. Each one works independently or integrates cleanly with the others.

--------------------------------------------------------

🧑‍💻 Who This Is For

RevFramework is for developers who:

• Are comfortable writing C#
• Need deterministic financial systems they can trust
• Care about rollback safety and authority gating
• Want debuggable economy logic with real failure reasons
• Prefer extending frameworks instead of rewriting them

If you want a no-code solution or a drag-and-drop economy builder, this is not the right package. That's not a criticism — it's just a different tool for a different job.

--------------------------------------------------------

🙋 Core Philosophy

Every system. Every operation. Every failure.

If something fails, it tells you why.

That's not a feature. That's the foundation everything else is built on.

If you value clarity, structure, and real engineering — this framework will feel like home.