@shipload/sdk 1.0.0-next.41 → 1.0.0-next.43

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.41",
+    "version": "1.0.0-next.43",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

package/src/data/capabilities.ts

@@ -8,6 +8,14 @@ export interface StatMapping {
     stat: string
     capability: string
     attribute: string
+    source: string // producing module/role, always present
+}
+
+export interface CapabilityAttributeRow {
+    capability: string
+    attribute: string
+    description: string
+    source?: string // producing module/role; absent when no formula-derived producer exists
 }
 
 export const capabilityNames: string[] = [

package/src/data/recipes.json

@@ -376,7 +376,7 @@
         "quantity": 300
       },
       {
-        "itemId": 10006,
+        "itemId": 10010,
         "quantity": 300
       }
     ],
@@ -875,147 +875,5 @@
       }
     ],
     "blendWeights": []
-  },
-  {
-    "outputItemId": 20001,
-    "outputMass": 500,
-    "inputs": [
-      {
-        "itemId": 10001,
-        "quantity": 200
-      },
-      {
-        "itemId": 102,
-        "quantity": 15
-      }
-    ],
-    "statSlots": [
-      {
-        "sources": [
-          {
-            "inputIndex": 0,
-            "statIndex": 0
-          },
-          {
-            "inputIndex": 1,
-            "statIndex": 0
-          }
-        ]
-      },
-      {
-        "sources": [
-          {
-            "inputIndex": 0,
-            "statIndex": 1
-          },
-          {
-            "inputIndex": 1,
-            "statIndex": 2
-          }
-        ]
-      }
-    ],
-    "blendWeights": [
-      1,
-      1
-    ]
-  },
-  {
-    "outputItemId": 20002,
-    "outputMass": 300,
-    "inputs": [
-      {
-        "itemId": 10002,
-        "quantity": 200
-      },
-      {
-        "itemId": 402,
-        "quantity": 10
-      },
-      {
-        "itemId": 502,
-        "quantity": 20
-      }
-    ],
-    "statSlots": [
-      {
-        "sources": [
-          {
-            "inputIndex": 0,
-            "statIndex": 0
-          },
-          {
-            "inputIndex": 1,
-            "statIndex": 1
-          }
-        ]
-      },
-      {
-        "sources": [
-          {
-            "inputIndex": 0,
-            "statIndex": 1
-          },
-          {
-            "inputIndex": 2,
-            "statIndex": 2
-          }
-        ]
-      }
-    ],
-    "blendWeights": [
-      1,
-      1,
-      1
-    ]
-  },
-  {
-    "outputItemId": 20200,
-    "outputMass": 80000,
-    "inputs": [
-      {
-        "itemId": 20001,
-        "quantity": 600
-      },
-      {
-        "itemId": 20002,
-        "quantity": 200
-      }
-    ],
-    "statSlots": [
-      {
-        "sources": [
-          {
-            "inputIndex": 0,
-            "statIndex": 0
-          }
-        ]
-      },
-      {
-        "sources": [
-          {
-            "inputIndex": 0,
-            "statIndex": 1
-          }
-        ]
-      },
-      {
-        "sources": [
-          {
-            "inputIndex": 1,
-            "statIndex": 0
-          }
-        ]
-      },
-      {
-        "sources": [
-          {
-            "inputIndex": 1,
-            "statIndex": 1
-          }
-        ]
-      }
-    ],
-    "blendWeights": []
   }
 ]

package/src/derivation/capabilities.test.ts

@@ -21,8 +21,8 @@ import {
 import type {InstalledModule} from '../entities/slot-multiplier'
 import type {EntitySlot} from '../data/recipes-runtime'
 
-function makeGathererStats(strength: number, tolerance: number, conductivity: number): bigint {
-    return encodeStats([strength, tolerance, conductivity, 0])
+function makeGathererStats(strength: number, tolerance: number, saturation: number): bigint {
+    return encodeStats([strength, tolerance, saturation, 0])
 }
 
 function makeCrafterStats(reactivity: number, conductivity: number): bigint {
@@ -72,8 +72,8 @@ test('computeEntityCapabilities emits gathererLanes alongside legacy gatherer su
     expect(result.gathererLanes![1].slotIndex).toBe(1)
 
     // Yields are amp-scaled and distinct
-    const caps1 = computeGathererCapabilities({strength: 300, tolerance: 200, conductivity: 400}, 1)
-    const caps2 = computeGathererCapabilities({strength: 500, tolerance: 100, conductivity: 300}, 1)
+    const caps1 = computeGathererCapabilities({strength: 300, tolerance: 200, saturation: 400}, 1)
+    const caps2 = computeGathererCapabilities({strength: 500, tolerance: 100, saturation: 300}, 1)
     const expectedYield1 = applySlotMultiplier(caps1.yield, 100)
     const expectedYield2 = applySlotMultiplier(caps2.yield, 100)
     expect(result.gathererLanes![0].yield).toBe(expectedYield1)

package/src/derivation/capabilities.ts

@@ -77,7 +77,7 @@ export function computeGathererCapabilities(
     depth: number
 } {
     const str = stats.strength
-    const con = stats.conductivity
+    const con = stats.saturation
     const tol = stats.tolerance
 
     return {

package/src/derivation/capability-mappings.ts

@@ -18,7 +18,8 @@ import {
     ITEM_WAREHOUSE_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
 } from '../data/item-ids'
-import type {StatMapping} from '../data/capabilities'
+import type {StatMapping, CapabilityAttributeRow} from '../data/capabilities'
+import {capabilityAttributes} from '../data/capabilities'
 
 export const KIND_TO_ITEM_ID: Record<SlotConsumerKind, number> = {
     engine: ITEM_ENGINE_T1,
@@ -69,6 +70,12 @@ function traceToRawCategoryStat(
     return traceToRawCategoryStat(subRecipe, subSource, nextVisited)
 }
 
+// Producing role for a capability·attribute: entity hull slots all roll up to "Hull"; modules use their own name.
+export function sourceLabelForOutput(itemId: number): string {
+    const item = getItem(itemId)
+    return item.type === 'entity' ? 'Hull' : item.name
+}
+
 let cached: StatMapping[] | undefined
 
 export function deriveStatMappings(): StatMapping[] {
@@ -82,20 +89,22 @@ export function deriveStatMappings(): StatMapping[] {
         const itemId = KIND_TO_ITEM_ID[kind]
         const recipe = getRecipe(itemId)
         if (!recipe) continue
+        const source = sourceLabelForOutput(itemId)
         for (const [slotIdxStr, consumer] of Object.entries(slots)) {
             const slotIdx = Number(slotIdxStr)
             const slot = recipe.statSlots[slotIdx]
             if (!slot) continue
-            for (const source of slot.sources) {
-                const stat = traceToRawCategoryStat(recipe, source)
+            for (const src of slot.sources) {
+                const stat = traceToRawCategoryStat(recipe, src)
                 if (!stat) continue
-                const key = `${stat.label}|${consumer.capability}|${consumer.attribute}`
+                const key = `${stat.label}|${consumer.capability}|${consumer.attribute}|${source}`
                 if (seen.has(key)) continue
                 seen.add(key)
                 out.push({
                     stat: stat.label,
                     capability: consumer.capability,
                     attribute: consumer.attribute,
+                    source,
                 })
             }
         }
@@ -115,3 +124,39 @@ export function getStatMappingsForStat(stat: string): StatMapping[] {
 export function getStatMappingsForCapability(capability: string): StatMapping[] {
     return deriveStatMappings().filter((m) => m.capability === capability)
 }
+
+export function getProducersForAttribute(capability: string, attribute: string): string[] {
+    const seen = new Set<string>()
+    const out: string[] = []
+    for (const m of deriveStatMappings()) {
+        if (m.capability !== capability || m.attribute !== attribute) continue
+        if (seen.has(m.source)) continue
+        seen.add(m.source)
+        out.push(m.source)
+    }
+    return out
+}
+
+export function getCapabilityAttributeRows(): CapabilityAttributeRow[] {
+    const rows: CapabilityAttributeRow[] = []
+    for (const ca of capabilityAttributes) {
+        const producers = getProducersForAttribute(ca.capability, ca.attribute)
+        if (producers.length === 0) {
+            rows.push({
+                capability: ca.capability,
+                attribute: ca.attribute,
+                description: ca.description,
+            })
+            continue
+        }
+        for (const source of producers) {
+            rows.push({
+                capability: ca.capability,
+                attribute: ca.attribute,
+                description: ca.description,
+                source,
+            })
+        }
+    }
+    return rows
+}

package/src/derivation/recipe-usage.test.ts

@@ -26,14 +26,12 @@ test('getRecipeConsumers lists every recipe that consumes Sensor', () => {
     const consumers = getRecipeConsumers(ITEM_SENSOR)
     const ids = consumers.map((c) => c.outputItemId).sort((a, b) => a - b)
     expect(ids).toEqual(
-        [ITEM_GATHERER_T1, ITEM_CRAFTER_T1, ITEM_SHIP_T1_PACKED, ITEM_EXTRACTOR_T1_PACKED].sort(
-            (a, b) => a - b
-        )
+        [ITEM_CRAFTER_T1, ITEM_SHIP_T1_PACKED, ITEM_EXTRACTOR_T1_PACKED].sort((a, b) => a - b)
     )
 })
 
-test('Sensor feeds the gatherer drain stat', () => {
-    const consumers = getRecipeConsumers(ITEM_SENSOR)
+test('Resin feeds the gatherer drain stat', () => {
+    const consumers = getRecipeConsumers(ITEM_RESIN)
     const gatherer = consumers.find((c) => c.outputItemId === ITEM_GATHERER_T1)
     expect(gatherer).toBeDefined()
     const drain = gatherer?.statFlows.find(
@@ -58,11 +56,12 @@ test('getResourceDemand traces a dual-resource component to both resources', ()
 })
 
 test('getResourceDemand recurses through a module to raw resources', () => {
-    // Gatherer = 300 Beam (5 ore + 5 gas each) + 300 Sensor (10 crystal each)
+    // Gatherer = 300 Beam (5 ore + 5 gas each) + 300 Resin (5 biomass + 5 crystal each)
     expect(getResourceDemand(ITEM_GATHERER_T1)).toEqual({
         ore: 1500,
         gas: 1500,
-        crystal: 3000,
+        biomass: 1500,
+        crystal: 1500,
     })
 })
 
@@ -70,9 +69,9 @@ test('getResourceDemand scales by quantity', () => {
     expect(getResourceDemand(ITEM_PLATE, 3)).toEqual({ore: 30})
 })
 
-test('getComponentDemand reports Resin as consumed by exactly one recipe', () => {
+test('getComponentDemand reports Resin as consumed by two recipes', () => {
     const demand = getComponentDemand()
     const resin = demand.find((d) => d.itemId === ITEM_RESIN)
     expect(resin).toBeDefined()
-    expect(resin?.consumerCount).toBe(1)
+    expect(resin?.consumerCount).toBe(2)
 })

package/src/derivation/wormhole.ts

@@ -1,5 +1,6 @@
 import type {Checksum256Type} from '@wharfkit/antelope'
 import {hash512} from '../utils/hash'
+import {COORD_MAX, COORD_MIN} from '../coordinates/constants'
 
 export const WH = {
     RSIZE: 75,
@@ -72,6 +73,9 @@ function endpointInRegion(seed: Checksum256Type, R: Region, key: string): {x: nu
 function dist(a: {x: number; y: number}, b: {x: number; y: number}): number {
     return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2)
 }
+function inBounds(c: {x: number; y: number}): boolean {
+    return c.x >= COORD_MIN && c.x <= COORD_MAX && c.y >= COORD_MIN && c.y <= COORD_MAX
+}
 function wormholeOfRegion(
     seed: Checksum256Type,
     R: Region
@@ -82,6 +86,7 @@ function wormholeOfRegion(
     if (roll16(seed, `wh-exists-${key}`) >= WH.THRESHOLD) return null
     const A = endpointInRegion(seed, R, key)
     const B = endpointInRegion(seed, P, key)
+    if (!inBounds(A) || !inBounds(B)) return null
     if (dist(A, B) < WH.MIN_REACH) return null
     return {A, B}
 }

package/src/index-module.ts

@@ -50,6 +50,7 @@ export {
     ConstructionManager,
 } from './managers'
 export type {
+    PlayerRosterEntry,
     LocationStratum,
     NftConfigForItem,
     BuildableTarget,
@@ -206,11 +207,12 @@ export type {
     HasScheduleAndLocation,
 } from './travel/travel'
 
-export {planRoute, sdkSystemGraph, MAX_LEGS} from './travel/route-planner'
+export {planRoute, sdkSystemGraph, setScanProvider, MAX_LEGS} from './travel/route-planner'
 export type {
     Coord,
     Neighbor,
     SystemGraph,
+    ScanProvider,
     RoutePlan,
     RouteFailure,
     RouteResult,
@@ -281,6 +283,17 @@ export type {
     CancelEligibilityInput,
 } from './scheduling/cancel'
 
+export {
+    derivedLoaders,
+    estimateUnwrapDuration,
+    incomingHoldMass,
+    projectedPeakCargomass,
+    receiveFits,
+    unwrapLoadDuration,
+    unwrapTransitDuration,
+} from './scheduling/unwrap'
+export type {DerivedLoaders, UnwrapDestination, UnwrapItem} from './scheduling/unwrap'
+
 export {
     projectedCargoAvailableAt,
     availableForItem,
@@ -346,13 +359,16 @@ export {
     isInvertedAttribute,
     getCapabilityAttributes,
 } from './data/capabilities'
-export type {CapabilityAttribute, StatMapping} from './data/capabilities'
+export type {CapabilityAttribute, StatMapping, CapabilityAttributeRow} from './data/capabilities'
 
 export {
     deriveStatMappings,
     getStatMappings,
     getStatMappingsForStat,
     getStatMappingsForCapability,
+    getProducersForAttribute,
+    getCapabilityAttributeRows,
+    sourceLabelForOutput,
 } from './derivation/capability-mappings'
 export {SLOT_FORMULAS} from './data/capability-formulas'
 export type {SlotConsumer, SlotConsumerKind} from './data/capability-formulas'
@@ -420,6 +436,7 @@ export {
     feistelInv,
     regionOf,
     partnerRegion,
+    nearbyWormholes,
     wormholeAt,
     wormholeAtRegionEndpoint,
     isValidWormholePair,

package/src/managers/actions.ts

@@ -593,6 +593,23 @@ export class ActionsManager extends BaseManager {
         )
     }
 
+    sendAsset(owner: NameType, recipient: NameType, assetId: UInt64Type, memo = ''): Action {
+        return Action.from(
+            {
+                account: this.atomicAssetsAccount,
+                name: 'transfer',
+                authorization: [{actor: Name.from(owner), permission: 'active'}],
+                data: {
+                    from: Name.from(owner),
+                    to: Name.from(recipient),
+                    asset_ids: [UInt64.from(assetId)],
+                    memo,
+                },
+            },
+            ATOMICASSETS_ABI
+        )
+    }
+
     // Two top-level actions the wallet signs to unwrap an NFT into a host's cargo.
     unwrapCargoTx(owner: NameType, assetId: UInt64Type, hostId: UInt64Type): Action[] {
         return [this.transferForUnwrap(owner, assetId), this.placecargo(owner, hostId, assetId)]

package/src/managers/entities.ts

@@ -34,6 +34,15 @@ export class EntitiesManager extends BaseManager {
         return entities.map((e) => new Entity(e))
     }
 
+    async getAllEntities(kind?: EntityTypeName): Promise<ServerContract.Types.entity_row[]> {
+        const rows = await this.server.table('entity').all()
+        if (!kind) {
+            return rows
+        }
+        const wanted = Name.from(kind)
+        return rows.filter((row) => wanted.equals(row.kind))
+    }
+
     async getSummaries(
         owner: NameType | ServerContract.Types.player_row,
         kind?: EntityTypeName

package/src/managers/index.ts

@@ -3,6 +3,7 @@ export {BaseManager} from './base'
 export {EntitiesManager} from './entities'
 export type {EntityTypeName} from './entities'
 export {PlayersManager} from './players'
+export type {PlayerRosterEntry} from './players'
 export {LocationsManager} from './locations'
 export type {LocationStratum} from './locations'
 export {EpochsManager} from './epochs'

package/src/managers/players.ts

@@ -2,6 +2,11 @@ import {Name, type NameType} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {Player} from '../entities/player'
 
+export interface PlayerRosterEntry {
+    owner: Name
+    company?: string
+}
+
 export class PlayersManager extends BaseManager {
     async getPlayer(account: NameType): Promise<Player | undefined> {
         const playerRow = await this.server.table('player').get(Name.from(account))
@@ -10,4 +15,24 @@ export class PlayersManager extends BaseManager {
         }
         return new Player(playerRow)
     }
+
+    async getPlayers(): Promise<Player[]> {
+        const rows = await this.server.table('player').all()
+        return rows.map((row) => new Player(row))
+    }
+
+    async getRoster(): Promise<PlayerRosterEntry[]> {
+        const [players, companies] = await Promise.all([
+            this.server.table('player').all(),
+            this.platform.table('company').all(),
+        ])
+        const companyNames = new Map<string, string>()
+        for (const company of companies) {
+            companyNames.set(company.account.toString(), company.name)
+        }
+        return players.map((player) => ({
+            owner: player.owner,
+            company: companyNames.get(player.owner.toString()),
+        }))
+    }
 }

package/src/nft/buildImmutableData.ts

@@ -203,8 +203,8 @@ export function buildModuleImmutable(
             const ref = decodeStat(stats, 3)
             base.push({first: 'strength', second: ['uint16', str]})
             base.push({first: 'tolerance', second: ['uint16', tol]})
-            base.push({first: 'conductivity', second: ['uint16', con]})
-            base.push({first: 'reflectivity', second: ['uint16', ref]})
+            base.push({first: 'saturation', second: ['uint16', con]})
+            base.push({first: 'plasticity', second: ['uint16', ref]})
             base.push({first: 'yield', second: ['uint16', computeGathererYield(str)]})
             base.push({first: 'drain', second: ['uint16', computeGathererDrain(con)]})
             base.push({first: 'depth', second: ['uint16', computeGathererDepth(tol, item.tier)]})