@shipload/sdk 2.0.0-rc4 → 2.0.0-rc6

package/src/entities/player.ts

@@ -1,288 +1,15 @@
-import {
-    Int64,
-    Int64Type,
-    Name,
-    NameType,
-    UInt32,
-    UInt32Type,
-    UInt64,
-    UInt64Type,
-} from '@wharfkit/antelope'
+import {Name, NameType} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 
 export interface PlayerStateInput {
     owner: NameType
-    balance: UInt64Type
-    debt: UInt32Type
-    networth: Int64Type
 }
 
-/**
- * Player helper class extending player_row with computed financial properties.
- * Provides easy access to balance, debt, networth, and loan calculations.
- */
 export class Player extends ServerContract.Types.player_row {
-    /**
-     * Construct a Player instance from individual state pieces.
-     * Used by UI's ReactivePlayer to reconstruct Player from reactive state.
-     */
     static fromState(state: PlayerStateInput): Player {
         const playerRow = ServerContract.Types.player_row.from({
             owner: Name.from(state.owner),
-            balance: UInt64.from(state.balance),
-            debt: UInt32.from(state.debt),
-            networth: Int64.from(state.networth),
         })
         return new Player(playerRow)
     }
-    // Constants for game rules (match smart contract)
-    private static readonly MAX_LOAN = 1000000
-    // Contract formula: 2500 * pow(5, sequence - 1) = 500 * pow(5, sequence)
-    private static readonly BASE_SHIP_COST = 500
-    private static readonly SHIP_COST_MULTIPLIER = 5
-
-    // Optional ship count for nextShipCost calculation
-    private _shipCount?: number
-
-    /**
-     * Set the current ship count (needed for nextShipCost calculation)
-     */
-    setShipCount(count: number): void {
-        this._shipCount = count
-    }
-
-    /**
-     * Get the current ship count (if set)
-     */
-    get shipCount(): number | undefined {
-        return this._shipCount
-    }
-
-    /**
-     * Calculate the cost of the next ship based on current ship count
-     * Matches contract: pow(5, sequence) * 100
-     * @param shipCount - Optional ship count (uses cached value if not provided)
-     */
-    getNextShipCost(shipCount?: number): UInt64 {
-        const count = shipCount ?? this._shipCount ?? 0
-        const cost = Math.pow(Player.SHIP_COST_MULTIPLIER, count) * Player.BASE_SHIP_COST
-        return UInt64.from(Math.floor(cost))
-    }
-
-    /**
-     * Get the cost of the next ship based on cached ship count
-     */
-    get nextShipCost(): UInt64 {
-        return this.getNextShipCost()
-    }
-
-    /**
-     * Check if player can afford to buy a ship
-     * @param shipCount - Optional ship count (uses cached value if not provided)
-     */
-    canBuyShip(shipCount?: number): boolean {
-        return UInt64.from(this.balance).gte(this.getNextShipCost(shipCount))
-    }
-
-    /**
-     * Calculate available loan amount (max loan - current debt)
-     */
-    get availableLoan(): UInt64 {
-        const maxLoan = UInt64.from(Player.MAX_LOAN)
-        if (UInt64.from(this.debt).gte(maxLoan)) {
-            return UInt64.from(0)
-        }
-        return maxLoan.subtracting(this.debt)
-    }
-
-    /**
-     * Check if player can take out a loan
-     */
-    get canTakeLoan(): boolean {
-        return this.availableLoan.gt(UInt64.zero)
-    }
-
-    /**
-     * Check if player can pay back loan
-     */
-    get canPayLoan(): boolean {
-        return UInt64.from(this.debt).gt(UInt64.zero) && UInt64.from(this.balance).gt(UInt64.zero)
-    }
-
-    /**
-     * Calculate maximum payback amount (min of debt and balance)
-     */
-    get maxPayback(): UInt64 {
-        return UInt64.from(this.debt).lt(this.balance) ? this.debt : this.balance
-    }
-
-    /**
-     * Get the maximum loan amount (constant)
-     */
-    static get MAX_LOAN_LIMIT(): number {
-        return Player.MAX_LOAN
-    }
-
-    /**
-     * Check if player is in debt
-     */
-    get hasDebt(): boolean {
-        return UInt64.from(this.debt).gt(UInt64.zero)
-    }
-
-    /**
-     * Check if player is solvent (positive networth)
-     */
-    get isSolvent(): boolean {
-        return this.networth.gte(Int64.zero)
-    }
-
-    /**
-     * Create an optimistic update for balance changes
-     * Uses integer math to match contract
-     * @param delta - Amount to change (can be negative)
-     */
-    withBalanceChange(delta: UInt64 | number): Player {
-        const newPlayer = Player.from(this)
-        const amount = typeof delta === 'number' ? UInt64.from(Math.abs(delta)) : delta
-
-        if (typeof delta === 'number' && delta < 0) {
-            // Subtract, ensuring we don't go below 0
-            newPlayer.balance = UInt64.from(this.balance).gte(amount)
-                ? this.balance.subtracting(amount)
-                : UInt64.from(0)
-        } else {
-            // Add
-            newPlayer.balance = this.balance.adding(amount)
-        }
-
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
-
-    /**
-     * Create an optimistic update for debt changes
-     * Uses integer math to match contract
-     * @param delta - Amount to change (can be negative)
-     */
-    withDebtChange(delta: UInt64 | number): Player {
-        const newPlayer = Player.from(this)
-        const amount = typeof delta === 'number' ? UInt64.from(Math.abs(delta)) : delta
-
-        if (typeof delta === 'number' && delta < 0) {
-            // Subtract, ensuring we don't go below 0
-            newPlayer.debt = UInt64.from(this.debt).gte(amount)
-                ? this.debt.subtracting(amount)
-                : UInt64.from(0)
-        } else {
-            // Add
-            newPlayer.debt = this.debt.adding(amount)
-        }
-
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
-
-    /**
-     * Create an optimistic update for taking a loan
-     */
-    withLoan(amount: UInt64): Player {
-        const newPlayer = Player.from(this)
-        newPlayer.balance = this.balance.adding(amount)
-        newPlayer.debt = this.debt.adding(amount)
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
-
-    /**
-     * Create an optimistic update for paying back a loan
-     */
-    withLoanPayment(amount: UInt64): Player {
-        const actualPayment = this.maxPayback.lt(amount) ? this.maxPayback : amount
-        const newPlayer = Player.from(this)
-        newPlayer.balance = this.balance.subtracting(actualPayment)
-        newPlayer.debt = this.debt.subtracting(actualPayment)
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
-
-    /**
-     * Simulate networth update from selling goods.
-     * Matches contract: networth += (sellPrice - paid * quantity)
-     * Contract reference: market.cpp:75
-     *
-     * @param sellPrice - Total revenue from sale (price * quantity)
-     * @param paidPerUnit - Average cost per unit paid (from cargo.paid)
-     * @param quantity - Quantity being sold
-     * @returns New player with updated networth
-     *
-     * @example
-     * // Sold 10 units at 150 each (revenue=1500), paid 100 per unit
-     * const newPlayer = player.withSaleNetworth(
-     *     UInt64.from(1500),
-     *     UInt64.from(100),
-     *     UInt32.from(10)
-     * )
-     * // Networth increases by: 1500 - (100*10) = 500
-     */
-    withSaleNetworth(sellPrice: UInt64, paidPerUnit: UInt64, quantity: UInt64): Player {
-        // Match contract: price - paid * quantity
-        const cost = paidPerUnit.multiplying(quantity)
-        const profit = sellPrice.gte(cost) ? sellPrice.subtracting(cost) : Int64.from(0)
-
-        const newPlayer = Player.from(this)
-        newPlayer.networth = Int64.from(this.networth).adding(profit)
-        return newPlayer
-    }
-
-    /**
-     * Simulate complete sell goods transaction.
-     * Updates both balance (adds revenue) and networth (adds profit).
-     * Matches contract actions: update_balance + update_networth
-     *
-     * @param sellPrice - Total revenue from sale (price * quantity)
-     * @param paidPerUnit - Average cost per unit paid (from cargo.paid)
-     * @param quantity - Quantity being sold
-     * @returns New player with updated balance and networth
-     */
-    withSellGoods(sellPrice: UInt64, paidPerUnit: UInt64, quantity: UInt64): Player {
-        const cost = paidPerUnit.multiplying(quantity)
-        const profit = sellPrice.gte(cost) ? sellPrice.subtracting(cost) : Int64.from(0)
-
-        const newPlayer = Player.from(this)
-        newPlayer.balance = this.balance.adding(sellPrice)
-        newPlayer.networth = Int64.from(this.networth).adding(profit)
-        return newPlayer
-    }
-
-    /**
-     * Simulate complete buy goods transaction.
-     * Updates balance (subtracts cost).
-     *
-     * @param purchaseCost - Total cost of purchase (price * quantity)
-     * @returns New player with updated balance
-     */
-    withBuyGoods(purchaseCost: UInt64): Player {
-        const newPlayer = Player.from(this)
-        newPlayer.balance = UInt64.from(this.balance).gte(purchaseCost)
-            ? this.balance.subtracting(purchaseCost)
-            : UInt64.from(0)
-        // Calculate networth as Int64 (can be negative)
-        const balanceInt = Int64.from(newPlayer.balance)
-        const debtInt = Int64.from(newPlayer.debt)
-        newPlayer.networth = balanceInt.subtracting(debtInt)
-        return newPlayer
-    }
 }

package/src/entities/ship.ts

@@ -21,7 +21,6 @@ import {
     hasEnergyForDistance,
     maxTravelDistance,
 } from '../capabilities/movement'
-import * as cargoUtils from './cargo-utils'
 import * as schedule from '../scheduling/schedule'
 
 export interface ShipStateInput {
@@ -133,10 +132,6 @@ export class Ship extends ServerContract.Types.entity_info {
         return this.inv.totalMass
     }
 
-    get cargoValue(): UInt64 {
-        return this.inv.totalValue
-    }
-
     get totalMass(): UInt64 {
         let mass = UInt64.from(this.hullmass ?? 0).adding(this.totalCargoMass)
         if (this.loaders) {
@@ -193,20 +188,4 @@ export class Ship extends ServerContract.Types.entity_info {
         if (!this.engines || !this.generator || this.energy === undefined) return false
         return hasEnergyForDistance(this as MovementEntity, distance)
     }
-
-    calculateSaleValue(prices: Map<number, UInt64>): cargoUtils.SaleValue {
-        return cargoUtils.calculateSaleValue(this.cargo, prices)
-    }
-
-    calculateSaleValueFromArray(prices: UInt64[]): cargoUtils.SaleValue {
-        return cargoUtils.calculateSaleValueFromArray(this.cargo, prices)
-    }
-
-    afterSellItems(goodsToSell: Array<{goodId: number; quantity: number}>): EntityInventory[] {
-        return cargoUtils.afterSellItems(this.cargo, goodsToSell)
-    }
-
-    afterSellAllItems(): EntityInventory[] {
-        return cargoUtils.afterSellAllItems(this.cargo)
-    }
 }

package/src/entities/warehouse.ts

@@ -58,10 +58,6 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return this.inv.totalMass
     }
 
-    get cargoValue(): UInt64 {
-        return this.inv.totalValue
-    }
-
     get maxCapacity(): UInt64 {
         return UInt64.from(this.capacity)
     }

package/src/index-module.ts

@@ -37,7 +37,6 @@ export {
     EntitiesManager,
     PlayersManager,
     LocationsManager,
-    TradesManager,
     EpochsManager,
     ActionsManager,
 } from './managers'
@@ -47,8 +46,6 @@ export type {EntityRefInput} from './managers/actions'
 export {getItem, getItems, itemIds} from './market/items'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
-export {marketPrice, marketPrices, getRarity, Rarities} from './market/market'
-export type {Rarity} from './market/market'
 export {
     getSystemName,
     hasSystem,
@@ -67,13 +64,13 @@ export {
     getResourceWeight,
     getLocationCandidates,
     getDepthThreshold,
-    getResourceRarity,
+    getResourceTier,
     depthScaleFactor,
-    DEPTH_THRESHOLD_COMMON,
-    DEPTH_THRESHOLD_UNCOMMON,
-    DEPTH_THRESHOLD_RARE,
-    DEPTH_THRESHOLD_EPIC,
-    DEPTH_THRESHOLD_LEGENDARY,
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
     LOCATION_MIN_DEPTH,
     LOCATION_MAX_DEPTH,
     PLANET_SUBTYPE_GAS_GIANT,
@@ -86,32 +83,10 @@ export {
 
 export type {StratumInfo, ResourceStats} from './derivation'
 
-export {hash, hash512} from './utils/hash'
-
-export type {Deal, FindDealsOptions} from './trading/deal'
-export {findDealsForShip, findBestDeal} from './trading/deal'
+export {getStatDefinitions, getStatName, resolveStats} from './derivation'
+export type {StatDefinition, NamedStats} from './derivation'
 
-export type {
-    CollectActionType,
-    CollectOption,
-    CollectAnalysis,
-    CollectAnalysisOptions,
-    CollectAnalysisCallbacks,
-    BetterSaleLocation,
-    RepositionLocation,
-    DiscountedItemInfo,
-    PotentialDeal,
-    CargoSaleItem,
-} from './trading/collect'
-export {
-    analyzeCollectOptions,
-    analyzeCargoSale,
-    createSellAndTradeOption,
-    createTravelToSellOption,
-    createSellAndRepositionOption,
-    createSellAndStayOption,
-    createExploreOption,
-} from './trading/collect'
+export {hash, hash512} from './utils/hash'
 
 export {
     distanceBetweenCoordinates,
@@ -150,19 +125,6 @@ export type {
     HasScheduleAndLocation,
 } from './travel/travel'
 
-export {
-    calculateUpdatedCargoCost,
-    calculateMaxTradeQuantity,
-    calculateTradeProfit,
-    calculateProfitPerMass,
-    calculateProfitPerSecond,
-    findBestItemToTrade,
-    calculateBreakEvenPrice,
-    isProfitable,
-    calculateROI,
-} from './trading/trade'
-export type {TradeCalculation, TradeProfitResult} from './trading/trade'
-
 export * as schedule from './scheduling/schedule'
 export type {Scheduleable, ScheduleData} from './scheduling/schedule'
 export {ScheduleAccessor, createScheduleAccessor} from './scheduling/accessor'
@@ -178,3 +140,37 @@ export type {Projectable, ProjectedEntity} from './scheduling/projection'
 export * from './types/capabilities'
 export * from './types/entity'
 export * from './capabilities'
+
+export {
+   components,
+   entityRecipes,
+   getComponentById,
+   getEntityRecipe,
+   getEntityRecipeByItemId,
+   getAllCraftableItems,
+   getComponentsForCategory,
+   getComponentsForStat,
+   ITEM_HULL_PLATES,
+   ITEM_CARGO_LINING,
+   ITEM_CONTAINER_PACKED,
+} from './data/recipes'
+export type {
+   ComponentDefinition,
+   ComponentStat,
+   RecipeInput,
+   EntityRecipe,
+   CraftableItem,
+} from './data/recipes'
+
+export {
+   encodeStats,
+   decodeStats,
+   decodeCraftedItemStats,
+   blendStacks,
+   computeComponentStats,
+   blendComponentStacks,
+   computeEntityStats,
+} from './derivation/crafting'
+export type {StackInput, CategoryStacks} from './derivation/crafting'
+
+export {computeContainerCapabilities} from './entities/container'

package/src/managers/actions.ts

@@ -1,15 +1,8 @@
 import {Action, Int64, Name, NameType, UInt16, UInt32, UInt64, UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {Ship} from '../entities/ship'
 import {CoordinatesType, EntityType, EntityTypeName} from '../types'
 import {ServerContract} from '../contracts'
 
-interface SellableCargo {
-    item_id: {toNumber(): number} | number
-    quantity: {toNumber(): number} | number
-    hasCargo: boolean
-}
-
 export type EntityRefInput = {
     entityType: EntityTypeName
     entityId: UInt64Type
@@ -91,71 +84,6 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    buyItems(
-        entityId: UInt64Type,
-        goodId: UInt64Type,
-        quantity: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
-        return this.server.action('buyitems', {
-            entity_type: entityType,
-            id: UInt64.from(entityId),
-            item_id: UInt16.from(goodId),
-            quantity: UInt32.from(quantity),
-        })
-    }
-
-    sellItems(
-        entityId: UInt64Type,
-        goodId: UInt64Type,
-        quantity: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
-        return this.server.action('sellitems', {
-            entity_type: entityType,
-            id: UInt64.from(entityId),
-            item_id: UInt16.from(goodId),
-            quantity: UInt32.from(quantity),
-        })
-    }
-
-    buyShip(account: NameType, name: string): Action {
-        return this.server.action('buyship', {
-            account: Name.from(account),
-            name,
-        })
-    }
-
-    buyWarehouse(account: NameType, shipId: UInt64Type, name: string): Action {
-        return this.server.action('buywarehouse', {
-            account: Name.from(account),
-            ship_id: UInt64.from(shipId),
-            name,
-        })
-    }
-
-    buyContainer(account: NameType, shipId: UInt64Type, name: string): Action {
-        return this.server.action('buycontainer', {
-            account: Name.from(account),
-            ship_id: UInt64.from(shipId),
-            name,
-        })
-    }
-
-    takeLoan(account: NameType, amount: UInt64Type): Action {
-        return this.server.action('takeloan', {
-            account: Name.from(account),
-            amount: UInt64.from(amount),
-        })
-    }
-
-    payLoan(account: NameType, amount: UInt64Type): Action {
-        return this.server.action('payloan', {
-            account: Name.from(account),
-            amount: UInt64.from(amount),
-        })
-    }
-
     foundCompany(account: NameType, name: string): Action {
         return this.platform.action('foundcompany', {
             account: Name.from(account),
@@ -187,26 +115,46 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    joinGame(account: NameType, companyName: string): Action[] {
-        return [this.foundCompany(account, companyName), this.join(account)]
+    craft(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        recipeId: number,
+        quantity: number,
+        inputs: {itemId: number; quantity: number; seed?: bigint}[]
+    ): Action {
+        const cargoInputs = inputs.map((i) =>
+            ServerContract.Types.cargo_item.from({
+                item_id: UInt16.from(i.itemId),
+                quantity: UInt32.from(i.quantity),
+                seed: i.seed !== undefined ? UInt64.from(i.seed) : null,
+            })
+        )
+        return this.server.action('craft', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            recipe_id: UInt16.from(recipeId),
+            quantity: UInt32.from(quantity),
+            inputs: cargoInputs,
+        })
     }
 
-    sellAllCargo(ship: Ship | UInt64Type, cargo?: SellableCargo[]): Action[] {
-        let shipCargo: SellableCargo[]
-
-        if (ship instanceof Ship) {
-            shipCargo = cargo || ship.inventory
-        } else {
-            if (!cargo) {
-                throw new Error('cargo parameter required when ship is a UInt64Type')
-            }
-            shipCargo = cargo
-        }
-
-        const shipId = ship instanceof Ship ? ship.id : UInt64.from(ship)
+    deploy(
+        entityType: EntityTypeName,
+        entityId: UInt64Type,
+        packedItemId: number,
+        seed: bigint,
+        entityName: string
+    ): Action {
+        return this.server.action('deploy', {
+            entity_type: entityType,
+            id: UInt64.from(entityId),
+            packed_item_id: UInt16.from(packedItemId),
+            seed: UInt64.from(seed),
+            entity_name: entityName,
+        })
+    }
 
-        return shipCargo
-            .filter((c) => c.hasCargo)
-            .map((c) => this.sellItems(shipId, c.item_id, c.quantity, EntityType.SHIP))
+    joinGame(account: NameType, companyName: string): Action[] {
+        return [this.foundCompany(account, companyName), this.join(account)]
     }
 }

package/src/managers/context.ts

@@ -6,7 +6,6 @@ import {GameState} from '../entities/gamestate'
 import {EntitiesManager} from './entities'
 import {PlayersManager} from './players'
 import {LocationsManager} from './locations'
-import {TradesManager} from './trades'
 import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
 
@@ -14,7 +13,6 @@ export class GameContext {
     private _entities?: EntitiesManager
     private _players?: PlayersManager
     private _locations?: LocationsManager
-    private _trades?: TradesManager
     private _epochs?: EpochsManager
     private _actions?: ActionsManager
 
@@ -48,13 +46,6 @@ export class GameContext {
         return this._locations
     }
 
-    get trades(): TradesManager {
-        if (!this._trades) {
-            this._trades = new TradesManager(this)
-        }
-        return this._trades
-    }
-
     get epochs(): EpochsManager {
         if (!this._epochs) {
             this._epochs = new EpochsManager(this)

package/src/managers/index.ts

@@ -4,6 +4,5 @@ export {EntitiesManager} from './entities'
 export type {EntityType} from './entities'
 export {PlayersManager} from './players'
 export {LocationsManager} from './locations'
-export {TradesManager} from './trades'
 export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'