@shipload/sdk 2.0.0-rc5 → 2.0.0-rc6

package/src/entities/location.ts

@@ -1,35 +1,22 @@
-import {Checksum256, Checksum256Type, UInt16, UInt16Type, UInt64} from '@wharfkit/antelope'
-import {ServerContract} from '../contracts'
-import {Coordinates, CoordinatesType, Distance, ItemPrice, LocationType} from '../types'
+import {Checksum256, Checksum256Type, UInt16Type, UInt64} from '@wharfkit/antelope'
+import {Coordinates, CoordinatesType, Distance, LocationType} from '../types'
 import {getLocationType, hasSystem, isExtractableLocation} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 
-/**
- * Location helper class for working with game coordinates.
- * Provides system detection, market price caching, nearby planet finding, and supply tracking.
- */
 export class Location {
     readonly coordinates: Coordinates
-    private _marketPrices?: ItemPrice[]
     private _gameSeed?: Checksum256
     private _hasSystem?: boolean
-    private _locationRows?: ServerContract.Types.supply_row[]
     private _epoch?: UInt64
 
     constructor(coordinates: CoordinatesType) {
         this.coordinates = Coordinates.from(coordinates)
     }
 
-    /**
-     * Create a Location from coordinates
-     */
     static from(coordinates: CoordinatesType): Location {
         return new Location(Coordinates.from(coordinates))
     }
 
-    /**
-     * Check if this location has a system (planet, asteroid, or nebula)
-     */
     hasSystemAt(gameSeed: Checksum256Type): boolean {
         const seed = Checksum256.from(gameSeed)
         if (this._hasSystem === undefined || !this._gameSeed?.equals(seed)) {
@@ -39,214 +26,32 @@ export class Location {
         return this._hasSystem
     }
 
-    /**
-     * Get the location type (EMPTY, PLANET, ASTEROID, or NEBULA)
-     */
     getLocationTypeAt(gameSeed: Checksum256Type): LocationType {
         return getLocationType(gameSeed, this.coordinates)
     }
 
-    /**
-     * Check if this location is extractable (asteroid or nebula)
-     */
     isExtractableAt(gameSeed: Checksum256Type): boolean {
         return isExtractableLocation(this.getLocationTypeAt(gameSeed))
     }
 
-    /**
-     * Set cached market prices for this location
-     */
-    setMarketPrices(prices: ItemPrice[]): void {
-        this._marketPrices = prices
-    }
-
-    /**
-     * Get cached market prices (returns undefined if not cached)
-     */
-    get marketPrices(): ItemPrice[] | undefined {
-        return this._marketPrices
-    }
-
-    /**
-     * Get price for a specific good (from cache)
-     */
-    getPrice(goodId: UInt16Type): ItemPrice | undefined {
-        if (!this._marketPrices) return undefined
-        return this._marketPrices.find((p) => p.id.equals(goodId))
-    }
-
-    /**
-     * Find nearby planets from this location
-     */
     findNearby(gameSeed: Checksum256Type, maxDistance: UInt16Type = 20): Distance[] {
         return findNearbyPlanets(Checksum256.from(gameSeed), this.coordinates, maxDistance)
     }
 
-    /**
-     * Check if this location equals another location
-     */
     equals(other: CoordinatesType | Location): boolean {
         const otherCoords = other instanceof Location ? other.coordinates : Coordinates.from(other)
         return this.coordinates.equals(otherCoords)
     }
 
-    /**
-     * Set location rows (supply data) for this location
-     */
-    setLocationRows(rows: ServerContract.Types.supply_row[], epoch: UInt64): void {
-        this._locationRows = rows
-        this._epoch = epoch
-    }
-
-    /**
-     * Get cached location rows (supply data)
-     */
-    get locationRows(): ServerContract.Types.supply_row[] | undefined {
-        return this._locationRows
-    }
-
-    /**
-     * Get supply for a specific good at this location
-     * Returns undefined if location rows not cached or good not found
-     */
-    getSupply(goodId: UInt16Type): UInt16 | undefined {
-        if (!this._locationRows) return undefined
-        const row = this._locationRows.find(
-            (r) => r.item_id.equals(goodId) && this._epoch && r.epoch.equals(this._epoch)
-        )
-        return row ? row.supply : undefined
-    }
-
-    /**
-     * Get all available goods at this location (goods with supply > 0)
-     * Returns undefined if location rows not cached
-     */
-    get availableGoods(): ServerContract.Types.supply_row[] | undefined {
-        if (!this._locationRows) return undefined
-        return this._locationRows.filter(
-            (r) => this._epoch && r.epoch.equals(this._epoch) && r.supply.gt(UInt16.from(0))
-        )
-    }
-
-    /**
-     * Check if a specific good is available (has supply)
-     * Returns false if location rows not cached
-     */
-    hasGood(goodId: UInt16Type): boolean {
-        const supply = this.getSupply(goodId)
-        return supply !== undefined && supply.gt(UInt16.from(0))
-    }
-
-    /**
-     * Get the epoch for cached location data
-     */
     get epoch(): UInt64 | undefined {
         return this._epoch
     }
 
-    /**
-     * Check if cached data exists
-     */
-    get hasCachedData(): boolean {
-        return this._marketPrices !== undefined || this._locationRows !== undefined
-    }
-
-    /**
-     * Check if supply data is cached
-     */
-    get hasSupplyData(): boolean {
-        return this._locationRows !== undefined
-    }
-
-    /**
-     * Clear all cached data
-     */
     clearCache(): void {
-        this._marketPrices = undefined
-        this._locationRows = undefined
         this._epoch = undefined
     }
-
-    /**
-     * Create optimistic Location with updated supply after purchase/sale.
-     * Matches contract: update_location_supply (delta can be positive or negative)
-     * Contract reference: market.cpp:53, 123-151
-     *
-     * @param goodId - Good ID to update supply for
-     * @param quantityDelta - Change in supply (negative for purchase, positive for sale)
-     * @returns New Location with updated supply in cached data
-     *
-     * @example
-     * // After buying 10 units (supply decreases)
-     * const newLocation = location.withUpdatedSupply(1, -10)
-     *
-     * // After selling 5 units (supply increases)
-     * const newLocation = location.withUpdatedSupply(1, 5)
-     */
-    withUpdatedSupply(goodId: UInt16Type, quantityDelta: number): Location {
-        const newLocation = Location.from(this.coordinates)
-
-        // Copy market prices if cached
-        if (this._marketPrices) {
-            newLocation._marketPrices = this._marketPrices.map((price) => {
-                if (price.id.equals(goodId)) {
-                    const currentSupply = UInt16.from(price.supply)
-                    const delta = UInt16.from(Math.abs(quantityDelta))
-                    const newSupply =
-                        quantityDelta < 0
-                            ? currentSupply.gte(delta)
-                                ? currentSupply.subtracting(delta)
-                                : UInt16.from(0)
-                            : currentSupply.adding(quantityDelta)
-
-                    return ItemPrice.from({
-                        id: price.id,
-                        item: price.item,
-                        price: price.price,
-                        supply: newSupply,
-                    })
-                }
-                return price
-            })
-        }
-
-        // Copy location rows if cached
-        if (this._locationRows && this._epoch) {
-            newLocation._locationRows = this._locationRows.map((row) => {
-                if (row.item_id.equals(goodId) && row.epoch.equals(this._epoch!)) {
-                    const currentSupply = UInt16.from(row.supply)
-                    const delta = UInt16.from(Math.abs(quantityDelta))
-                    const newSupply =
-                        quantityDelta < 0
-                            ? currentSupply.gte(delta)
-                                ? currentSupply.subtracting(delta)
-                                : UInt16.from(0)
-                            : currentSupply.adding(quantityDelta)
-
-                    return ServerContract.Types.supply_row.from({
-                        id: row.id,
-                        coordinates: row.coordinates,
-                        epoch: row.epoch,
-                        item_id: row.item_id,
-                        supply: newSupply,
-                    })
-                }
-                return row
-            })
-            newLocation._epoch = this._epoch
-        }
-
-        // Copy other cached data
-        newLocation._gameSeed = this._gameSeed
-        newLocation._hasSystem = this._hasSystem
-
-        return newLocation
-    }
 }
 
-/**
- * Helper function to convert various coordinate types to Location
- */
 export function toLocation(coords: CoordinatesType | Location): Location {
     if (coords instanceof Location) {
         return coords

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, getRarityMultiplier, Rarities} from './market/market'
-export type {Rarity} from './market/market'
 export {
     getSystemName,
     hasSystem,
@@ -91,31 +88,6 @@ export type {StatDefinition, NamedStats} from './derivation'
 
 export {hash, hash512} from './utils/hash'
 
-export type {Deal, FindDealsOptions} from './trading/deal'
-export {findDealsForShip, findBestDeal} from './trading/deal'
-
-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 {
     distanceBetweenCoordinates,
     distanceBetweenPoints,
@@ -153,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'
@@ -181,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'