@shipload/sdk 1.0.0-next.7 → 1.0.0-next.70

package/src/managers/balances.test.ts

@@ -0,0 +1,161 @@
+import {describe, expect, test} from 'bun:test'
+import {Asset, type Name} from '@wharfkit/antelope'
+import {BalancesManager} from './balances'
+import type {GameContext} from './context'
+import {PlatformContract} from '../contracts'
+
+interface StubOptions {
+    depositConfig?: {token_contract: string; token_symbol: string} | null
+    balances?: {token_contract: string; balance: string}[] | null
+    wallet?: string[]
+}
+
+function stubContext(options: StubOptions = {}) {
+    const counts = {depositcfg: 0, balance: 0, currency: 0}
+    const rows = (options.balances ?? []).map((row) => PlatformContract.Types.balance_row.from(row))
+    const platform = {
+        table(name: string) {
+            if (name === 'depositcfg') {
+                return {
+                    get: async () => {
+                        counts.depositcfg++
+                        return options.depositConfig
+                            ? PlatformContract.Types.depositcfg_row.from(options.depositConfig)
+                            : undefined
+                    },
+                }
+            }
+            return {
+                get: async (key: Name) => {
+                    counts.balance++
+                    return rows.find((row) => row.token_contract.equals(key))
+                },
+                all: async () => {
+                    counts.balance++
+                    return rows
+                },
+            }
+        },
+    }
+    const client = {
+        v1: {
+            chain: {
+                get_currency_balance: async () => {
+                    counts.currency++
+                    return (options.wallet ?? []).map((value) => Asset.from(value))
+                },
+            },
+        },
+    }
+    const context = {platform, client} as unknown as GameContext
+    return {manager: new BalancesManager(context), counts}
+}
+
+const SCRAP = {token_contract: 'scrap.gm', token_symbol: '0,SCRAP'}
+
+describe('getDepositConfig', () => {
+    test('reads the configured deposit token', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP})
+        const config = await manager.getDepositConfig()
+        expect(String(config?.tokenContract)).toBe('scrap.gm')
+        expect(String(config?.symbol)).toBe('0,SCRAP')
+    })
+
+    test('caches the config across calls', async () => {
+        const {manager, counts} = stubContext({depositConfig: SCRAP})
+        await manager.getDepositConfig()
+        await manager.getDepositConfig()
+        expect(counts.depositcfg).toBe(1)
+        await manager.getDepositConfig(true)
+        expect(counts.depositcfg).toBe(2)
+    })
+
+    test('caches a missing config as null without refetching', async () => {
+        const {manager, counts} = stubContext({depositConfig: null})
+        expect(await manager.getDepositConfig()).toBeNull()
+        expect(await manager.getDepositConfig()).toBeNull()
+        expect(counts.depositcfg).toBe(1)
+    })
+})
+
+describe('getPlatformBalance', () => {
+    test('returns null when the owner has never opened a row', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, balances: []})
+        expect(await manager.getPlatformBalance('alice')).toBeNull()
+    })
+
+    test('returns a zero balance for an opened but empty row', async () => {
+        const {manager} = stubContext({
+            depositConfig: SCRAP,
+            balances: [{token_contract: 'scrap.gm', balance: '0 SCRAP'}],
+        })
+        const balance = await manager.getPlatformBalance('alice')
+        expect(balance).not.toBeNull()
+        expect(String(balance?.balance)).toBe('0 SCRAP')
+        expect(balance?.balance.units.toNumber()).toBe(0)
+        expect(balance?.balance.symbol.precision).toBe(0)
+        expect(String(balance?.owner)).toBe('alice')
+    })
+
+    test('defaults to the deposit token and honours an explicit contract', async () => {
+        const {manager} = stubContext({
+            depositConfig: SCRAP,
+            balances: [
+                {token_contract: 'scrap.gm', balance: '12 SCRAP'},
+                {token_contract: 'eosio.token', balance: '3.0000 EOS'},
+            ],
+        })
+        expect(String((await manager.getPlatformBalance('alice'))?.balance)).toBe('12 SCRAP')
+        expect(String((await manager.getPlatformBalance('alice', 'eosio.token'))?.balance)).toBe(
+            '3.0000 EOS'
+        )
+    })
+
+    test('returns null when no deposit token is configured', async () => {
+        const {manager, counts} = stubContext({depositConfig: null})
+        expect(await manager.getPlatformBalance('alice')).toBeNull()
+        expect(counts.balance).toBe(0)
+    })
+})
+
+describe('getPlatformBalances', () => {
+    test('returns every row the owner holds', async () => {
+        const {manager} = stubContext({
+            depositConfig: SCRAP,
+            balances: [
+                {token_contract: 'scrap.gm', balance: '12 SCRAP'},
+                {token_contract: 'eosio.token', balance: '3.0000 EOS'},
+            ],
+        })
+        const balances = await manager.getPlatformBalances('alice')
+        expect(balances.map((row) => String(row.balance))).toEqual(['12 SCRAP', '3.0000 EOS'])
+        expect(balances.map((row) => String(row.tokenContract))).toEqual([
+            'scrap.gm',
+            'eosio.token',
+        ])
+    })
+
+    test('returns an empty array for an owner with no rows', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, balances: []})
+        expect(await manager.getPlatformBalances('alice')).toEqual([])
+    })
+})
+
+describe('getWalletBalance', () => {
+    test('reads the wallet balance for the deposit token', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, wallet: ['500 SCRAP']})
+        const balance = await manager.getWalletBalance('alice')
+        expect(String(balance?.balance)).toBe('500 SCRAP')
+        expect(String(balance?.tokenContract)).toBe('scrap.gm')
+    })
+
+    test('returns null when the account holds none of the token', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, wallet: []})
+        expect(await manager.getWalletBalance('alice')).toBeNull()
+    })
+
+    test('ignores balances of other symbols on the same contract', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, wallet: ['1.0000 OTHER']})
+        expect(await manager.getWalletBalance('alice')).toBeNull()
+    })
+})

package/src/managers/balances.ts

@@ -0,0 +1,93 @@
+import {Asset, Name, type NameType} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {PlatformContract} from '../contracts'
+
+export interface DepositConfig {
+    tokenContract: Name
+    symbol: Asset.Symbol
+}
+
+export interface PlatformBalance {
+    owner: Name
+    tokenContract: Name
+    balance: Asset
+}
+
+export interface TokenBalance {
+    account: Name
+    tokenContract: Name
+    balance: Asset
+}
+
+export class BalancesManager extends BaseManager {
+    private depositConfig?: DepositConfig | null
+
+    async getDepositConfig(reload = false): Promise<DepositConfig | null> {
+        if (!reload && this.depositConfig !== undefined) {
+            return this.depositConfig
+        }
+        const row = (await this.platform.table('depositcfg').get()) as
+            | PlatformContract.Types.depositcfg_row
+            | undefined
+        this.depositConfig = row
+            ? {tokenContract: row.token_contract, symbol: row.token_symbol}
+            : null
+        return this.depositConfig
+    }
+
+    private async resolveTokenContract(tokenContract?: NameType): Promise<Name | null> {
+        if (tokenContract) return Name.from(tokenContract)
+        const config = await this.getDepositConfig()
+        return config ? config.tokenContract : null
+    }
+
+    async getPlatformBalances(owner: NameType): Promise<PlatformBalance[]> {
+        const account = Name.from(owner)
+        const rows = (await this.platform
+            .table('balance', account)
+            .all()) as PlatformContract.Types.balance_row[]
+        return rows.map((row) => ({
+            owner: account,
+            tokenContract: row.token_contract,
+            balance: row.balance,
+        }))
+    }
+
+    // Null means no balance row at all: deposits abort until `open`. A zero row is a valid state.
+    async getPlatformBalance(
+        owner: NameType,
+        tokenContract?: NameType
+    ): Promise<PlatformBalance | null> {
+        const contract = await this.resolveTokenContract(tokenContract)
+        if (!contract) return null
+        const account = Name.from(owner)
+        const row = (await this.platform.table('balance', account).get(contract)) as
+            | PlatformContract.Types.balance_row
+            | undefined
+        if (!row) return null
+        return {owner: account, tokenContract: row.token_contract, balance: row.balance}
+    }
+
+    async getWalletBalance(
+        account: NameType,
+        tokenContract?: NameType,
+        symbolCode?: Asset.SymbolCodeType
+    ): Promise<TokenBalance | null> {
+        const contract = await this.resolveTokenContract(tokenContract)
+        if (!contract) return null
+        let code = symbolCode ? Asset.SymbolCode.from(symbolCode) : undefined
+        if (!code) {
+            const config = await this.getDepositConfig()
+            code = config?.symbol.code
+        }
+        const holder = Name.from(account)
+        const balances = await this.client.v1.chain.get_currency_balance(
+            contract,
+            holder,
+            code ? String(code) : undefined
+        )
+        const balance = balances.find((asset) => !code || asset.symbol.code.equals(code))
+        if (!balance) return null
+        return {account: holder, tokenContract: contract, balance}
+    }
+}

package/src/managers/base.ts

@@ -15,11 +15,19 @@ export abstract class BaseManager {
         return this.context.platform
     }
 
+    protected get fund() {
+        return this.context.fund
+    }
+
+    protected get atomicAssetsAccount() {
+        return this.context.atomicAssetsAccount
+    }
+
     protected async getGame() {
         return this.context.getGame()
     }
 
-    protected async getState() {
-        return this.context.getState()
+    protected async getState(reload = false) {
+        return this.context.getState(reload)
     }
 }

package/src/managers/cluster.test.ts

@@ -0,0 +1,39 @@
+import {describe, expect, test} from 'bun:test'
+import {computeFreeCells} from './cluster'
+
+describe('computeFreeCells', () => {
+    test('returns footprint cells that are not occupied', () => {
+        const footprint = [
+            {gx: 2, gy: 0},
+            {gx: 0, gy: 2},
+            {gx: 1, gy: 1},
+        ]
+        const occupied = [{gx: 2, gy: 0, entity: 7}]
+        expect(computeFreeCells(footprint, occupied)).toEqual([
+            {gx: 0, gy: 2},
+            {gx: 1, gy: 1},
+        ])
+    })
+
+    test('matches occupancy on signed coordinates', () => {
+        const footprint = [
+            {gx: -2, gy: 0},
+            {gx: 0, gy: -2},
+            {gx: -1, gy: 1},
+        ]
+        const occupied = [{gx: 0, gy: -2, entity: 9}]
+        expect(computeFreeCells(footprint, occupied)).toEqual([
+            {gx: -2, gy: 0},
+            {gx: -1, gy: 1},
+        ])
+    })
+
+    test('empty footprint yields no free cells', () => {
+        expect(computeFreeCells([], [])).toEqual([])
+    })
+
+    test('fully occupied footprint yields no free cells', () => {
+        const footprint = [{gx: 1, gy: 1}]
+        expect(computeFreeCells(footprint, [{gx: 1, gy: 1, entity: 3}])).toEqual([])
+    })
+})

package/src/managers/cluster.ts

@@ -0,0 +1,53 @@
+import {UInt16, type UInt16Type, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+
+export interface GridCell {
+    gx: number
+    gy: number
+}
+
+export interface ClusterCell extends GridCell {
+    entity: number
+}
+
+export interface Cluster {
+    root: number
+    cells: ClusterCell[]
+}
+
+export function computeFreeCells(footprint: GridCell[], occupied: ClusterCell[]): GridCell[] {
+    const taken = new Set(occupied.map((c) => `${c.gx},${c.gy}`))
+    return footprint.filter((c) => !taken.has(`${c.gx},${c.gy}`))
+}
+
+export class ClusterManager extends BaseManager {
+    async getFootprint(itemId: UInt16Type): Promise<GridCell[]> {
+        const res = (await this.server.readonly('getfootprint', {
+            item_id: UInt16.from(itemId),
+        })) as ServerContract.Types.footprint_result
+        return res.cells.map((c) => ({gx: Number(c.gx), gy: Number(c.gy)}))
+    }
+
+    async getCluster(hubId: UInt64Type): Promise<Cluster> {
+        const res = (await this.server.readonly('getcluster', {
+            hub_id: UInt64.from(hubId),
+        })) as ServerContract.Types.cluster_row
+        return {
+            root: Number(res.root),
+            cells: res.cells.map((c) => ({
+                gx: Number(c.gx),
+                gy: Number(c.gy),
+                entity: Number(c.entity),
+            })),
+        }
+    }
+
+    async freeCells(hubId: UInt64Type, hubItemId: UInt16Type): Promise<GridCell[]> {
+        const [footprint, cluster] = await Promise.all([
+            this.getFootprint(hubItemId),
+            this.getCluster(hubId),
+        ])
+        return computeFreeCells(footprint, cluster.cells)
+    }
+}

package/src/managers/construction-types.ts

@@ -0,0 +1,80 @@
+import type {Name, UInt32, UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import type {Item} from '../types'
+import type {Recipe} from '../data/recipes-runtime'
+import type {PlotProgress} from './plot'
+
+export type BuildState = 'initializing' | 'accepting' | 'ready' | 'scheduled' | 'finalizing'
+
+export type FinalizerCapability = 'builder'
+
+export interface BuildableTarget {
+    entityId: UInt64
+    ownerName: Name
+    coordinates: ServerContract.Types.coordinates
+    targetItemId: number
+    targetItem: Item
+    state: BuildState
+    recipe: Recipe
+    progress: PlotProgress
+    finalizeAction: Name
+    finalizerCapability: FinalizerCapability
+    activeTask?: ServerContract.Types.task
+    scheduledBuild?: ScheduledBuild
+}
+
+export interface SourceEntityRef {
+    entityId: UInt64
+    name: string
+    hasLoaders: boolean
+    loaderCount: number
+    loaderTotalMass: number
+    relevantCargo: SourceCargoStack[]
+}
+
+export interface SourceCargoStack {
+    key: string
+    rowId: UInt64
+    itemId: number
+    item: Item
+    stats: UInt64
+    modules: ServerContract.Types.module_entry[]
+    available: number
+    plotNeeds: number
+    reserved: number
+}
+
+export interface FinalizerEntityRef {
+    entityId: UInt64
+    entityType: Name
+    name: string
+    capability: FinalizerCapability
+    builderSpeed: number
+    estimatedDuration: UInt32
+}
+
+export interface InboundTransfer {
+    sourceEntityId: UInt64
+    sourceEntityType: Name
+    sourceName: string
+    itemId: number
+    quantity: number
+    etaSeconds: number
+}
+
+export interface ScheduledBuild {
+    shipId: UInt64
+    shipName: string
+    hasStarted: boolean
+    startsAt: number
+    completesAt: number
+    cancelable: boolean
+    blockingTaskCount: number
+}
+
+export interface Reservation {
+    targetEntityId: UInt64
+    targetEntityType: Name
+    itemId: number
+    quantity: number
+}