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

package/src/managers/actions.ts

@@ -332,25 +332,35 @@ export class ActionsManager extends BaseManager {
     depotstore(
         shipId: UInt64Type,
         depotId: UInt64Type,
-        items: ServerContract.ActionParams.Type.cargo_item[]
+        items: ServerContract.ActionParams.Type.cargo_item[],
+        shuttledBy?: UInt64Type
     ): Action {
-        return this.server.action('depotstore', {
+        const params: ServerContract.ActionParams.depotstore = {
             ship_id: UInt64.from(shipId),
             depot_id: UInt64.from(depotId),
             items,
-        })
+        }
+        if (shuttledBy !== undefined) {
+            params.shuttled_by = UInt64.from(shuttledBy)
+        }
+        return this.server.action('depotstore', params)
     }
 
     depottake(
         shipId: UInt64Type,
         depotId: UInt64Type,
-        items: ServerContract.ActionParams.Type.cargo_item[]
+        items: ServerContract.ActionParams.Type.cargo_item[],
+        shuttledBy?: UInt64Type
     ): Action {
-        return this.server.action('depottake', {
+        const params: ServerContract.ActionParams.depottake = {
             ship_id: UInt64.from(shipId),
             depot_id: UInt64.from(depotId),
             items,
-        })
+        }
+        if (shuttledBy !== undefined) {
+            params.shuttled_by = UInt64.from(shuttledBy)
+        }
+        return this.server.action('depottake', params)
     }
 
     shuttle(
@@ -518,7 +528,8 @@ export class ActionsManager extends BaseManager {
         workshopId: UInt64Type,
         recipeId: UInt16Type,
         quantity: UInt32Type,
-        inputs: ServerContract.ActionParams.Type.cargo_item[]
+        inputs: ServerContract.ActionParams.Type.cargo_item[],
+        shuttledBy?: UInt64Type
     ): Action {
         const params: ServerContract.ActionParams.craftjob = {
             ship_id: UInt64.from(shipId),
@@ -527,6 +538,9 @@ export class ActionsManager extends BaseManager {
             quantity: UInt32.from(quantity),
             inputs,
         }
+        if (shuttledBy !== undefined) {
+            params.shuttled_by = UInt64.from(shuttledBy)
+        }
         return this.server.action('craftjob', params)
     }
 
@@ -540,6 +554,9 @@ export class ActionsManager extends BaseManager {
     canceljob(route: JobCancelRoute): Action {
         if (route.kind === 'dropoff') return this.cancel(route.shipId, route.laneKey, route.count)
         if (route.kind === 'build') return this.cancelbuild(route.jobId)
+        if (route.kind === 'civic') {
+            return this.cancelcivic(route.buildingId, route.laneKey, route.fromId)
+        }
         return this.cancelcraft(route.jobId)
     }
 
@@ -566,11 +583,14 @@ export class ActionsManager extends BaseManager {
         return this.server.action('clustercraft', params)
     }
 
-    claimcraft(jobId: UInt64Type, shipId: UInt64Type): Action {
+    claimcraft(jobId: UInt64Type, shipId: UInt64Type, shuttledBy?: UInt64Type): Action {
         const params: ServerContract.ActionParams.claimcraft = {
             job_id: UInt64.from(jobId),
             ship_id: UInt64.from(shipId),
         }
+        if (shuttledBy !== undefined) {
+            params.shuttled_by = UInt64.from(shuttledBy)
+        }
         return this.server.action('claimcraft', params)
     }
 
@@ -578,7 +598,8 @@ export class ActionsManager extends BaseManager {
         targetId: UInt64Type,
         dockId: UInt64Type,
         targetItemId: UInt16Type,
-        inputs: ServerContract.ActionParams.Type.cargo_item[]
+        inputs: ServerContract.ActionParams.Type.cargo_item[],
+        shuttledBy?: UInt64Type
     ): Action {
         const params: ServerContract.ActionParams.buildjob = {
             target_id: UInt64.from(targetId),
@@ -586,6 +607,9 @@ export class ActionsManager extends BaseManager {
             target_item_id: UInt16.from(targetItemId),
             inputs,
         }
+        if (shuttledBy !== undefined) {
+            params.shuttled_by = UInt64.from(shuttledBy)
+        }
         return this.server.action('buildjob', params)
     }
 
@@ -596,10 +620,13 @@ export class ActionsManager extends BaseManager {
         return this.server.action('claimbuild', params)
     }
 
-    cancelbuild(jobId: UInt64Type): Action {
+    cancelbuild(jobId: UInt64Type, shuttledBy?: UInt64Type): Action {
         const params: ServerContract.ActionParams.cancelbuild = {
             job_id: UInt64.from(jobId),
         }
+        if (shuttledBy !== undefined) {
+            params.shuttled_by = UInt64.from(shuttledBy)
+        }
         return this.server.action('cancelbuild', params)
     }
 

package/src/managers/balances.test.ts

@@ -78,6 +78,39 @@ describe('getDepositConfig', () => {
     })
 })
 
+describe('setDepositConfig', () => {
+    test('a seeded config keeps every balance read off the chain', async () => {
+        const {manager, counts} = stubContext({
+            depositConfig: SCRAP,
+            balances: [{token_contract: 'scrap.gm', balance: '5 SCRAP'}],
+            wallet: ['7 SCRAP'],
+        })
+        manager.setDepositConfig({tokenContract: 'scrap.gm', symbol: '0,SCRAP'})
+
+        const config = await manager.getDepositConfig()
+        expect(String(config?.tokenContract)).toBe('scrap.gm')
+        expect(String(config?.symbol)).toBe('0,SCRAP')
+        await manager.getPlatformBalance('alice')
+        await manager.getWalletBalance('alice')
+
+        expect(counts.depositcfg).toBe(0)
+    })
+
+    test('a reload still reaches the chain', async () => {
+        const {manager, counts} = stubContext({depositConfig: SCRAP})
+        manager.setDepositConfig({tokenContract: 'scrap.gm', symbol: '0,SCRAP'})
+        await manager.getDepositConfig(true)
+        expect(counts.depositcfg).toBe(1)
+    })
+
+    test('seeding null records a chain with no deposit token', async () => {
+        const {manager, counts} = stubContext({depositConfig: SCRAP})
+        manager.setDepositConfig(null)
+        expect(await manager.getDepositConfig()).toBeNull()
+        expect(counts.depositcfg).toBe(0)
+    })
+})
+
 describe('getPlatformBalance', () => {
     test('returns null when the owner has never opened a row', async () => {
         const {manager} = stubContext({depositConfig: SCRAP, balances: []})

package/src/managers/balances.ts

@@ -7,6 +7,11 @@ export interface DepositConfig {
     symbol: Asset.Symbol
 }
 
+export interface DepositConfigInput {
+    tokenContract: NameType
+    symbol: Asset.SymbolType
+}
+
 export interface PlatformBalance {
     owner: Name
     tokenContract: Name
@@ -22,6 +27,16 @@ export interface TokenBalance {
 export class BalancesManager extends BaseManager {
     private depositConfig?: DepositConfig | null
 
+    // A caller holding the config already, from the indexer or its own cache, seeds it here so no balance read reaches the chain for it.
+    setDepositConfig(config: DepositConfigInput | null): void {
+        this.depositConfig = config
+            ? {
+                  tokenContract: Name.from(config.tokenContract),
+                  symbol: Asset.Symbol.from(config.symbol),
+              }
+            : null
+    }
+
     async getDepositConfig(reload = false): Promise<DepositConfig | null> {
         if (!reload && this.depositConfig !== undefined) {
             return this.depositConfig

package/src/managers/context.ts

@@ -15,6 +15,7 @@ import {NftManager} from './nft'
 import {BalancesManager} from './balances'
 import {FundManager} from './fund'
 import {JobsManager} from './jobs'
+import {ShuttleManager} from './shuttle'
 import {InfluenceManager} from './influence'
 import {SubscriptionsManager} from '../subscriptions/manager'
 
@@ -30,12 +31,15 @@ export class GameContext {
     private _balances?: BalancesManager
     private _funds?: FundManager
     private _jobs?: JobsManager
+    private _shuttle?: ShuttleManager
     private _influence?: InfluenceManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
 
     private _gameCache?: PlatformContract.Types.game_row
+    private _gameInflight?: Promise<PlatformContract.Types.game_row>
     private _stateCache?: GameState
+    private _stateInflight?: Promise<GameState>
 
     constructor(
         public readonly client: APIClient,
@@ -122,6 +126,13 @@ export class GameContext {
         return this._jobs
     }
 
+    get shuttle(): ShuttleManager {
+        if (!this._shuttle) {
+            this._shuttle = new ShuttleManager(this)
+        }
+        return this._shuttle
+    }
+
     get influence(): InfluenceManager {
         if (!this._influence) {
             this._influence = new InfluenceManager(this)
@@ -149,25 +160,53 @@ export class GameContext {
         if (!reload && this._gameCache) {
             return this._gameCache
         }
-        const game = await this.platform.table('games').get()
-        if (!game) {
-            throw new Error('Game not initialized')
+        if (!reload && this._gameInflight) {
+            return this._gameInflight
+        }
+        const inflight = (async () => {
+            const game = await this.platform.table('games').get()
+            if (!game) {
+                throw new Error('Game not initialized')
+            }
+            this._gameCache = game
+            return game
+        })()
+        this._gameInflight = inflight
+        try {
+            return await inflight
+        } finally {
+            if (this._gameInflight === inflight) {
+                this._gameInflight = undefined
+            }
         }
-        this._gameCache = game
-        return game
     }
 
     async getState(reload = false): Promise<GameState> {
         if (!reload && this._stateCache) {
             return this._stateCache
         }
-        const state = await this.server.table('state').get()
-        if (!state) {
-            throw new Error('Game state not initialized')
+        if (!reload && this._stateInflight) {
+            return this._stateInflight
+        }
+        const inflight = (async () => {
+            const [state, game] = await Promise.all([
+                this.server.table('state').get(),
+                this.getGame(),
+            ])
+            if (!state) {
+                throw new Error('Game state not initialized')
+            }
+            this._stateCache = GameState.from(state, game)
+            return this._stateCache
+        })()
+        this._stateInflight = inflight
+        try {
+            return await inflight
+        } finally {
+            if (this._stateInflight === inflight) {
+                this._stateInflight = undefined
+            }
         }
-        const game = this._gameCache
-        this._stateCache = GameState.from(state, game)
-        return this._stateCache
     }
 
     get cachedGame(): PlatformContract.Types.game_row | undefined {

package/src/managers/index.ts

@@ -15,6 +15,20 @@ export type {NftConfigForItem, WrapConfig, WrapGate} from './nft'
 export {BalancesManager} from './balances'
 export type {DepositConfig, PlatformBalance, TokenBalance} from './balances'
 export {JobsManager} from './jobs'
+export {
+    ShuttleManager,
+    rankShuttleOptions,
+    shuttleReasonCode,
+    BOOKING_LEVEL_CODES,
+    OMITTED_REASONS,
+} from './shuttle'
+export type {
+    ShuttleMode,
+    ShuttleOption,
+    ShuttleOptions,
+    ShuttleReason,
+    ShuttleReasonCode,
+} from './shuttle'
 export {InfluenceManager} from './influence'
 export type {
     CharterProgress,

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)
+    })
+})