Kotlin API guide

Dependency

Publish from the SkyyEconomy checkout:

.\gradlew.bat publishApiToMavenLocal

Consumer build.gradle.kts:

repositories {
    mavenLocal()
    mavenCentral()
    maven("https://repo.papermc.io/repository/maven-public/")
}

dependencies {
    compileOnly("de.skyymedia:skyyeconomy-api:0.2.0")
    compileOnly("io.papermc.paper:paper-api:26.1.2.build.+")
}

Alternatively copy SkyyEconomy-API-0.2.0.jar into libs/ and use:

dependencies {
    compileOnly(files("libs/SkyyEconomy-API-0.2.0.jar"))
}

Consumer plugin.yml:

name: JobSystem
version: '1.0.0'
main: example.jobs.JobSystemPlugin
api-version: '26.1'
depend: [SkyyEconomy]

Complete JobSystem example

package example.jobs

import de.skyymedia.economy.api.EconomyApi
import de.skyymedia.economy.api.ListenerRegistration
import de.skyymedia.economy.api.event.BalanceChangeEvent
import de.skyymedia.economy.api.model.FailureCode
import de.skyymedia.economy.api.model.Money
import de.skyymedia.economy.api.model.MutationContext
import de.skyymedia.economy.api.model.ResultStatus
import org.bukkit.entity.Player
import org.bukkit.plugin.java.JavaPlugin
import java.util.UUID

class JobSystemPlugin : JavaPlugin() {
    private lateinit var economy: EconomyApi
    private var balanceListener: ListenerRegistration? = null

    override fun onEnable() {
        economy = server.servicesManager.load(EconomyApi::class.java)
            ?: error("SkyyEconomy is required")
        balanceListener = economy.eventService().register(BalanceChangeEvent::class.java) { event ->
            logger.fine("Balance changed for ${event.accountUniqueId}: ${event.newBalance}")
        }
    }

    override fun onDisable() {
        balanceListener?.close()
    }

    fun rewardMiner(player: Player, rewardId: UUID) {
        val amount = Money.parse("25.00", 2)
        val context = MutationContext.builder("JobSystem", "Miner reward")
            .actor(player.uniqueId, player.name)
            .requestId("miner-reward:$rewardId")
            .metadata("job", "miner")
            .build()

        economy.economyService().deposit(player.uniqueId, amount, context)
            .whenComplete { result, failure ->
                server.scheduler.runTask(this, Runnable {
                    when {
                        failure != null -> logger.warning("Economy request failed: ${failure.message}")
                        result.status == ResultStatus.SUCCESS -> player.sendMessage("Reward credited.")
                        result.status == ResultStatus.ALREADY_PROCESSED -> logger.info("Reward was already credited.")
                        result.failureCode == FailureCode.ACCOUNT_RECEIVE_BLOCKED -> player.sendMessage("Your account cannot receive money.")
                        else -> player.sendMessage("Reward rejected: ${result.failureCode}")
                    }
                })
            }
    }

    fun readBalance(playerId: UUID) = economy.economyService().getBalance(playerId)

    fun withdraw(playerId: UUID, purchaseId: UUID) = economy.economyService().withdraw(
        playerId,
        Money.parse("10.00", 2),
        MutationContext.builder("JobSystem", "Job shop purchase")
            .requestId("job-purchase:$purchaseId")
            .build(),
    )

    fun transfer(from: UUID, to: UUID, amount: Money, transferId: UUID) =
        economy.economyService().transfer(
            from,
            to,
            amount,
            MutationContext.builder("JobSystem", "Team payout")
                .requestId("team-payout:$transferId")
                .build(),
        )

    fun history(playerId: UUID, page: Int = 1) =
        economy.transactionService().getTransactions(playerId, page, 20)

    fun restrictionStatus(playerId: UUID) =
        economy.accountRestrictionService().getActiveRestrictions(playerId)
}

The flow is JobSystem -> SkyyEconomy API -> authoritative transaction/ledger -> Redis invalidation after commit. Never infer a completed reward from a Redis event.