LlamaEconomy

Compatible API Versions: 1.0.0

Contributors: LlamaDevelopment

LlamaEconomy NG 2.3.5 — Doncoin Edition

A customizable multi-currency economy system for Nukkit servers.

LlamaEconomy NG allows you to create and manage custom currencies, transfer money between players, configure economy commands, track player statistics and integrate other plugins through a Java API.

The plugin includes two default currencies, money and doncoin, and supports creating additional currencies without a predefined limit.

Each currency can be enabled or disabled independently without deleting player balances.

LlamaEconomy NG supports YAML-based file storage, SQLite, MySQL and MongoDB, and provides optional compatibility bridges for EconomyAPI and BladeEconomy.

Features:

Create your own custom currencies
Create multiple currencies with individual settings
Enable or disable each currency independently
Keep player balances when a currency is disabled
Configure currency names, symbols and decimal precision
Set individual starting balances and maximum limits
Manage player balances through commands
Transfer money between players
Transfer different currencies independently
View your own balance and other players' balances
Display currency leaderboards
Display the total money supply for each currency
Track player kills, deaths, K/D ratio and playtime
UUID-based player accounts
Offline player account support
YAML, SQLite, MySQL and MongoDB storage options
Configurable economy rules
Customizable commands and aliases
Customizable permissions
Enable or disable individual commands
Customizable messages and currency formatting
Russian and English language support
Additional custom language files
PlaceholderAPI integration
Developer API for other plugins
Economy transaction events
Import balances from older economy plugins
EconomyAPI compatibility bridge
BladeEconomy compatibility bridge
Lightweight and Linux database builds

Multi-Currency System:

LlamaEconomy NG allows you to create separate currencies for different parts of your server.

For example:

Survival money
Doncoin
Premium currencies
Event points
Tokens
Crystals
Custom server currencies

Every currency has its own configuration, balances and maximum limits.

You can create a currency using an in-game command or configure it through currencies.yml.

Default Currencies:

The plugin includes two currencies by default.

money

Currency ID: money
Symbol: $
Decimal precision: 2
Starting balance: 1000.00
Maximum balance: 9999999999.00
Enabled by default

doncoin

Currency ID: doncoin
Symbol: DC
Decimal precision: 0
Starting balance: 10
Maximum balance: 999999999
Enabled by default

The default values can be changed in currencies.yml.

Currency Configuration:

Code:

Currencies:
  money:
    Symbol: "$"
    Decimals: 2
    Starting: "1000.00"
    Maximum: "9999999999.00"
    Enabled: true

  doncoin:
    Symbol: "DC"
    Decimals: 0
    Starting: "10"
    Maximum: "999999999"
    Enabled: true

Currency Features:

Custom currency identifiers
Custom symbols
Decimal precision from 0 to 6 digits
Custom starting balances
Maximum balance limits
Independent player wallets
Independent leaderboards
Individual enable/disable settings
Currency management commands
Developer API support

Currency IDs use lowercase letters, numbers and underscores, and must begin with a letter.

A currency can be disabled without removing its balances from storage.

When disabled, normal balance operations for that currency are rejected. Existing data remains stored.

Once enabled again, player balances become available.

Enable or Disable Currencies:

Code:

/currency set doncoin enabled false
/currency set doncoin enabled true

/currency set money enabled false
/currency set money enabled true

You can also change the Enabled setting in currencies.yml.

Important:

Disabling money also prevents normal EconomyAPI bridge operations that depend on the primary money currency.

For EconomyAPI compatibility, keep money enabled.

The plugin does not allow changing the decimal precision of an initialized currency because doing so could change the meaning of stored balances.

Create Custom Currencies:

Example:

Code:

/currency create crystals ✦ 0 0 1000000
/currency create tokens T 0 100 100000
/currency create rubles ₽ 2 500 999999999

You can then manage these currencies using regular economy commands.

Code:

/money Steve crystals
/pay Steve 100 crystals
/givemoney Steve 500 rubles
/takemoney Steve 20 tokens
/topmoney 1 crystals

Custom currencies are also available through the Developer API.

Money Management:

LlamaEconomy NG provides commands for managing player balances.

Check your balance
Check another player's balance
Add money to a player
Remove money from a player
Set a player's balance
Transfer money between players
Choose the currency for each transaction
Configure transfer limits
Configure recipient notifications
Configure administrative operations
Prevent transfers to the same account
Reject transactions with insufficient funds
Reject amounts exceeding the maximum balance
Validate transaction amounts and decimal precision

Player balances are internally represented using integer minor units.

The plugin validates balance changes before committing them to storage.

Supported transfer operations update the sender and recipient through the same ledger update.

Player Statistics:

LlamaEconomy NG also includes a player statistics system.

Track player kills
Track player deaths
Calculate player K/D ratio
Track player playtime
Store player statistics
View your own statistics
View another player's statistics
Access player statistics through the Developer API
Use statistics with PlaceholderAPI
Configure periodic statistics checkpoints

Statistics are stored alongside player account information.

The playtime checkpoint interval can be configured through Runtime.StatsCheckpointMinutes.

Leaderboards:

Players can view the richest accounts for a selected currency.

Display the richest players
Separate leaderboards for different currencies
Leaderboard pagination
Customizable entries per page
Optional total money supply display
Customizable leaderboard messages
Enable or disable the leaderboard feature

Example:

Code:

/topmoney
/topmoney 2
/topmoney 1 doncoin
/topmoney 1 crystals

The default number of entries per page is 5.

You can change this using Rules.TopPageSize.

Storage Systems:

LlamaEconomy NG supports four storage providers.

YAML mode - Local file-based storage
SQLite - Local SQL database
MySQL - External SQL database
MongoDB - External document database

The storage provider is selected in config.yml.

Code:

Provider: "yaml"

Available settings:

Code:

yaml
sqlite
mysql
mongodb

The default YAML mode uses an internal ledger.properties file to store balances.

MySQL Configuration:

Code:

MySql:
  Host: "127.0.0.1"
  Port: "3306"
  User: "root"
  Password: ""
  Database: "llamaeconomy"

MongoDB Configuration:

Code:

MongoDB:
  Uri: "mongodb://127.0.0.1:27017"
  Database: "llamaeconomy"

Database connection settings must be configured before enabling an external storage provider.

Lightweight Builds:

LlamaEconomy NG 2.3.5 is available in two versions.

LITE Edition — approximately 2.36 MB

YAML storage
MongoDB storage
Multi-currency system
Doncoin support
All economy commands
Statistics
Developer API
Language system
PlaceholderAPI integration

Recommended for servers that use local file storage or MongoDB.

SQLite and MySQL JDBC drivers are not bundled in this version.

Linux All-DB Edition — approximately 9.35 MB

YAML storage
SQLite storage
MySQL storage
MongoDB storage
All features from the LITE Edition
SQLite native libraries for supported Linux systems

The Linux build targets Linux x86_64 and aarch64 environments, including the packaged glibc and musl SQLite variants.

It is not intended as a universal Windows or macOS build.

Important:

Install only one main LlamaEconomy JAR.

Do not install both LITE and Linux editions at the same time.

Player Accounts and Data Protection:

UUID-based player wallets
Player name association
Protection against account ownership conflicts
Automatic account registration
Configurable starting balances
Maximum balance validation
Transaction amount validation
Decimal precision validation
Protection against negative transaction amounts
Protection against numeric overflow
Transaction cancellation support
Storage error reporting
Currency schema validation
Detection of conflicting migration data

The plugin supports concurrent-safe storage update mechanisms for its ledger operations.

Money-changing API operations must be performed on the Nukkit main thread.

Data Migration:

LlamaEconomy NG supports importing account data from older economy plugins.

Supported migration sources include:

Legacy LlamaEconomy YAML balances
Legacy LlamaEconomy MySQL balances
Legacy LlamaEconomy MongoDB balances
EconomyAPI Money.yml
BladeEconomy SQLite data
BladeEconomy coins
BladeEconomy amethysts
BladeEconomy player statistics

Amethysts to Doncoin Migration:

Starting with version 2.3.5, doncoin replaces the previous default amethysts currency.

When upgrading an older installation, the plugin can migrate existing amethysts balances to doncoin.

Preserves existing balances
Preserves currency configuration values
Creates backups for supported local files
Rejects conflicting old and new balances
Does not overwrite conflicting accounts
Does not create a second independent amethysts wallet

The migration is performed only when the existing configuration matches the supported legacy format.

Always back up your economy data before upgrading.

External Economy Migration:

Optional import paths can be configured using:

Code:

Migration:
  EconomyApiMoneyFile: ""
  BladeSqliteFile: ""

External imports are intended for a new empty ledger.

Only one external source can be selected at a time.

The original import files are not deleted.

Configuration Files:

The plugin uses several configuration files.

config.yml

Main economy configuration.

Storage provider
Database connections
Language
Economy features
Transaction rules
Permissions
Command names
Command aliases
Command descriptions
Command usage messages
Message formatting
Statistics checkpoint interval
Migration configuration

currencies.yml

Currency definitions.

Currency IDs
Currency symbols
Decimal precision
Starting balances
Maximum balances
Enable/disable status

messages.yml

Message customization and language overrides.

lang_ru.yml

Russian localization.

lang_en.yml

English localization.

Additional language files can be added using the lang_CODE.yml format.

Language files use normal readable UTF-8 YAML.

No Unicode escape sequences or Java Properties language files are required.

Full Command Customization:

All command groups can be configured independently.

Available settings:

Enabled - Enable or disable a command
PlayerOnly - Restrict execution to players
Name - Change the command name
Aliases - Customize command aliases
Description - Change the description
Usage - Customize the usage message
Permission - Set a permission node

Example:

Code:

Commands:
  Pay:
    Enabled: true
    PlayerOnly: false
    Name: "pay"
    Aliases:
      - "balpay"
    Description: "Transfer money"
    Usage: "/pay <player> <amount> [currency]"
    Permission: ""

You can rename commands and create additional aliases.

Command names and aliases are checked for conflicts during registration.

The usage message is customizable, but the command argument order is defined by the command implementation.

Economy Rules:

The Rules section provides additional configuration.

MaxCurrencies - Maximum number of currencies
MinimumTransfer - Minimum transfer amount
TopPageSize - Leaderboard entries per page
ShowTopTotal - Show total currency balance
NotifyRecipient - Send transfer notifications
AllowZeroAdminOperations - Allow zero-value administrative operations

Example:

Code:

Rules:
  MaxCurrencies: 0
  MinimumTransfer: "0.01"
  TopPageSize: 5
  ShowTopTotal: true
  NotifyRecipient: true
  AllowZeroAdminOperations: true

MaxCurrencies: 0 means no configured currency-count limit.

Feature Configuration:

The Features section allows you to enable or disable economy systems.

Code:

Features:
  Transfers: true
  AdminOperations: true
  Leaderboard: true
  Statistics: true
  CurrencyCreate: true
  CurrencyEdit: true

Currency Formatting:

The Display section controls how balances and messages are shown.

Available settings:

Message prefix
Enable or disable the prefix
Show or hide the prefix on leaderboards
Currency symbol position
Digit grouping
Thousands separator
Decimal separator

Example:

Code:

Display:
  PrefixEnabled: true
  PrefixTop: false
  Prefix: ""
  SymbolPosition: "before"
  GroupDigits: false
  ThousandsSeparator: " "
  DecimalSeparator: "."

Commands & Permissions:

The following are the default command names and aliases.

All command names, aliases and command permissions can be changed through config.yml.

Balance Commands:

money
Usage: /money [Player] [Currency]
Description: View a player's balance
Aliases: mymoney, getmoney, bal, balance
Permission: No command permission by default
seemoney
Usage: /seemoney <Player> [Currency]
Description: View another player's balance
Permission: llamaeconomy.seemoney
wallet
Usage: /wallet <Currency> [Player]
Description: View the balance of a selected currency
Aliases: balcurrency
Permission: No command permission by default

Viewing another player's balance is also checked against the ViewOthers permission setting.

Transfer Commands:

pay
Usage: /pay <Player> <Amount> [Currency]
Description: Transfer money to another player
Aliases: balpay
Permission: No command permission by default
Player-only operation
paycurrency
Usage: /paycurrency <Player> <Currency> <Amount>
Description: Transfer a specific currency
Aliases: payc
Permission: No command permission by default
Player-only operation

Administrative Commands:

addmoney
Usage: /addmoney <Player> <Amount> [Currency]
Description: Add money to a player
Aliases: givemoney, baladd, deposit
Permission: llamaeconomy.addmoney
reducemoney
Usage: /reducemoney <Player> <Amount> [Currency]
Description: Remove money from a player
Aliases: takemoney, baltake, withdraw
Permission: llamaeconomy.reducemoney
setmoney
Usage: /setmoney <Player> <Amount> [Currency]
Description: Set a player's balance
Aliases: balset, setbal, setbalance
Permission: llamaeconomy.setmoney

Leaderboard Commands:

topmoney
Usage: /topmoney [Page] [Currency]
Description: Display the richest players
Aliases: baltop, balancetop
Permission: No command permission by default

Currency Commands:

currency
Usage: /currency list
Description: Display available currencies
currency
Usage: /currency info <Currency>
Description: Display currency information
currency
Usage: /currency create <ID> <Symbol> <Decimals> <Starting> <Maximum>
Description: Create a custom currency
Permission: llamaeconomy.currency.admin
currency
Usage: /currency set <ID> <symbol|starting|maximum|enabled> <Value>
Description: Update an existing currency
Permission: llamaeconomy.currency.admin

Alias: currencies

Currency Enable/Disable Examples:

Code:

/currency set doncoin enabled false
/currency set doncoin enabled true
/currency set money enabled false
/currency set money enabled true

Statistics Commands:

ecostats
Usage: /ecostats [Player]
Description: View player kills, deaths, K/D ratio and playtime
Permission: llamaeconomy.stats

Language Commands:

ecolang
Usage: /ecolang <Language>
Description: Change the active economy language
Aliases: economylang, setlang
Permission: llamaeconomy.language

Reload Commands:

lecoreload
Usage: /lecoreload
Description: Reload command configuration, permissions, economy rules, formatting and languages
Aliases: lreload, ecoreload
Permission: llamaeconomy.reload

Currency definitions and storage providers require a server restart when changed manually.

Default Permissions:

llamaeconomy.setmoney - OP
llamaeconomy.addmoney - OP
llamaeconomy.reducemoney - OP
llamaeconomy.reload - OP
llamaeconomy.currency.admin - OP
llamaeconomy.language - OP
llamaeconomy.seemoney - Everyone
llamaeconomy.stats - Everyone

Additional permissions used for viewing other players' data can be configured in config.yml.

PlaceholderAPI Integration:

LlamaEconomy NG provides optional integration with compatible Nukkit PlaceholderAPI versions.

Currency placeholders use the currency ID.

Examples:

Code:

llama_money
llama_money_raw

llama_doncoin
llama_doncoin_raw

llama_crystals
llama_crystals_raw

Formatted placeholders return the configured display format.

Raw placeholders return numeric values.

Statistics Placeholders:

Code:

llama_kills
llama_deaths
llama_kd
llama_playtime

PlaceholderAPI is optional.

The economy can run without it.

Developer API:

LlamaEconomy NG provides a Java API for other Nukkit-MOT plugins.

Developers can access:

Player accounts
Player balances
Custom currency balances
Balance changes
Currency transfers
UUID wallet operations
Currency information
Formatted currency values
Maximum balance limits
Default balances
Server-wide currency totals
Player kills and deaths
Player playtime
K/D ratio
Scoreboard-friendly values

The API also preserves the supported legacy LlamaEconomy methods for the primary currency.

Local Developer API Integration:

You can connect LlamaEconomy NG directly to your Java plugin.

No external web API is required.

The economy JAR is used as a compile-time dependency, while the main LlamaEconomy plugin runs on the Minecraft server.

1. Download the API JAR

Download one of the main LlamaEconomy NG JAR files.

Recommended for development:

Code:

LlamaEconomy-NG-2.3.5-Doncoin-LITE.jar

You do not need to install EconomyAPI or BladeEconomy bridges when using the native LlamaEconomy API.

2. Connect the JAR locally using Maven

Create a libs folder inside your Java project.

Put the LlamaEconomy JAR inside it.

Install the JAR into your local Maven repository:

Code:

mvn install:install-file -Dfile=libs/LlamaEconomy-NG-2.3.5-Doncoin-LITE.jar -DgroupId=net.lldv.llamaeconomy -DartifactId=LlamaEconomy-MOT-NG -Dversion=2.3.5 -Dpackaging=jar

Add the dependency to your pom.xml:

Code:

<dependency>
    <groupId>net.lldv.llamaeconomy</groupId>
    <artifactId>LlamaEconomy-MOT-NG</artifactId>
    <version>2.3.5</version>
    <scope>provided</scope>
</dependency>

The provided scope tells Maven that LlamaEconomy is already available on the server.

Do not package another copy of LlamaEconomy inside your own plugin.

3. Connect the JAR using Gradle

Put the JAR inside your project's libs folder.

For a Groovy build.gradle file, add:

Code:

dependencies {
    compileOnly files("libs/LlamaEconomy-NG-2.3.5-Doncoin-LITE.jar")
}

Reload your Gradle project.

4. Connect the JAR manually in IntelliJ IDEA

Open your Java project.
Open Project Structure.
Select Modules.
Open Dependencies.
Click the plus button.
Select JARs or Directories.
Choose the LlamaEconomy NG JAR.
Apply the changes.

This allows IntelliJ IDEA to resolve the LlamaEconomy Java classes.

For Maven or Gradle projects, using the build tool is recommended instead.

5. Add the plugin dependency

Open your plugin.yml and add:

Code:

depend:
  - LlamaEconomy

The plugin name is LlamaEconomy, even though the distribution is called LlamaEconomy NG.

This ensures that Nukkit loads LlamaEconomy before your plugin.

6. Access the API

Import the API classes:

Java:

import net.lldv.llamaeconomy.LlamaEconomy;
import net.lldv.llamaeconomy.components.api.API;

Get the API instance:

Java:

API economy = LlamaEconomy.getAPI();

Call this only after LlamaEconomy has successfully initialized.

7. Check whether the economy is ready

Example:

Java:

import cn.nukkit.plugin.Plugin;
import net.lldv.llamaeconomy.LlamaEconomy;
import net.lldv.llamaeconomy.components.api.API;

Plugin plugin = getServer()
        .getPluginManager()
        .getPlugin("LlamaEconomy");

if (!(plugin instanceof LlamaEconomy llama)
        || !llama.isReady()) {
    getLogger().error("LlamaEconomy is not ready!");
    return;
}

API economy = LlamaEconomy.getAPI();

8. Get a player's balance

Java:

double balance = economy.getMoney(player);

To get the balance of a custom currency:

Java:

double doncoin = economy.getBalance(
    player.getUniqueId(),
    "doncoin"
);

You can also get a formatted value:

Java:

String formatted = economy.getFormattedMoney(
    player.getName(),
    "doncoin"
);

9. Add money to a player

For the primary currency:

Java:

economy.addMoney(player, 100);

For a custom currency:

Java:

import net.lldv.llamaeconomy.next.Ledger;

Ledger.Result result = economy.changeBalance(
    player.getName(),
    "doncoin",
    Ledger.Action.ADD,
    "25"
);

10. Remove money from a player

For the primary currency:

Java:

economy.reduceMoney(player, 50);

For doncoin:

Java:

Ledger.Result result = economy.changeBalance(
    player.getName(),
    "doncoin",
    Ledger.Action.TAKE,
    "10"
);

11. Set a player's balance

For the primary currency:

Java:

economy.setMoney(player, 500);

For doncoin:

Java:

Ledger.Result result = economy.changeBalance(
    player.getName(),
    "doncoin",
    Ledger.Action.SET,
    "100"
);

12. Transfer money between players

LlamaEconomy provides a direct transfer method.

Example using UUIDs:

Java:

import net.lldv.llamaeconomy.next.Ledger;

Ledger.Result result = economy.transfer(
    sender.getUniqueId(),
    receiver.getUniqueId(),
    "money",
    "100"
);

if (result == Ledger.Result.OK) {
    sender.sendMessage("Transfer successful!");
}

Transfer doncoin:

Java:

Ledger.Result result = economy.transfer(
    sender.getUniqueId(),
    receiver.getUniqueId(),
    "doncoin",
    "5"
);

You can replace doncoin with the ID of any enabled custom currency.

13. Check transaction results

The Ledger.Result enum provides operation results.

Java:

Ledger.Result.OK
Ledger.Result.INVALID
Ledger.Result.NOT_FOUND
Ledger.Result.INSUFFICIENT
Ledger.Result.EXCEEDS_MAX
Ledger.Result.SAME_ACCOUNT
Ledger.Result.CANCELLED

Example:

Java:

Ledger.Result result = economy.transfer(
    sender.getUniqueId(),
    receiver.getUniqueId(),
    "doncoin",
    "5"
);

switch (result) {
    case OK:
        sender.sendMessage("Payment successful!");
        break;

    case INSUFFICIENT:
        sender.sendMessage("Not enough doncoin!");
        break;

    case EXCEEDS_MAX:
        sender.sendMessage("Balance limit exceeded!");
        break;

    default:
        sender.sendMessage("Payment failed!");
        break;
}

Invalid inputs or storage failures can also raise exceptions. Handle them appropriately in your plugin.

14. Check whether a player has enough money

Java:

boolean enough = economy.hasEnough(
    player.getName(),
    "doncoin",
    "50"
);

15. Get available currencies

Java:

import net.lldv.llamaeconomy.next.Currency;

for (Currency currency : economy.getCurrencies()) {
    String id = currency.id;
    String symbol = currency.symbol;
    boolean enabled = currency.enabled;
}

You can use these values to create your own currency menus and interfaces.

16. Get currency limits and settings

Java:

double max = economy.getMaxMoney("doncoin");

double starting = economy.getDefaultMoney("doncoin");

String symbol = economy.getMonetaryUnit("doncoin");

17. Get the total money supply

Java:

double total = economy.getTotalMoney("money");

For doncoin:

Java:

double totalDoncoin = economy.getTotalMoney("doncoin");

18. Get player statistics

Java:

long kills = economy.getKills(player.getName());

long deaths = economy.getDeaths(player.getName());

long playtime = economy.getPlaytimeSeconds(
    player.getName()
);

double kd = economy.getKDRatio(player.getName());

Formatted statistics are also available:

Java:

String stats = economy.getFormattedStats(
    player.getName()
);

19. Get scoreboard values

Java:

String kills = economy.getKillsForScoreboard(
    player.getName()
);

String deaths = economy.getDeathsForScoreboard(
    player.getName()
);

String playtime = economy.getPlaytimeForScoreboard(
    player.getName()
);

Important API Notes:

LlamaEconomy NG must be installed and enabled on the server
Add LlamaEconomy as a dependency in plugin.yml
Use the JAR as a compile-time dependency
Do not bundle LlamaEconomy inside your plugin
Use Java 17 or a compatible newer version
Money-changing operations must run on the Nukkit main thread
Check whether the economy has initialized
Check transaction results
Use existing currency IDs
Disabled currencies cannot be used for normal transactions
Use UUID-based methods when possible
Handle invalid amounts and storage exceptions

Economy Events:

LlamaEconomy NG provides events for integration with other plugins.

Available events include:

CurrencyTransactionEvent
WalletCreateEvent
SetMoneyEvent
AddMoneyEvent
ReduceMoneyEvent
PlayerSetMoneyEvent
PlayerAddMoneyEvent
PlayerReduceMoneyEvent
PlayerPayMoneyEvent

CurrencyTransactionEvent can be cancelled by another plugin before a balance change is committed.

WalletCreateEvent can also be cancelled and supports adjusting the initial primary-currency amount.

This allows developers to implement custom rules for wallet creation and economy transactions.

EconomyAPI Compatibility Bridge:

An optional compatibility bridge is available for plugins developed against EconomyAPI.

The bridge exposes supported EconomyAPI classes and redirects economy operations to LlamaEconomy NG.

Supported functionality includes:

Balance retrieval
Money addition
Money reduction
Balance setting
Economy events
Account creation integration
EconomyAPI message support
Shared economy balances

The bridge uses LlamaEconomy's primary money currency.

It does not create a separate database.

Installation:

Install LlamaEconomy NG.
Place the EconomyAPI Bridge JAR in the plugins folder.
Remove the original EconomyAPI plugin.
Start the server.

Do not install the original EconomyAPI together with the bridge.

The bridge provides supported API compatibility, but plugins relying on custom EconomyAPI providers or undocumented internals may require additional work.

BladeEconomy Compatibility Bridge:

An optional BladeEconomy bridge is also available.

It exposes supported BladeEconomy API classes through LlamaEconomy NG.

Supported functionality includes:

Coins API
Amethysts API compatibility
Player balance operations
Money transfers
Player statistics
Kills and deaths
Playtime
K/D ratio
Scoreboard formatting methods
UUID-based account operations

Doncoin Compatibility:

The original BladeEconomy API uses coins and amethysts.

LlamaEconomy NG 2.3.5 replaces the default amethysts currency with doncoin.

For compatibility, the bridge keeps the original amethysts Java method names and maps their operations to doncoin.

Example bridge configuration:

Code:

CoinsCurrency: "money"
AmethystsCurrency: "doncoin"

This allows plugins built for the original BladeEconomy API to use LlamaEconomy NG wallets.

The bridge does not create a separate amethysts currency.

Installation:

Install LlamaEconomy NG.
Install the BladeEconomy compatibility bridge.
Remove the original BladeEconomy plugin.
Configure currency mappings if necessary.
Start the server.

Plugins that depend directly on the original BladeEconomy database implementation may not be fully compatible.

How to install LlamaEconomy NG?

Download the preferred LlamaEconomy NG JAR.
Stop your Nukkit-MOT server.
Place the JAR inside the plugins folder.
Make sure no older LlamaEconomy JAR is installed.
Start your server.
Open plugins/LlamaEconomy/config.yml.
Select your storage provider.
Configure your currencies in currencies.yml.
Configure commands, permissions and economy rules.
Edit messages.yml or the language files if necessary.
Restart your server after manual changes to currency definitions or the storage provider.
Install optional compatibility bridges only if needed.
And have fun using LlamaEconomy NG!

Requirements:

Nukkit-MOT
Java 17 or newer

PlaceholderAPI is optional.

EconomyAPI and BladeEconomy compatibility bridges are optional.

External database servers are only required when using the corresponding storage providers.

Building from Source:

The Java source project includes Maven configuration.

To build the lightweight edition:

Code:

mvn package

To build the Linux database edition:

Code:

mvn -Plinux-databases package

The project declares a provided Nukkit-MOT dependency and includes the MongoDB driver dependencies.

The Linux database Maven profile adds SQLite and MySQL drivers.

A compatible Nukkit-MOT dependency and the required Maven artifacts must be available when building.

Additional Information:

LlamaEconomy NG 2.3.5 is a beta build.

Offline tests have covered the money ledger, currency enable/disable behavior, UUID handling, migration, configuration and selected compatibility checks.

SQLite was tested locally on Linux. Full operation on a live Nukkit-MOT server, real MySQL/MongoDB connections and compatibility with every third-party plugin have not been verified.

Always back up your existing economy data before upgrading or changing storage providers.

Contact & Support:

No support is allowed in the reviews!

If you want to report a problem, ask a question or suggest a feature, contact us via Telegram.

If you have further wishes, please let me know.

LlamaEconomy 2.3.4-NG-YAML

Ratings

More resources from LlamaDevelopment

Share this resource