Remove redundant documentation from transaction APIs

- Stripped excessive comments and inline documentation across interfaces in `transaction`, `account`, and `currency` APIs.
- Simplified code readability by retaining only essential comments for public functions and properties.
- Updated related classes to adopt a cleaner, more concise interface structure.

Author: twisti-dev

surf-transaction-api/src/main/kotlin/dev/slne/surf/transaction/api/account/Account.kt

@@ -10,42 +10,15 @@ import java.util.*
 @OptIn(InternalTransactionApi::class)
 interface Account : Transactional, AccountMemberOperations {
 
-    /**
-     * Unique identifier for the account.
-     */
     val accountId: UUID
-
-    /**
-     * The name of the account.
-     */
     val name: String
-
-    /**
-     * The owner of the account.
-     */
     val ownerUuid: UUID
-
-    /**
-     * Indicates whether this account is the default account for the owner.
-     */
     val defaultAccount: Boolean
 
-    /**
-     * Converts the account information into a [Component] for display purposes.
-     *
-     * @return A [Component] representing the account information, suitable for use in user interfaces.
-     */
     suspend fun asComponent(): Component
 
     companion object {
-        /**
-         * Minimum length for account names.
-         */
         const val MIN_NAME_LENGTH = 3
-
-        /**
-         * Maximum length for account names.
-         */
         const val MAX_NAME_LENGTH = 32
 
         suspend fun byId(accountId: UUID): Account? =

surf-transaction-api/src/main/kotlin/dev/slne/surf/transaction/api/account/AccountAccess.kt

@@ -9,43 +9,10 @@ import java.util.*
 interface AccountAccess {
 
     val userUuid: UUID
-
-    /**
-     * Retrieves the default account for this player.
-     *
-     * @return the default [Account] associated with this player
-     */
     suspend fun getDefaultAccount(): Account
-
-    /**
-     * Retrieves all accounts associated with this player.
-     *
-     * @return a set of [Account]s owned by this player
-     */
     suspend fun getAllAccounts(): Set<Account>
-
-    /**
-     * Creates a new account for this player with the specified [name].
-     *
-     * @param name the name of the new account; must be non-empty
-     * @return the newly created [Account]
-     */
     suspend fun createAccount(name: String): AccountCreationResult
-
-    /**
-     * Retrieves the account with the specified [accountName] for this player.
-     *
-     * @param accountName the name of the account to retrieve; must be non-empty
-     * @return the [Account] matching [accountName], or `null` if not found
-     */
     suspend fun getAccountByName(accountName: String): Account?
-
-    /**
-     * Deletes the specified [account] from this player's accounts.
-     *
-     * @param account the account to delete; must be non-null
-     * @return an [dev.slne.surf.transaction.api.account.result.AccountDeleteResult] indicating success or failure
-     */
     suspend fun deleteAccount(account: Account): AccountDeleteResult
 
 }

surf-transaction-api/src/main/kotlin/dev/slne/surf/transaction/api/account/AccountService.kt

@@ -7,23 +7,8 @@ import java.util.*
 
 @InternalTransactionApi
 interface AccountService {
-    /**
-     * Retrieves an account by its unique identifier.
-     *
-     * @param accountId The unique identifier of the account to retrieve.
-     * @return The account associated with the given identifier, or null if no such account exists.
-     */
     suspend fun getAccountByAccountId(accountId: UUID): Account?
-
     suspend fun getAccountByName(accountName: String): Account?
-
-    /**
-     * Creates a new account for a specified player.
-     *
-     * @param owner The player who will own the new account.
-     * @param name The name of the new account.
-     * @return A result indicating the success or failure of the account creation.
-     */
     suspend fun createAccount(ownerUuid: UUID, name: String): AccountCreationResult
 
     companion object {

surf-transaction-api/src/main/kotlin/dev/slne/surf/transaction/api/account/member/AccountMemberOperations.kt

@@ -1,42 +1,20 @@
 package dev.slne.surf.transaction.api.account.member
 
 import dev.slne.surf.transaction.api.account.member.results.AccountMemberResult
-import it.unimi.dsi.fastutil.objects.ObjectSet
 import java.util.*
 
 interface AccountMemberOperations {
-    /**
-     * A set of members associated with the account.
-     */
     val members: Set<UUID>
 
-    /**
-     * Adds a new member to the account.
-     *
-     * @param executor The [OfflineCloudPlayer] executing the addition.
-     * @param target The [OfflineCloudPlayer] to be added as a member.
-     */
     suspend fun addMember(
         executor: UUID,
         target: UUID
     ): AccountMemberResult
 
-    /**
-     * Removes a member from the account.
-     *
-     * @param executor The [OfflineCloudPlayer] executing the removal.
-     * @param target The [OfflineCloudPlayer] to be removed from the members.
-     */
     suspend fun removeMember(
         executor: UUID,
         target: UUID
     ): AccountMemberResult
 
-    /**
-     * Checks if a player is a member of the account.
-     *
-     * @param player The [OfflineCloudPlayer] to check for membership.
-     * @return `true` if the player is a member, `false` otherwise.
-     */
     fun isMember(player: UUID): Boolean
 }

surf-transaction-api/src/main/kotlin/dev/slne/surf/transaction/api/currency/Currency.kt

@@ -1,103 +1,36 @@
 package dev.slne.surf.transaction.api.currency
 
 import dev.slne.surf.surfapi.core.api.messages.Colors
-import dev.slne.surf.transaction.api.currency.Currency.Companion.byName
 import dev.slne.surf.transaction.api.util.InternalTransactionApi
 import net.kyori.adventure.text.Component
 import net.kyori.adventure.text.ComponentLike
 import net.kyori.adventure.text.format.TextColor
 import java.math.BigDecimal
 
-/**
- * Describes a monetary unit that can be used in the transaction system.
- *
- * A **currency** is identified by its unique [name] and may provide rich‐text
- * variants for UI presentation via [displayName] and [symbolDisplay].
- * Implementations must be immutable and thread-safe.
- *
- * ### Serialization
- * This interface is annotated with `@Serializable(with = CurrencySerializer::class)`
- * to enable polymorphic (de)serialization of concrete currency implementations.
- */
 @OptIn(InternalTransactionApi::class)
 interface Currency : ComponentLike {
-
-    /** Unique identifier (≤ [ CURRENCY_NAME_MAX_LENGTH ] characters), e.g. `"castcoin"`. */
     val name: String
-
-    /** Rich-text display name, e.g. `<red>CastCoin</red>`. */
     val displayName: Component
-
-    /** `true` if this is the platform-wide default currency. */
     val defaultCurrency: Boolean
-
-    /** Plain text symbol, e.g. `"$"`. */
     val symbol: String
-
-    /** Rich-text variant of [symbol], e.g. `<red>$</red>`. */
     val symbolDisplay: Component
-
-    /** Decimal precision and formatting rules for this currency. */
     val scale: CurrencyScale
-
-    /** Minimum amount that must be present after validation unless bypassed. */
     val minimumAmount: BigDecimal
 
-    /**
-     * Converts [amount] into a formatted, colorized [Component].
-     *
-     * @param amount value to format
-     * @param color  text color for the numeric part; defaults to [Colors.VARIABLE_VALUE]
-     * @return formatted text like `"§7$§c1.50"`
-     */
     fun format(amount: BigDecimal, color: TextColor = Colors.VARIABLE_VALUE): Component
 
-    /**
-     * Convenience overload delegating to the `BigDecimal` version.
-     *
-     * @param amount value to format (will be converted with `toBigDecimal()`)
-     * @param color  text color for the numeric part; defaults to [Colors.VARIABLE_VALUE]
-     * @return formatted text component
-     */
     fun format(amount: Double, color: TextColor = Colors.VARIABLE_VALUE) =
         format(amount.toBigDecimal(), color)
 
-    /**
-     * Returns the display name of this currency as a [Component].
-     * This is primarily used for UI purposes, such as displaying the currency
-     * name in menus or transaction summaries.
-     *
-     * @return the display name of this currency as a [Component]
-     */
     override fun asComponent(): Component = displayName
 
     companion object {
-        /** Maximum allowed length for [name]. */
         const val CURRENCY_NAME_MAX_LENGTH = 16
-
-        /** Maximum allowed length for [symbol] and its display variant. */
         const val CURRENCY_SYMBOL_MAX_LENGTH = 16
 
-        /** Returns the platform-wide default currency. */
         fun default(): Currency = CurrencyService.instance.defaultCurrency
-
-
-        /**
-         * Retrieves the complete set of available currencies.
-         *
-         * This method provides access to all the currencies managed by the
-         * underlying `CurrencyService` instance. The returned set includes
-         * every defined currency that can be used in transactions or
-         * other currency-related operations.
-         *
-         * @return a set of all available currencies
-         */
         fun all(): Set<Currency> = CurrencyService.instance.currencies
-
-        /** Retrieves a currency by its [name] or `null` if none matches. */
         fun byName(name: String): Currency? = CurrencyService.instance.getCurrencyByName(name)
-
-        /** Alias for [byName]. */
         operator fun get(name: String): Currency? = byName(name)
     }
 }

surf-transaction-api/src/main/kotlin/dev/slne/surf/transaction/api/currency/CurrencyScale.kt

@@ -5,50 +5,21 @@ import java.math.RoundingMode
 import java.text.NumberFormat
 import java.util.*
 
-/**
- * Supported decimal precisions for monetary values.
- *
- * Each entry provides a custom implementation of [format] that clamps a
- * [BigDecimal] to the appropriate scale. Helper overloads are supplied for
- * `Double` conversion and locale-aware string formatting via [NumberFormat].
- */
 enum class CurrencyScale {
-
-    /**
-     * No fractional digits (`scale = 0`).
-     */
     INTEGER {
         override fun format(amount: BigDecimal): BigDecimal {
             return amount.setScale(0, RoundingMode.HALF_UP)
         }
     },
 
-    /**
-     * Exactly two fractional digits (`scale = 2`).
-     */
     DECIMAL_2 {
         override fun format(amount: BigDecimal): BigDecimal {
             return amount.setScale(2, RoundingMode.HALF_UP)
         }
     };
 
-    /**
-     * Returns [amount] rounded to this scale.
-     *
-     * @param amount value to adjust
-     * @return a new [BigDecimal] with the correct scale
-     */
     abstract fun format(amount: BigDecimal): BigDecimal
 
-    /**
-     * Returns a locale-aware string representation of [amount] after applying
-     * this scale’s rounding rules.
-     *
-     * @param amount  value to convert and scale
-     * @param locale  formatting locale; defaults to the JVM’s current
-     *                [`FORMAT`](https://docs.oracle.com/javase/8/docs/api/java/util/Locale.Category.html#FORMAT) locale
-     * @return        human-readable number, e.g. `"1,234.00"`
-     */
     fun formatString(
         amount: BigDecimal,
         locale: Locale = Locale.getDefault(Locale.Category.FORMAT)

surf-transaction-api/src/main/kotlin/dev/slne/surf/transaction/api/transaction/Transaction.kt

@@ -8,77 +8,19 @@ import org.jetbrains.annotations.Unmodifiable
 import java.math.BigDecimal
 import java.util.*
 
-/**
- * Immutable description of a single monetary operation.
- *
- * A transaction moves an [amount] of a specified [currency] from an optional [senderAccount]
- * to an optional [receiverAccount]. When either participant is `null`, the transfer is treated
- * as a **system transaction**—originating from or destined to the platform itself
- * rather than an [Account].
- *
- * All properties are read-only; implementations are expected to be thread-safe.
- */
 @OptIn(InternalTransactionApi::class)
 interface Transaction {
 
-    /** Globally unique identifier of this transaction instance. */
     val identifier: UUID
-
-    /**
-     * The [OfflineCloudPlayer] who initiated this transaction.
-     */
     val initiator: UUID?
-
-    /**
-     * The uuid of the [Account] initiating the transfer, or `null` for system credits.
-     *
-     * When `null`, the funds originate from the platform (e.g. daily rewards).
-     */
     val senderAccountId: UUID?
-
-    /**
-     * The uuid of the [Account] receiving the funds, or `null` for system debits.
-     *
-     * When `null`, the funds are removed from circulation by the platform
-     * (e.g., taxes, sinks).
-     */
     val receiverAccountId: UUID?
 
-    /**
-     * Asynchronously retrieves the [Account] initiating the transfer, or `null` for system credits.
-     *
-     * When `null`, the funds originate from the platform (e.g. daily rewards).
-     */
-    suspend fun senderAccount(): Account?
-
-    /**
-     * Asynchronously retrieves the [Account] receiving the funds, or `null` for system debits.
-     *
-     * When `null`, the funds are removed from circulation by the platform
-     * (e.g., taxes, sinks).
-     */
-    suspend fun receiverAccount(): Account?
-
-    /**
-     * Currency in which the [amount] is denominated.
-     * */
     val currency: Currency
-
-    /**
-     * Absolute value transferred, expressed with high-precision decimal arithmetic.
-     */
     val amount: BigDecimal
-
-    /**
-     * Arbitrary, immutable set of metadata entries associated with this transaction.
-     */
-    val data: @Unmodifiable Set<TransactionData>
-
-    /**
-     * `true` if minimum-balance validation should be bypassed for this transaction.
-     *
-     * Typically used for administrative or system-level operations.
-     */
     val ignoreMinimumAmount: Boolean
+    val data: @Unmodifiable Set<TransactionData>
 
-}
+    suspend fun receiverAccount(): Account?
+    suspend fun senderAccount(): Account?
+}