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

package/src/managers/nft.ts

@@ -0,0 +1,110 @@
+import {Name, UInt64, type NameType, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {PlatformContract, ServerContract} from '../contracts'
+
+export interface NftConfigForItem {
+    templateId: number
+    schemaName: string
+}
+
+export interface WrapConfig {
+    feePctBasisPoints: number
+    feeAccount: Name
+}
+
+export interface WrapGate {
+    owner: Name
+    game: Name
+    lastAssetId: UInt64
+}
+
+export interface WrapDeposit {
+    cost: bigint
+    refund: bigint
+    feePct: number
+    symbol: string
+    precision: number
+    tokenContract: string
+}
+
+export function resolveLockedAmount(cost: bigint, feePctBasisPoints: number): bigint {
+    const fee = (cost * BigInt(feePctBasisPoints)) / 10_000n
+    return cost - fee
+}
+
+export function wrapCostKey(itemType: number, tier: number): UInt64 {
+    return UInt64.from((BigInt(itemType) << 8n) | BigInt(tier))
+}
+
+export class NftManager extends BaseManager {
+    private cache = new Map<string, NftConfigForItem | null>()
+    private wrapConfig?: WrapConfig | null
+
+    async getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined> {
+        const id = UInt64.from(itemId)
+        const key = id.toString()
+        if (this.cache.has(key)) {
+            return this.cache.get(key) ?? undefined
+        }
+        const row = (await this.server.table('nftconfig').get(id)) as
+            | ServerContract.Types.nftconfig_row
+            | undefined
+        const result: NftConfigForItem | null = row
+            ? {templateId: Number(row.template_id), schemaName: String(row.schema_name)}
+            : null
+        this.cache.set(key, result)
+        return result ?? undefined
+    }
+
+    async getWrapConfig(reload = false): Promise<WrapConfig | null> {
+        if (!reload && this.wrapConfig !== undefined) {
+            return this.wrapConfig
+        }
+        const row = (await this.server.table('wrapconfig').get()) as
+            | ServerContract.Types.wrapconfig_row
+            | undefined
+        this.wrapConfig = row
+            ? {feePctBasisPoints: Number(row.fee_pct), feeAccount: row.fee_account}
+            : null
+        return this.wrapConfig
+    }
+
+    async getWrapCost(itemType: number, tier: number): Promise<bigint> {
+        const row = (await this.server.table('wrapcost').get(wrapCostKey(itemType, tier))) as
+            | ServerContract.Types.wrapcost_row
+            | undefined
+        return row ? BigInt(row.amount.toString()) : 0n
+    }
+
+    async getWrapDeposit(
+        itemType: number,
+        tier: number,
+        opts: {reload?: boolean} = {}
+    ): Promise<WrapDeposit | null> {
+        const cost = await this.getWrapCost(itemType, tier)
+        if (cost === 0n) return null
+
+        const wrapConfig = await this.getWrapConfig(opts.reload)
+        const feePctBasisPoints = wrapConfig ? wrapConfig.feePctBasisPoints : 0
+
+        const depositConfig = await this.context.balances.getDepositConfig(opts.reload)
+        if (!depositConfig) return null
+
+        return {
+            cost,
+            refund: resolveLockedAmount(cost, feePctBasisPoints),
+            feePct: feePctBasisPoints / 100,
+            symbol: depositConfig.symbol.code.toString(),
+            precision: depositConfig.symbol.precision,
+            tokenContract: depositConfig.tokenContract.toString(),
+        }
+    }
+
+    async getWrapGate(owner: NameType): Promise<WrapGate | null> {
+        const row = (await this.platform.table('wrapgate').get(Name.from(owner))) as
+            | PlatformContract.Types.wrapgate_row
+            | undefined
+        if (!row) return null
+        return {owner: row.owner, game: row.game, lastAssetId: row.last_asset_id}
+    }
+}

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/managers/plot.ts

@@ -0,0 +1,122 @@
+import {Name} from '@wharfkit/antelope'
+import {getItem} from '../data/catalog'
+import {getRecipe} from '../data/recipes-runtime'
+import {computeInputMass} from '../derivation/crafting'
+import {calc_craft_duration} from '../capabilities/crafting'
+import {TaskType} from '../types'
+import {BaseManager} from './base'
+import type {CrafterStats} from '../types/capabilities'
+import type {ServerContract} from '../contracts'
+import type {BuildableTarget, ScheduledBuild} from './construction-types'
+
+export interface PlotProgressInputRow {
+    itemId: number
+    required: number
+    provided: number
+    missing: number
+}
+
+export interface PlotProgress {
+    targetItemId: number
+    rows: PlotProgressInputRow[]
+    massProvided: number
+    massRequired: number
+    isComplete: boolean
+}
+
+export class PlotManager extends BaseManager {
+    progress(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[]
+    ): PlotProgress {
+        const targetItemId = Number(plot.item_id.toString())
+        const recipe = getRecipe(targetItemId)
+        if (!recipe) {
+            throw new Error(`No recipe found for item ${targetItemId}`)
+        }
+
+        const plotId = plot.id.toString()
+        const plotCargo = cargo.filter((c) => c.entity_id.toString() === plotId)
+
+        const quantityByItemId = new Map<number, number>()
+        for (const c of plotCargo) {
+            const id = c.item_id.toNumber()
+            quantityByItemId.set(
+                id,
+                (quantityByItemId.get(id) ?? 0) + Number(c.quantity.toString())
+            )
+        }
+
+        const rows: PlotProgressInputRow[] = recipe.inputs.map((input) => {
+            const itemId = input.itemId
+            const required = input.quantity
+            const provided = quantityByItemId.get(itemId) ?? 0
+            const missing = Math.max(0, required - provided)
+            return {itemId, required, provided, missing}
+        })
+
+        const massRequired = computeInputMass(targetItemId)
+        const massProvided = rows.reduce((sum, r) => {
+            const item = getItem(r.itemId)
+            return sum + item.mass * r.provided
+        }, 0)
+        const isComplete = rows.every((r) => r.missing === 0)
+
+        return {targetItemId, rows, massProvided, massRequired, isComplete}
+    }
+
+    buildableTarget(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[],
+        activeTask?: ServerContract.Types.task,
+        scheduledBuild?: ScheduledBuild
+    ): BuildableTarget {
+        const progress = this.progress(plot, cargo)
+        const targetItemId = Number(plot.item_id.toString())
+        const targetItem = getItem(targetItemId)
+        const recipe = getRecipe(targetItemId)
+        if (!recipe) {
+            throw new Error(`Plot target item ${targetItemId} has no recipe`)
+        }
+
+        let state: BuildableTarget['state']
+        if (scheduledBuild?.hasStarted) {
+            state = 'finalizing'
+        } else if (scheduledBuild) {
+            state = 'scheduled'
+        } else if (progress.isComplete) {
+            state = 'ready'
+        } else {
+            state = 'accepting'
+        }
+
+        return {
+            entityId: plot.id,
+            ownerName: plot.owner,
+            coordinates: plot.coordinates,
+            targetItemId,
+            targetItem,
+            state,
+            recipe,
+            progress,
+            finalizeAction: Name.from('buildplot'),
+            finalizerCapability: 'builder',
+            activeTask,
+            scheduledBuild,
+        }
+    }
+
+    canBuild(
+        plot: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[]
+    ): boolean {
+        return this.progress(plot, cargo).isComplete
+    }
+
+    timeToComplete(plot: ServerContract.Types.entity_info, crafter: CrafterStats): number {
+        const capacity = Number(plot.capacity?.toString() ?? '0')
+        const speed = Number(crafter.speed.toString())
+        if (speed === 0) return 0
+        return calc_craft_duration(speed, capacity).toNumber()
+    }
+}