@shipload/sdk 1.0.0-next.2 → 1.0.0-next.20

package/src/managers/entities.ts

@@ -1,99 +1,51 @@
 import {Name, type NameType, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {Ship} from '../entities/ship'
-import {Warehouse} from '../entities/warehouse'
-import {Container} from '../entities/container'
+import {Entity} from '../entities/entity'
+import type {EntityTypeName} from '../data/kind-registry'
 import type {ServerContract} from '../contracts'
 
-export type EntityType = 'ship' | 'warehouse' | 'container' | 'location'
+export type {EntityTypeName} from '../data/kind-registry'
 
 export class EntitiesManager extends BaseManager {
-    async getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse | Container> {
+    async getEntity(id: UInt64Type): Promise<Entity> {
         const result = await this.server.readonly('getentity', {
-            entity_type: Name.from(type),
             entity_id: id,
         })
-        const entityInfo = result as ServerContract.Types.entity_info
-        return this.wrapEntity(entityInfo)
+        return new Entity(result as ServerContract.Types.entity_info)
+    }
+
+    async getProjection(id: UInt64Type, taskCount?: number): Promise<unknown> {
+        return this.server.readonly('getprojstate', {
+            entity_id: id,
+            task_count: taskCount,
+        })
     }
 
     async getEntities(
         owner: NameType | ServerContract.Types.player_row,
-        type?: EntityType
-    ): Promise<(Ship | Warehouse | Container)[]> {
+        kind?: EntityTypeName
+    ): Promise<Entity[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getentities', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: kind,
         })
         const entities = result as ServerContract.Types.entity_info[]
-        return entities.map((entity) => this.wrapEntity(entity))
+        return entities.map((e) => new Entity(e))
     }
 
     async getSummaries(
         owner: NameType | ServerContract.Types.player_row,
-        type?: EntityType
+        kind?: EntityTypeName
     ): Promise<ServerContract.Types.entity_summary[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getsummaries', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: kind,
         })
         return result as ServerContract.Types.entity_summary[]
     }
 
-    async getShip(id: UInt64Type): Promise<Ship> {
-        return (await this.getEntity('ship', id)) as Ship
-    }
-
-    async getWarehouse(id: UInt64Type): Promise<Warehouse> {
-        return (await this.getEntity('warehouse', id)) as Warehouse
-    }
-
-    async getContainer(id: UInt64Type): Promise<Container> {
-        return (await this.getEntity('container', id)) as Container
-    }
-
-    async getShips(owner: NameType | ServerContract.Types.player_row): Promise<Ship[]> {
-        return (await this.getEntities(owner, 'ship')) as Ship[]
-    }
-
-    async getWarehouses(owner: NameType | ServerContract.Types.player_row): Promise<Warehouse[]> {
-        return (await this.getEntities(owner, 'warehouse')) as Warehouse[]
-    }
-
-    async getContainers(owner: NameType | ServerContract.Types.player_row): Promise<Container[]> {
-        return (await this.getEntities(owner, 'container')) as Container[]
-    }
-
-    async getShipSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'ship')
-    }
-
-    async getWarehouseSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'warehouse')
-    }
-
-    async getContainerSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'container')
-    }
-
-    private wrapEntity(entity: ServerContract.Types.entity_info): Ship | Warehouse | Container {
-        if (entity.type.equals('ship')) {
-            return new Ship(entity)
-        } else if (entity.type.equals('warehouse')) {
-            return new Warehouse(entity)
-        } else {
-            return new Container(entity)
-        }
-    }
-
     private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {
         if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
             return owner.owner

package/src/managers/epochs.ts

@@ -1,6 +1,7 @@
 import {UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
+import type {ServerContract} from '../contracts'
 
 export class EpochsManager extends BaseManager {
     async getCurrentHeight(): Promise<UInt64> {
@@ -8,6 +9,11 @@ export class EpochsManager extends BaseManager {
         return getCurrentEpoch(game)
     }
 
+    async getFinalizedEpoch(reload = false): Promise<UInt64> {
+        const state = await this.getState(reload)
+        return state.currentEpoch
+    }
+
     async getCurrent(): Promise<EpochInfo> {
         const game = await this.getGame()
         const epoch = await this.getCurrentHeight()
@@ -44,4 +50,38 @@ export class EpochsManager extends BaseManager {
         const remaining = await this.getTimeRemaining()
         return durationMs <= remaining
     }
+
+    async getEpochRow(epoch: UInt64Type): Promise<ServerContract.Types.epoch_row | undefined> {
+        const target = UInt64.from(epoch)
+        return this.server.table('epoch').get(target)
+    }
+
+    async getActiveEpochInfo(): Promise<ServerContract.Types.epoch_row | undefined> {
+        const rows = await this.server.table('epoch').all()
+        if (rows.length === 0) {
+            return undefined
+        }
+        return rows[rows.length - 1]
+    }
+
+    async getOracles(): Promise<ServerContract.Types.oracle_row[]> {
+        return this.server.table('oracles').all()
+    }
+
+    async getThreshold(): Promise<number> {
+        const cfg = await this.server.table('oraclecfg').get()
+        return cfg ? Number(cfg.threshold) : 0
+    }
+
+    async getCommitsFor(epoch: UInt64Type): Promise<ServerContract.Types.commit_row[]> {
+        const target = UInt64.from(epoch)
+        const rows = await this.server.table('commit').all()
+        return rows.filter((r) => r.epoch.equals(target))
+    }
+
+    async getRevealsFor(epoch: UInt64Type): Promise<ServerContract.Types.reveal_row[]> {
+        const target = UInt64.from(epoch)
+        const rows = await this.server.table('reveal').all()
+        return rows.filter((r) => r.epoch.equals(target))
+    }
 }

package/src/managers/index.ts

@@ -1,9 +1,22 @@
 export {GameContext} from './context'
 export {BaseManager} from './base'
 export {EntitiesManager} from './entities'
-export type {EntityType} from './entities'
+export type {EntityTypeName} from './entities'
 export {PlayersManager} from './players'
 export {LocationsManager} from './locations'
 export type {LocationStratum} from './locations'
 export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'
+export {NftManager} from './nft'
+export type {NftConfigForItem} from './nft'
+export {PlotManager} from './plot'
+export type {PlotProgress, PlotProgressInputRow} from './plot'
+export {ConstructionManager} from './construction'
+export type {
+    BuildableTarget,
+    BuildState,
+    SourceEntityRef,
+    SourceCargoStack,
+    FinalizerEntityRef,
+    FinalizerCapability,
+} from './construction-types'

package/src/managers/locations.ts

@@ -1,6 +1,6 @@
-import {type UInt16Type, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import type {UInt16Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {type CoordinatesType, coordsToLocationId, type Distance} from '../types'
+import type {CoordinatesType, Distance} from '../types'
 import {hasSystem} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 import type {ServerContract} from '../contracts'
@@ -47,22 +47,4 @@ export class LocationsManager extends BaseManager {
             reserve: overrideMap.get(s.index) ?? s.reserve,
         }))
     }
-
-    async getLocationEntity(
-        id: UInt64Type
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const row = await this.server.table('location').get(UInt64.from(id))
-        return row ?? undefined
-    }
-
-    async getLocationEntityAt(
-        coords: CoordinatesType
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const id = coordsToLocationId(coords)
-        return this.getLocationEntity(id)
-    }
-
-    async getAllLocationEntities(): Promise<ServerContract.Types.location_row[]> {
-        return this.server.table('location').all()
-    }
 }

package/src/managers/nft.ts

@@ -0,0 +1,28 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+
+export interface NftConfigForItem {
+    templateId: number
+    schemaName: string
+}
+
+export class NftManager extends BaseManager {
+    private cache = new Map<string, NftConfigForItem | 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
+    }
+}

package/src/managers/plot.ts

@@ -0,0 +1,123 @@
+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 {ServerContract} from '../contracts'
+import type {BuildableTarget} 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
+    ): 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']
+        const taskType = activeTask?.type.toNumber()
+        if (taskType === TaskType.CLAIMPLOT) {
+            state = 'initializing'
+        } else if (taskType === TaskType.BUILDPLOT) {
+            state = 'finalizing'
+        } 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: 'crafter',
+            activeTask,
+        }
+    }
+
+    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: ServerContract.Types.crafter_stats
+    ): 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()
+    }
+}

package/src/nft/atomicassets.ts

@@ -0,0 +1,231 @@
+import {
+    ABI,
+    type ABIDef,
+    Action,
+    type APIClient,
+    type NameType,
+    Name,
+    PermissionLevel,
+    UInt64,
+} from '@wharfkit/antelope'
+import {deserializeAtomicData, type SchemaField} from './atomicdata'
+import {deserializeAsset, type NFTCargoItem, type NFTModuleSlot} from './deserializers'
+import type {ImmutableEntry} from './buildImmutableData'
+
+const PLACEHOLDER_AUTH = PermissionLevel.from({
+    actor: '............1',
+    permission: '............2',
+})
+
+export const ATOMICASSETS_ACCOUNT = 'atomicassets'
+export const SHIPLOAD_COLLECTION = 'shipload'
+
+const ATOMIC_ATTRIBUTE_VARIANT_NAME =
+    'variant_int8_int16_int32_int64_uint8_uint16_uint32_uint64_float32_float64_string_INT8_VEC_INT16_VEC_INT32_VEC_INT64_VEC_UINT8_VEC_UINT16_VEC_UINT32_VEC_UINT64_VEC_FLOAT_VEC_DOUBLE_VEC_STRING_VEC'
+
+const MINTASSET_ABI_DEF: ABIDef = {
+    version: 'eosio::abi/1.2',
+    types: [
+        {new_type_name: 'ATOMIC_ATTRIBUTE', type: ATOMIC_ATTRIBUTE_VARIANT_NAME},
+        {new_type_name: 'ATTRIBUTE_MAP', type: 'pair_string_ATOMIC_ATTRIBUTE[]'},
+        {new_type_name: 'INT8_VEC', type: 'bytes'},
+        {new_type_name: 'INT16_VEC', type: 'int16[]'},
+        {new_type_name: 'INT32_VEC', type: 'int32[]'},
+        {new_type_name: 'INT64_VEC', type: 'int64[]'},
+        {new_type_name: 'UINT8_VEC', type: 'bytes'},
+        {new_type_name: 'UINT16_VEC', type: 'uint16[]'},
+        {new_type_name: 'UINT32_VEC', type: 'uint32[]'},
+        {new_type_name: 'UINT64_VEC', type: 'uint64[]'},
+        {new_type_name: 'FLOAT_VEC', type: 'float32[]'},
+        {new_type_name: 'DOUBLE_VEC', type: 'float64[]'},
+        {new_type_name: 'STRING_VEC', type: 'string[]'},
+    ],
+    structs: [
+        {
+            name: 'pair_string_ATOMIC_ATTRIBUTE',
+            base: '',
+            fields: [
+                {name: 'first', type: 'string'},
+                {name: 'second', type: 'ATOMIC_ATTRIBUTE'},
+            ],
+        },
+        {
+            name: 'mintasset',
+            base: '',
+            fields: [
+                {name: 'authorized_minter', type: 'name'},
+                {name: 'collection_name', type: 'name'},
+                {name: 'schema_name', type: 'name'},
+                {name: 'template_id', type: 'int32'},
+                {name: 'new_asset_owner', type: 'name'},
+                {name: 'immutable_data', type: 'ATTRIBUTE_MAP'},
+                {name: 'mutable_data', type: 'ATTRIBUTE_MAP'},
+                {name: 'tokens_to_back', type: 'asset[]'},
+            ],
+        },
+    ],
+    actions: [{name: 'mintasset', type: 'mintasset', ricardian_contract: ''}],
+    variants: [
+        {
+            name: ATOMIC_ATTRIBUTE_VARIANT_NAME,
+            types: [
+                'int8',
+                'int16',
+                'int32',
+                'int64',
+                'uint8',
+                'uint16',
+                'uint32',
+                'uint64',
+                'float32',
+                'float64',
+                'string',
+                'INT8_VEC',
+                'INT16_VEC',
+                'INT32_VEC',
+                'INT64_VEC',
+                'UINT8_VEC',
+                'UINT16_VEC',
+                'UINT32_VEC',
+                'UINT64_VEC',
+                'FLOAT_VEC',
+                'DOUBLE_VEC',
+                'STRING_VEC',
+            ],
+        },
+    ],
+}
+
+export interface MintAssetParams {
+    authorizedMinter: NameType
+    collectionName: NameType
+    schemaName: NameType
+    templateId: number
+    newAssetOwner: NameType
+    immutableData: ImmutableEntry[]
+}
+
+const MINTASSET_ABI = ABI.from(MINTASSET_ABI_DEF)
+
+export function buildMintAssetAction(params: MintAssetParams): Action {
+    return Action.from(
+        {
+            account: Name.from(ATOMICASSETS_ACCOUNT),
+            name: Name.from('mintasset'),
+            authorization: [PLACEHOLDER_AUTH],
+            data: {
+                authorized_minter: Name.from(params.authorizedMinter),
+                collection_name: Name.from(params.collectionName),
+                schema_name: Name.from(params.schemaName),
+                template_id: params.templateId,
+                new_asset_owner: Name.from(params.newAssetOwner),
+                immutable_data: params.immutableData,
+                mutable_data: [],
+                tokens_to_back: [],
+            },
+        },
+        MINTASSET_ABI
+    )
+}
+
+export interface AtomicAssetRow {
+    asset_id: string
+    collection_name: string
+    schema_name: string
+    template_id: number
+    ram_payer?: string
+    backed_tokens?: string[]
+    immutable_serialized_data: string | number[]
+    mutable_serialized_data?: string | number[]
+}
+
+export interface AtomicSchemaRow {
+    schema_name: string
+    format: SchemaField[]
+}
+
+export interface FetchAssetsOptions {
+    collection?: NameType
+    pageSize?: number
+}
+
+export async function fetchAtomicAssetsForOwner(
+    client: APIClient,
+    owner: NameType,
+    opts: FetchAssetsOptions = {}
+): Promise<AtomicAssetRow[]> {
+    const collection = opts.collection ? String(Name.from(opts.collection)) : undefined
+    const pageSize = opts.pageSize ?? 1000
+    const out: AtomicAssetRow[] = []
+    let lower: UInt64 | undefined
+    while (true) {
+        const res = await client.v1.chain.get_table_rows({
+            code: Name.from(ATOMICASSETS_ACCOUNT),
+            scope: String(Name.from(owner)),
+            table: Name.from('assets'),
+            limit: pageSize,
+            lower_bound: lower,
+            json: true,
+        })
+        for (const row of res.rows as AtomicAssetRow[]) {
+            if (!collection || row.collection_name === collection) out.push(row)
+        }
+        if (!res.more) break
+        lower = UInt64.from(String(res.next_key))
+    }
+    return out
+}
+
+export async function fetchAtomicSchemas(
+    client: APIClient,
+    collection: NameType
+): Promise<AtomicSchemaRow[]> {
+    const out: AtomicSchemaRow[] = []
+    let lower: Name | undefined
+    while (true) {
+        const res = await client.v1.chain.get_table_rows({
+            code: Name.from(ATOMICASSETS_ACCOUNT),
+            scope: String(Name.from(collection)),
+            table: Name.from('schemas'),
+            limit: 100,
+            lower_bound: lower,
+            json: true,
+        })
+        for (const row of res.rows as AtomicSchemaRow[]) out.push(row)
+        if (!res.more) break
+        lower = Name.from(String(res.next_key))
+    }
+    return out
+}
+
+export interface DecodedAtomicAsset {
+    asset_id: bigint
+    schema_name: string
+    template_id: number
+    item_id: number
+    quantity: number
+    stats: string
+    origin_x: bigint
+    origin_y: bigint
+    modules?: NFTModuleSlot[]
+}
+
+export function decodeAtomicAsset(
+    asset: AtomicAssetRow,
+    schemaFormat: SchemaField[],
+    itemId: number
+): DecodedAtomicAsset {
+    const data = deserializeAtomicData(asset.immutable_serialized_data, schemaFormat)
+    const cargo: NFTCargoItem = deserializeAsset(data, itemId)
+    return {
+        asset_id: BigInt(String(asset.asset_id)),
+        schema_name: String(asset.schema_name),
+        template_id: Number(asset.template_id),
+        item_id: cargo.item_id,
+        quantity: cargo.quantity,
+        stats: cargo.stats,
+        origin_x: BigInt(String(data.origin_x ?? 0)),
+        origin_y: BigInt(String(data.origin_y ?? 0)),
+        modules: cargo.modules,
+    }
+}