@shipload/sdk 2.0.0-rc2 → 2.0.0-rc21

package/src/derivation/stratum.ts

@@ -0,0 +1,134 @@
+import {Bytes, Checksum256, Checksum256Type} from '@wharfkit/antelope'
+import {hash512} from '../utils/hash'
+import {Coordinates, CoordinatesType} from '../types'
+import {getEligibleResources, getResourceWeight, YIELD_THRESHOLD} from './resources'
+import {RESERVE_TIERS, rollTier, rollWithinTier} from './tiers'
+
+export interface StratumInfo {
+    itemId: number
+    seed: bigint
+    richness: number
+    reserve: number
+}
+
+export interface ResourceStats {
+    stat1: number
+    stat2: number
+    stat3: number
+}
+
+export function deriveStratum(
+    epochSeed: Checksum256Type,
+    coords: CoordinatesType,
+    stratum: number,
+    locationType: number,
+    subtype: number,
+    _maxDepth: number
+): StratumInfo {
+    const seed = Checksum256.from(epochSeed)
+    const c = Coordinates.from(coords)
+    const input = `stratum-${c.x}-${c.y}-${stratum}`
+    const hashResult = hash512(seed, input)
+    const bytes = hashResult.array
+
+    const rawReserve = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
+
+    let reserve = 0
+    if (rawReserve <= YIELD_THRESHOLD) {
+        const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0
+        const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0
+        const tier = rollTier(tierRoll, stratum)
+        reserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier])
+    }
+
+    if (reserve === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+
+    const eligible = getEligibleResources(locationType, subtype, stratum)
+    if (eligible.length === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+
+    const resourceRoll = ((bytes[4] << 24) | (bytes[5] << 16) | (bytes[6] << 8) | bytes[7]) >>> 0
+
+    let totalWeight = 0
+    for (const id of eligible) {
+        totalWeight += getResourceWeight(id, stratum)
+    }
+
+    let selectedItemId = eligible[0]
+    if (totalWeight > 0) {
+        const roll = resourceRoll % totalWeight
+        let cumulative = 0
+        for (const id of eligible) {
+            cumulative += getResourceWeight(id, stratum)
+            if (roll < cumulative) {
+                selectedItemId = id
+                break
+            }
+        }
+    }
+
+    const seedBigInt =
+        (BigInt(bytes[8]) << 56n) |
+        (BigInt(bytes[9]) << 48n) |
+        (BigInt(bytes[10]) << 40n) |
+        (BigInt(bytes[11]) << 32n) |
+        (BigInt(bytes[12]) << 24n) |
+        (BigInt(bytes[13]) << 16n) |
+        (BigInt(bytes[14]) << 8n) |
+        BigInt(bytes[15])
+
+    const rawRichness = (bytes[16] << 8) | bytes[17]
+    const normalized = rawRichness / 65535
+    const baseRichness = Math.floor(normalized * normalized * 999) + 1
+
+    let depthBonus = 0
+    if (stratum > 1) {
+        depthBonus = (50 * Math.log(stratum)) / Math.log(65535)
+    }
+    const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000)
+
+    return {itemId: selectedItemId, seed: seedBigInt, richness, reserve}
+}
+
+/**
+ * Derives the three stat values for a raw resource from a deposit's
+ * entropy seed (hash-based, weibull-transformed).
+ *
+ * **Use only on deposit seeds** — the bigint returned by `deriveStratum`
+ * or carried on a `MassDeposit`. Do NOT call this on a cargo item's
+ * `stats` field; cargo stats are bit-packed and must be read via
+ * `decodeStat` (or `decodeStackStats` for category-mapped output).
+ *
+ * Passing a cargo `stats` value here produces meaningless output
+ * (hash of the packed bits, unrelated to the actual stats).
+ */
+export function deriveResourceStats(seed: bigint): ResourceStats {
+    const seedBytes = new Uint8Array(8)
+    for (let i = 0; i < 8; i++) {
+        seedBytes[i] = Number(seed & 0xffn)
+        seed >>= 8n
+    }
+    const hashResult = Checksum256.hash(Bytes.from(seedBytes))
+    const hashBytes = hashResult.array
+
+    const extractU32 = (offset: number): number =>
+        (hashBytes[offset] * 0x1000000 +
+            (hashBytes[offset + 1] << 16) +
+            (hashBytes[offset + 2] << 8) +
+            hashBytes[offset + 3]) >>>
+        0
+
+    const weibull = (raw: number): number => {
+        const u = raw / 4294967296
+        let x = 0.24 * Math.sqrt(-Math.log(1 - u))
+        if (x > 1) x = 1
+        let val = Math.floor(x * 999) + 1
+        if (val > 999) val = 999
+        return val
+    }
+
+    return {
+        stat1: weibull(extractU32(0)),
+        stat2: weibull(extractU32(4)),
+        stat3: weibull(extractU32(8)),
+    }
+}

package/src/derivation/tiers.ts

@@ -0,0 +1,54 @@
+export type ReserveTier = 'small' | 'medium' | 'large' | 'massive' | 'motherlode'
+
+export interface TierRange {
+    min: number
+    max: number
+}
+
+export const RESERVE_TIERS: Record<ReserveTier, TierRange> = {
+    small: {min: 15, max: 60},
+    medium: {min: 100, max: 200},
+    large: {min: 400, max: 700},
+    massive: {min: 1000, max: 2500},
+    motherlode: {min: 4000, max: 10000},
+}
+
+const SHALLOW_THRESHOLDS = {
+    small: 0.8,
+    medium: 0.991946,
+    large: 0.999946,
+    massive: 0.999996,
+}
+
+const DEEP_THRESHOLDS = {
+    small: 0.5,
+    medium: 0.95892,
+    large: 0.99892,
+    massive: 0.99992,
+}
+
+export const TIER_ROLL_MAX = 0x10000 // 65536
+
+function lerp(a: number, b: number, t: number): number {
+    return a + (b - a) * t
+}
+
+export function rollTier(tierRoll: number, stratum: number): ReserveTier {
+    const d = Math.min(stratum, 65535) / 65535
+    const smallMax = lerp(SHALLOW_THRESHOLDS.small, DEEP_THRESHOLDS.small, d) * TIER_ROLL_MAX
+    const mediumMax = lerp(SHALLOW_THRESHOLDS.medium, DEEP_THRESHOLDS.medium, d) * TIER_ROLL_MAX
+    const largeMax = lerp(SHALLOW_THRESHOLDS.large, DEEP_THRESHOLDS.large, d) * TIER_ROLL_MAX
+    const massiveMax = lerp(SHALLOW_THRESHOLDS.massive, DEEP_THRESHOLDS.massive, d) * TIER_ROLL_MAX
+
+    if (tierRoll < smallMax) return 'small'
+    if (tierRoll < mediumMax) return 'medium'
+    if (tierRoll < largeMax) return 'large'
+    if (tierRoll < massiveMax) return 'massive'
+    return 'motherlode'
+}
+
+export function rollWithinTier(withinRoll: number, range: TierRange): number {
+    const u = withinRoll / 65535
+    const skewed = u * u
+    return Math.floor(range.min + skewed * (range.max - range.min))
+}

package/src/entities/cargo-utils.ts

@@ -12,17 +12,11 @@ export function totalCargoMass(cargo: EntityInventory[]): UInt64 {
     }, UInt64.from(0))
 }
 
-export function cargoValue(cargo: EntityInventory[]): UInt64 {
-    return cargo.reduce((sum, c) => {
-        return sum.adding(c.totalCost)
-    }, UInt64.from(0))
-}
-
-export function getCargoForGood(
+export function getCargoForItem(
     cargo: EntityInventory[],
     goodId: UInt64Type
 ): EntityInventory | undefined {
-    return cargo.find((c) => c.good_id.equals(goodId))
+    return cargo.find((c) => c.item_id.equals(goodId))
 }
 
 export function hasSpace(
@@ -47,84 +41,33 @@ export function isFull(currentMass: UInt64, maxCapacity: UInt64): boolean {
     return currentMass.gte(maxCapacity)
 }
 
-export interface SaleValue {
-    revenue: UInt64
-    profit: UInt64
-    cost: UInt64
-}
-
-export function calculateSaleValue(
-    cargo: ServerContract.Types.cargo_item[],
-    prices: Map<number, UInt64>
-): SaleValue {
-    if (cargo.length === 0) {
-        return {revenue: UInt64.from(0), profit: UInt64.from(0), cost: UInt64.from(0)}
-    }
-
-    let revenue = UInt64.from(0)
-    let cost = UInt64.from(0)
-
-    for (const item of cargo) {
-        if (UInt32.from(item.quantity).equals(UInt32.from(0))) continue
-
-        const goodId = Number(item.good_id)
-        const salePrice = prices.get(goodId)
-
-        if (salePrice) {
-            revenue = revenue.adding(salePrice.multiplying(item.quantity))
-        }
-
-        cost = cost.adding(item.unit_cost.multiplying(item.quantity))
-    }
-
-    const profit = revenue.gte(cost) ? revenue.subtracting(cost) : UInt64.from(0)
-
-    return {
-        revenue,
-        profit,
-        cost,
-    }
-}
-
-export function calculateSaleValueFromArray(
-    cargo: ServerContract.Types.cargo_item[],
-    prices: UInt64[]
-): SaleValue {
-    const priceMap = new Map<number, UInt64>()
-    prices.forEach((price, index) => {
-        priceMap.set(index, price)
-    })
-    return calculateSaleValue(cargo, priceMap)
-}
-
-export function afterSellGoods(
+export function afterRemoveItems(
     cargo: ServerContract.Types.cargo_item[],
-    goodsToSell: Array<{goodId: number; quantity: number}>
+    goodsToRemove: Array<{goodId: number; quantity: number}>
 ): EntityInventory[] {
     if (cargo.length === 0) {
         return []
     }
 
     return cargo.map((item) => {
-        const saleItem = goodsToSell.find((s) => Number(item.good_id) === s.goodId)
-        if (!saleItem) {
+        const removeItem = goodsToRemove.find((s) => Number(item.item_id) === s.goodId)
+        if (!removeItem) {
             return new EntityInventory(item)
         }
 
         const currentQty = Number(item.quantity)
-        const newQty = Math.max(0, currentQty - saleItem.quantity)
+        const newQty = Math.max(0, currentQty - removeItem.quantity)
 
         return new EntityInventory(
             ServerContract.Types.cargo_item.from({
-                good_id: item.good_id,
+                item_id: item.item_id,
                 quantity: UInt32.from(newQty),
-                unit_cost: item.unit_cost,
             })
         )
     })
 }
 
-export function afterSellAllGoods(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
+export function afterRemoveAllItems(cargo: ServerContract.Types.cargo_item[]): EntityInventory[] {
     if (cargo.length === 0) {
         return []
     }
@@ -133,9 +76,8 @@ export function afterSellAllGoods(cargo: ServerContract.Types.cargo_item[]): Ent
         (item) =>
             new EntityInventory(
                 ServerContract.Types.cargo_item.from({
-                    good_id: item.good_id,
+                    item_id: item.item_id,
                     quantity: UInt32.from(0),
-                    unit_cost: item.unit_cost,
                 })
             )
     )

package/src/entities/container.ts

@@ -13,6 +13,7 @@ export interface ContainerStateInput {
     hullmass: number
     capacity: number
     cargomass?: number
+    cargo?: ServerContract.Types.cargo_item[]
     schedule?: ServerContract.Types.schedule
 }
 
@@ -68,3 +69,39 @@ export class Container extends ServerContract.Types.entity_info {
         return this.coordinates.z?.toNumber() || 0
     }
 }
+
+export function computeContainerCapabilities(stats: Record<string, number>): {
+    hullmass: number
+    capacity: number
+} {
+    const density = stats['density'] ?? 500
+    const strength = stats['strength'] ?? 500
+    const hardness = stats['hardness'] ?? 500
+    const saturation = stats['saturation'] ?? 500
+
+    const hullmass = 25000 + 75 * density
+
+    const statSum = strength + hardness + saturation
+    const exponent = statSum / 2997
+    const capacity = Math.floor(1000000 * Math.pow(10, exponent))
+
+    return {hullmass, capacity}
+}
+
+export function computeContainerT2Capabilities(stats: Record<string, number>): {
+    hullmass: number
+    capacity: number
+} {
+    const strength = stats['strength'] ?? 0
+    const density = stats['density'] ?? 0
+    const hardness = stats['hardness'] ?? 0
+    const saturation = stats['saturation'] ?? 0
+
+    const hullmass = 20000 + 50 * density
+
+    const statSum = strength + hardness + saturation
+    const exponent = statSum / 2500
+    const capacity = Math.floor(1500000 * Math.pow(10, exponent))
+
+    return {hullmass, capacity}
+}

package/src/entities/entity-inventory.ts

@@ -1,34 +1,34 @@
 import {UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {getGood} from '../market/goods'
-import {Good} from '../types'
+import {getItem} from '../market/items'
+import {Item} from '../types'
 
 export class EntityInventory extends ServerContract.Types.cargo_item {
-    private _good?: Good
+    private _item?: Item
 
-    get good(): Good {
-        if (!this._good) {
-            this._good = getGood(this.good_id)
+    get item(): Item {
+        if (!this._item) {
+            this._item = getItem(this.item_id)
         }
-        return this._good
+        return this._item
+    }
+
+    get good(): Item {
+        return this.item
     }
 
     get name(): string {
-        return this.good.name
+        return this.item.name
     }
 
     get unitMass(): UInt32 {
-        return this.good.mass
+        return UInt32.from(this.item.mass)
     }
 
     get totalMass(): UInt64 {
         return UInt64.from(this.unitMass).multiplying(this.quantity)
     }
 
-    get totalCost(): UInt64 {
-        return this.unit_cost.multiplying(this.quantity)
-    }
-
     get hasCargo(): boolean {
         return UInt32.from(this.quantity).gt(UInt32.from(0))
     }

package/src/entities/inventory-accessor.ts

@@ -20,12 +20,8 @@ export class InventoryAccessor {
         return this.items.reduce((sum, c) => sum.adding(c.totalMass), UInt64.from(0))
     }
 
-    get totalValue(): UInt64 {
-        return this.items.reduce((sum, c) => sum.adding(c.totalCost), UInt64.from(0))
-    }
-
-    forGood(goodId: UInt64Type): EntityInventory | undefined {
-        return this.items.find((c) => c.good_id.equals(goodId))
+    forItem(goodId: UInt64Type): EntityInventory | undefined {
+        return this.items.find((c) => c.item_id.equals(goodId))
     }
 
     get sellable(): EntityInventory[] {

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, GoodPrice, LocationType} from '../types'
-import {getLocationType, hasSystem, isExtractableLocation} from '../utils/system'
+import {Checksum256, Checksum256Type, UInt16Type, UInt64} from '@wharfkit/antelope'
+import {Coordinates, CoordinatesType, Distance, LocationType} from '../types'
+import {getLocationType, hasSystem, isGatherableLocation} 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?: GoodPrice[]
     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))
+    isGatherableAt(gameSeed: Checksum256Type): boolean {
+        return isGatherableLocation(this.getLocationTypeAt(gameSeed))
     }
 
-    /**
-     * Set cached market prices for this location
-     */
-    setMarketPrices(prices: GoodPrice[]): void {
-        this._marketPrices = prices
-    }
-
-    /**
-     * Get cached market prices (returns undefined if not cached)
-     */
-    get marketPrices(): GoodPrice[] | undefined {
-        return this._marketPrices
-    }
-
-    /**
-     * Get price for a specific good (from cache)
-     */
-    getPrice(goodId: UInt16Type): GoodPrice | 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.good_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 GoodPrice.from({
-                        id: price.id,
-                        good: price.good,
-                        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.good_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,
-                        good_id: row.good_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