@shipload/sdk 1.0.0-next.72 → 1.0.0-next.74

package/src/managers/jobs.test.ts

@@ -41,7 +41,7 @@ describe('JobsManager.getOwnedJobs', () => {
         expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
     })
 
-    it('reports an undeposited row as dropping off, whatever its window says', async () => {
+    it('reports a legacy undeposited row (inputs only) as dropping off, whatever its window says', async () => {
         const inFlight = row({
             deposited: false,
             cargo: [{item: 'in'}],
@@ -57,6 +57,27 @@ describe('JobsManager.getOwnedJobs', () => {
         expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
     })
 
+    it('reads a booking-time undeposited row whose input is booked as more than one stack', async () => {
+        const inFlight = row({
+            deposited: false,
+            cargo: [
+                {item_id: 101, quantity: 20},
+                {item_id: 101, quantity: 30},
+            ],
+        })
+        const m = managerWith(
+            async () => [inFlight],
+            async () => []
+        )
+        const jobs = await m.getOwnedJobs(OWNER, {now: new Date('2026-07-26T11:30:00Z')})
+        expect(jobs[0].status).toBe('dropping')
+        expect(jobs[0].inputs).toEqual([
+            {item_id: 101, quantity: 20},
+            {item_id: 101, quantity: 30},
+        ] as never)
+        expect(jobs[0].output).toBeNull()
+    })
+
     it('reports a cancelled row as ready with its inputs held', async () => {
         const cancelled = row({
             quantity: {toNumber: () => 0},
@@ -94,3 +115,63 @@ describe('JobsManager.getOwnedJobs', () => {
         expect(jobs).toHaveLength(1)
     })
 })
+
+const buildRow = (over: Record<string, unknown> = {}) => ({
+    id: {toNumber: () => 9},
+    building: {toNumber: () => 2},
+    socket: {toNumber: () => 1},
+    target: {toNumber: () => 5},
+    owner: Name.from(OWNER),
+    coords: {x: {toNumber: () => 0}, y: {toNumber: () => 0}},
+    starts_at: {toDate: () => new Date('2026-07-26T10:00:00Z')},
+    completes_at: {toDate: () => new Date('2026-07-26T11:00:00Z')},
+    arrives_at: {toDate: () => new Date('2026-07-26T09:45:00Z')},
+    target_item_id: {toNumber: () => 10212},
+    cargo: [{item: 'in'}],
+    deposited: true,
+    ...over,
+})
+
+function managerWithReadonly(impl: (name: string, data: unknown) => Promise<unknown>) {
+    const ctx = {server: {readonly: impl}} as never
+    return new JobsManager(ctx)
+}
+
+describe('JobsManager.getBuildJobs', () => {
+    it('reads the dock queue through getbuildjobs and parses every row', async () => {
+        let called: unknown = null
+        const m = managerWithReadonly(async (name, data) => {
+            called = {name, data}
+            return {jobs: [buildRow(), buildRow({id: {toNumber: () => 10}, deposited: false})]}
+        })
+        const jobs = await m.getBuildJobs(2, {now: new Date('2026-07-26T11:30:00Z')})
+        expect(called).toMatchObject({name: 'getbuildjobs'})
+        expect(String((called as {data: {building_id: unknown}}).data.building_id)).toBe('2')
+        expect(jobs).toHaveLength(2)
+        expect(jobs[0]).toMatchObject({
+            id: 9,
+            building: 2,
+            socket: 1,
+            targetId: 5,
+            owner: OWNER,
+            targetItemId: 10212,
+            deposited: true,
+            status: 'ready',
+        })
+        expect(jobs[0].coords).toEqual({x: 0, y: 0})
+        expect(jobs[0].arrivesAt).toEqual(new Date('2026-07-26T09:45:00Z'))
+        expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
+        expect(jobs[1].status).toBe('dropping')
+    })
+
+    it('reports a booked row before its window as queued', async () => {
+        const m = managerWithReadonly(async () => ({jobs: [buildRow()]}))
+        const jobs = await m.getBuildJobs(2, {now: new Date('2026-07-26T09:50:00Z')})
+        expect(jobs[0].status).toBe('queued')
+    })
+
+    it('returns an empty list when the result carries no jobs', async () => {
+        const m = managerWithReadonly(async () => ({}))
+        expect(await m.getBuildJobs(2)).toEqual([])
+    })
+})

package/src/managers/jobs.ts

@@ -1,9 +1,16 @@
-import {Name, type NameType} from '@wharfkit/antelope'
+import {Name, UInt64, type NameType, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {jobDeposited, jobStatus, splitJobCargo, type OwnedJob} from '../scheduling/jobs'
+import {
+    jobDeposited,
+    jobStatus,
+    splitJobCargo,
+    type BuildJob,
+    type OwnedJob,
+} from '../scheduling/jobs'
 import type {ServerContract} from '../contracts'
 
 type JobRow = ServerContract.Types.craftjob_row
+type BuildJobRow = ServerContract.Types.buildjob_row
 
 export class JobsManager extends BaseManager {
     async getOwnedJobs(owner: NameType, opts?: {now?: Date}): Promise<OwnedJob[]> {
@@ -29,6 +36,38 @@ export class JobsManager extends BaseManager {
         return rows.filter((r) => ownerName.equals(r.owner)).map((r) => this.parseOwnedJob(r, now))
     }
 
+    async getBuildJobs(dockId: UInt64Type, opts?: {now?: Date}): Promise<BuildJob[]> {
+        const now = opts?.now ?? new Date()
+        const result = (await this.server.readonly('getbuildjobs', {
+            building_id: UInt64.from(dockId),
+        })) as ServerContract.Types.buildjobs_result | undefined
+        return (result?.jobs ?? []).map((r) => this.parseBuildJob(r, now))
+    }
+
+    private parseBuildJob(r: BuildJobRow, now: Date): BuildJob {
+        const startsAt = r.starts_at.toDate()
+        const completesAt = r.completes_at.toDate()
+        const arrivesAt = r.arrives_at.toDate()
+        const deposited = jobDeposited(r.deposited)
+        const building = r.building.toNumber()
+        const inputs = [...r.cargo]
+        return {
+            id: r.id.toNumber(),
+            building,
+            socket: r.socket.toNumber(),
+            targetId: r.target.toNumber(),
+            owner: r.owner.toString(),
+            coords: {x: r.coords.x.toNumber(), y: r.coords.y.toNumber()},
+            startsAt,
+            completesAt,
+            arrivesAt,
+            targetItemId: r.target_item_id.toNumber(),
+            status: jobStatus({startsAt, completesAt, arrivesAt, deposited, building, inputs}, now),
+            deposited,
+            inputs,
+        }
+    }
+
     private parseOwnedJob(r: JobRow, now: Date): OwnedJob {
         const startsAt = r.starts_at.toDate()
         const completesAt = r.completes_at.toDate()

package/src/managers/nft.test.ts

@@ -1,5 +1,8 @@
 import {describe, expect, test} from 'bun:test'
-import {resolveLockedAmount, wrapCostKey} from './nft'
+import {Asset, Name} from '@wharfkit/antelope'
+import {NftManager, resolveLockedAmount, wrapCostKey} from './nft'
+import type {GameContext} from './context'
+import {ServerContract} from '../contracts'
 
 describe('resolveLockedAmount', () => {
     test('no fee refunds the full cost', () => {
@@ -19,3 +22,172 @@ describe('wrapCostKey', () => {
         expect(wrapCostKey(3, 2).toString()).toBe('770')
     })
 })
+
+interface StubOptions {
+    wrapConfig?: {fee_pct: number; fee_account: string; min_asset_id?: number} | null
+    wrapCosts?: {item_type: number; tier: number; amount: number}[]
+    depositConfig?: {tokenContract: string; symbol: string} | null
+}
+
+function stubContext(options: StubOptions = {}) {
+    const counts = {wrapconfig: 0, wrapcost: 0, depositcfg: 0}
+    const costRows = (options.wrapCosts ?? []).map((row) =>
+        ServerContract.Types.wrapcost_row.from(row)
+    )
+    const server = {
+        table(name: string) {
+            if (name === 'wrapconfig') {
+                return {
+                    get: async () => {
+                        counts.wrapconfig++
+                        return options.wrapConfig
+                            ? ServerContract.Types.wrapconfig_row.from({
+                                  ...options.wrapConfig,
+                                  min_asset_id: options.wrapConfig.min_asset_id ?? 0,
+                              })
+                            : undefined
+                    },
+                }
+            }
+            if (name === 'wrapcost') {
+                return {
+                    get: async (key: {toString(): string}) => {
+                        counts.wrapcost++
+                        return costRows.find(
+                            (row) =>
+                                wrapCostKey(Number(row.item_type), Number(row.tier)).toString() ===
+                                key.toString()
+                        )
+                    },
+                }
+            }
+            throw new Error(`unexpected table: ${name}`)
+        },
+    }
+    const balances = {
+        getDepositConfig: async () => {
+            counts.depositcfg++
+            return options.depositConfig
+                ? {
+                      tokenContract: Name.from(options.depositConfig.tokenContract),
+                      symbol: Asset.Symbol.from(options.depositConfig.symbol),
+                  }
+                : null
+        },
+    }
+    const context = {server, balances} as unknown as GameContext
+    return {manager: new NftManager(context), counts}
+}
+
+const DEPOSIT = {tokenContract: 'scrap.gm', symbol: '0,SCRAP'}
+
+describe('setWrapConfig', () => {
+    test('a seeded config keeps getWrapConfig off the chain', async () => {
+        const {manager, counts} = stubContext({wrapConfig: {fee_pct: 200, fee_account: 'fee.gm'}})
+        manager.setWrapConfig({feePctBasisPoints: 200, feeAccount: 'fee.gm'})
+
+        const config = await manager.getWrapConfig()
+        expect(config?.feePctBasisPoints).toBe(200)
+        expect(String(config?.feeAccount)).toBe('fee.gm')
+        expect(counts.wrapconfig).toBe(0)
+    })
+
+    test('a reload still reaches the chain', async () => {
+        const {manager, counts} = stubContext({wrapConfig: {fee_pct: 200, fee_account: 'fee.gm'}})
+        manager.setWrapConfig({feePctBasisPoints: 200, feeAccount: 'fee.gm'})
+        await manager.getWrapConfig(true)
+        expect(counts.wrapconfig).toBe(1)
+    })
+
+    test('seeding null records a chain with no wrap fee configured', async () => {
+        const {manager, counts} = stubContext({wrapConfig: {fee_pct: 200, fee_account: 'fee.gm'}})
+        manager.setWrapConfig(null)
+        expect(await manager.getWrapConfig()).toBeNull()
+        expect(counts.wrapconfig).toBe(0)
+    })
+})
+
+describe('setWrapCosts', () => {
+    test('a seeded cost keeps getWrapCost off the chain', async () => {
+        const {manager, counts} = stubContext({
+            wrapCosts: [{item_type: 3, tier: 2, amount: 500}],
+        })
+        manager.setWrapCosts([{itemType: 3, tier: 2, units: 500n}])
+
+        expect(await manager.getWrapCost(3, 2)).toBe(500n)
+        expect(counts.wrapcost).toBe(0)
+    })
+
+    test('an item missing from the seed falls back to chain', async () => {
+        const {manager, counts} = stubContext({
+            wrapCosts: [{item_type: 3, tier: 2, amount: 500}],
+        })
+        manager.setWrapCosts([{itemType: 3, tier: 2, units: 500n}])
+
+        expect(await manager.getWrapCost(9, 1)).toBe(0n)
+        expect(counts.wrapcost).toBe(1)
+    })
+
+    test('a reload still reaches the chain', async () => {
+        const {manager, counts} = stubContext({
+            wrapCosts: [{item_type: 3, tier: 2, amount: 500}],
+        })
+        manager.setWrapCosts([{itemType: 3, tier: 2, units: 500n}])
+        await manager.getWrapCost(3, 2, true)
+        expect(counts.wrapcost).toBe(1)
+    })
+})
+
+describe('getWrapDeposit', () => {
+    test('with every seed present, makes no chain reads', async () => {
+        const {manager, counts} = stubContext({
+            wrapCosts: [{item_type: 3, tier: 2, amount: 500}],
+            wrapConfig: {fee_pct: 200, fee_account: 'fee.gm'},
+            depositConfig: DEPOSIT,
+        })
+        manager.setWrapCosts([{itemType: 3, tier: 2, units: 500n}])
+        manager.setWrapConfig({feePctBasisPoints: 200, feeAccount: 'fee.gm'})
+
+        const deposit = await manager.getWrapDeposit(3, 2)
+        expect(deposit).toEqual({
+            cost: 500n,
+            refund: 490n,
+            feePct: 2,
+            symbol: 'SCRAP',
+            precision: 0,
+            tokenContract: 'scrap.gm',
+        })
+        expect(counts.wrapcost).toBe(0)
+        expect(counts.wrapconfig).toBe(0)
+        // getDepositConfig is a BalancesManager concern seeded separately; this stub always calls through.
+        expect(counts.depositcfg).toBe(1)
+    })
+
+    test('with nothing seeded, falls back to chain for config and cost', async () => {
+        const {manager, counts} = stubContext({
+            wrapCosts: [{item_type: 3, tier: 2, amount: 500}],
+            wrapConfig: {fee_pct: 200, fee_account: 'fee.gm'},
+            depositConfig: DEPOSIT,
+        })
+
+        const deposit = await manager.getWrapDeposit(3, 2)
+        expect(deposit?.cost).toBe(500n)
+        expect(counts.wrapcost).toBe(1)
+        expect(counts.wrapconfig).toBe(1)
+    })
+
+    test('reload true bypasses seeds and reaches chain', async () => {
+        const {manager, counts} = stubContext({
+            wrapCosts: [{item_type: 3, tier: 2, amount: 500}],
+            wrapConfig: {fee_pct: 200, fee_account: 'fee.gm'},
+            depositConfig: DEPOSIT,
+        })
+        manager.setWrapCosts([{itemType: 3, tier: 2, units: 500n}])
+        manager.setWrapConfig({feePctBasisPoints: 200, feeAccount: 'fee.gm'})
+
+        await manager.getWrapDeposit(3, 2, {reload: true})
+        expect(counts.wrapcost).toBe(1)
+        expect(counts.wrapconfig).toBe(1)
+        expect(counts.depositcfg).toBe(1)
+    })
+})

package/src/managers/nft.ts

@@ -12,6 +12,17 @@ export interface WrapConfig {
     feeAccount: Name
 }
 
+export interface WrapConfigInput {
+    feePctBasisPoints: number
+    feeAccount: NameType
+}
+
+export interface WrapCostInput {
+    itemType: number
+    tier: number
+    units: bigint | string | number
+}
+
 export interface WrapGate {
     owner: Name
     game: Name
@@ -39,6 +50,7 @@ export function wrapCostKey(itemType: number, tier: number): UInt64 {
 export class NftManager extends BaseManager {
     private cache = new Map<string, NftConfigForItem | null>()
     private wrapConfig?: WrapConfig | null
+    private wrapCosts?: Map<string, bigint> | null
 
     async getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined> {
         const id = UInt64.from(itemId)
@@ -56,6 +68,23 @@ export class NftManager extends BaseManager {
         return result ?? undefined
     }
 
+    setWrapConfig(config: WrapConfigInput | null): void {
+        this.wrapConfig = config
+            ? {
+                  feePctBasisPoints: config.feePctBasisPoints,
+                  feeAccount: Name.from(config.feeAccount),
+              }
+            : null
+    }
+
+    setWrapCosts(costs: WrapCostInput[] | null): void {
+        this.wrapCosts = costs
+            ? new Map(
+                  costs.map((c) => [wrapCostKey(c.itemType, c.tier).toString(), BigInt(c.units)])
+              )
+            : null
+    }
+
     async getWrapConfig(reload = false): Promise<WrapConfig | null> {
         if (!reload && this.wrapConfig !== undefined) {
             return this.wrapConfig
@@ -69,7 +98,11 @@ export class NftManager extends BaseManager {
         return this.wrapConfig
     }
 
-    async getWrapCost(itemType: number, tier: number): Promise<bigint> {
+    async getWrapCost(itemType: number, tier: number, reload = false): Promise<bigint> {
+        if (!reload && this.wrapCosts) {
+            const seeded = this.wrapCosts.get(wrapCostKey(itemType, tier).toString())
+            if (seeded !== undefined) return seeded
+        }
         const row = (await this.server.table('wrapcost').get(wrapCostKey(itemType, tier))) as
             | ServerContract.Types.wrapcost_row
             | undefined
@@ -81,7 +114,7 @@ export class NftManager extends BaseManager {
         tier: number,
         opts: {reload?: boolean} = {}
     ): Promise<WrapDeposit | null> {
-        const cost = await this.getWrapCost(itemType, tier)
+        const cost = await this.getWrapCost(itemType, tier, opts.reload)
         if (cost === 0n) return null
 
         const wrapConfig = await this.getWrapConfig(opts.reload)