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

package/src/managers/actions.ts

@@ -1,8 +1,12 @@
 import {
-    type Action,
+    Action,
+    Checksum256,
+    type Checksum256Type,
     Int64,
     Name,
     type NameType,
+    UInt8,
+    type UInt8Type,
     UInt16,
     type UInt16Type,
     UInt32,
@@ -11,11 +15,11 @@ import {
     type UInt64Type,
 } from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {type CoordinatesType, EntityType, type EntityTypeName} from '../types'
+import type {CoordinatesType} from '../types'
 import {ServerContract} from '../contracts'
 
 export type EntityRefInput = {
-    entityType: EntityTypeName
+    entityType: NameType
     entityId: UInt64Type
 }
 
@@ -25,7 +29,6 @@ export class ActionsManager extends BaseManager {
         const y = Int64.from(destination.y)
 
         return this.server.action('travel', {
-            entity_type: EntityType.SHIP,
             id: UInt64.from(shipId),
             x,
             y,
@@ -51,13 +54,8 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    resolve(
-        entityId: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP,
-        count?: UInt64Type
-    ): Action {
+    resolve(entityId: UInt64Type, count?: UInt64Type): Action {
         const params: ServerContract.ActionParams.resolve = {
-            entity_type: entityType,
             id: UInt64.from(entityId),
         }
         if (count !== undefined) {
@@ -66,42 +64,34 @@ export class ActionsManager extends BaseManager {
         return this.server.action('resolve', params)
     }
 
-    cancel(
-        entityId: UInt64Type,
-        count: UInt64Type,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
+    cancel(entityId: UInt64Type, count: UInt64Type): Action {
         return this.server.action('cancel', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
             count: UInt64.from(count),
         })
     }
 
-    recharge(entityId: UInt64Type, entityType: EntityTypeName = EntityType.SHIP): Action {
+    recharge(entityId: UInt64Type): Action {
         return this.server.action('recharge', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
         })
     }
 
+    refrshentity(entityId: UInt64Type): Action {
+        return this.server.action('refrshentity', {
+            entity_id: UInt64.from(entityId),
+        })
+    }
+
     transfer(
-        sourceType: EntityTypeName,
         sourceId: UInt64Type,
-        destType: EntityTypeName,
         destId: UInt64Type,
-        itemId: UInt64Type,
-        stats: UInt64Type,
-        quantity: UInt64Type
+        items: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
         return this.server.action('transfer', {
-            source_type: sourceType,
             source_id: UInt64.from(sourceId),
-            dest_type: destType,
             dest_id: UInt64.from(destId),
-            item_id: UInt16.from(itemId),
-            stats: UInt64.from(stats),
-            quantity: UInt32.from(quantity),
+            items,
         })
     }
 
@@ -119,35 +109,24 @@ export class ActionsManager extends BaseManager {
     }
 
     gather(
-        source: EntityRefInput,
-        destination: EntityRefInput,
+        sourceId: UInt64Type,
+        destinationId: UInt64Type,
         stratum: UInt16Type,
         quantity: UInt32Type
     ): Action {
         return this.server.action('gather', {
-            source: ServerContract.Types.entity_ref.from({
-                entity_type: source.entityType,
-                entity_id: UInt64.from(source.entityId),
-            }),
-            destination: ServerContract.Types.entity_ref.from({
-                entity_type: destination.entityType,
-                entity_id: UInt64.from(destination.entityId),
-            }),
+            source_id: UInt64.from(sourceId),
+            destination_id: UInt64.from(destinationId),
             stratum: UInt16.from(stratum),
             quantity: UInt32.from(quantity),
         })
     }
 
-    warp(
-        entityId: UInt64Type,
-        destination: CoordinatesType,
-        entityType: EntityTypeName = EntityType.SHIP
-    ): Action {
+    warp(entityId: UInt64Type, destination: CoordinatesType): Action {
         const x = Int64.from(destination.x)
         const y = Int64.from(destination.y)
 
         return this.server.action('warp', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
             x,
             y,
@@ -155,96 +134,219 @@ export class ActionsManager extends BaseManager {
     }
 
     craft(
-        entityType: EntityTypeName,
         entityId: UInt64Type,
         recipeId: number,
         quantity: number,
         inputs: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
-        const cargoInputs = inputs.map((i) => ServerContract.Types.cargo_item.from(i))
         return this.server.action('craft', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
             recipe_id: UInt16.from(recipeId),
             quantity: UInt32.from(quantity),
-            inputs: cargoInputs,
+            inputs,
         })
     }
 
-    blend(
-        entityType: EntityTypeName,
-        entityId: UInt64Type,
-        inputs: ServerContract.ActionParams.Type.cargo_item[]
-    ): Action {
-        const cargoInputs = inputs.map((i) => ServerContract.Types.cargo_item.from(i))
+    blend(entityId: UInt64Type, inputs: ServerContract.ActionParams.Type.cargo_item[]): Action {
         return this.server.action('blend', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
-            inputs: cargoInputs,
+            inputs,
         })
     }
 
-    deploy(
-        entityType: EntityTypeName,
-        entityId: UInt64Type,
-        packedItemId: number,
-        stats: bigint
-    ): Action {
+    deploy(entityId: UInt64Type, ref: ServerContract.ActionParams.Type.cargo_ref): Action {
         return this.server.action('deploy', {
-            entity_type: entityType,
             id: UInt64.from(entityId),
-            packed_item_id: UInt16.from(packedItemId),
-            stats: UInt64.from(stats),
+            ref,
+        })
+    }
+
+    claimplot(
+        entityId: UInt64Type,
+        targetItemId: UInt16Type,
+        coords: ServerContract.ActionParams.Type.coordinates
+    ): Action {
+        return this.server.action('claimplot', {
+            builder_id: UInt64.from(entityId),
+            target_item_id: UInt16.from(targetItemId),
+            coords,
+        })
+    }
+
+    buildplot(entityId: UInt64Type, plotId: UInt64Type): Action {
+        return this.server.action('buildplot', {
+            builder_id: UInt64.from(entityId),
+            plot_id: UInt64.from(plotId),
         })
     }
 
     addmodule(
-        entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        moduleCargoId: UInt64Type,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        moduleRef: ServerContract.ActionParams.Type.cargo_ref,
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('addmodule', {
-            entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            module_cargo_id: UInt64.from(moduleCargoId),
-            target_cargo_id: UInt64.from(targetCargoId),
+            module_ref: moduleRef,
+            target_ref: targetRef ?? undefined,
         })
     }
 
     rmmodule(
-        entityType: EntityTypeName,
         entityId: UInt64Type,
         moduleIndex: number,
-        targetCargoId: UInt64Type = UInt64.from(0)
+        targetRef: ServerContract.ActionParams.Type.cargo_ref | null = null
     ): Action {
         return this.server.action('rmmodule', {
-            entity_type: entityType,
             entity_id: UInt64.from(entityId),
             module_index: moduleIndex,
-            target_cargo_id: UInt64.from(targetCargoId),
+            target_ref: targetRef ?? undefined,
         })
     }
 
-    wrap(
+    async wrap(
         owner: NameType,
-        entityType: EntityTypeName,
         entityId: UInt64Type,
+        nexusId: UInt64Type,
         cargoId: UInt64Type,
         quantity: UInt64Type
-    ): Action {
-        return this.server.action('wrap', {
+    ): Promise<Action[]> {
+        return [
+            this.platform.action('wrapcargo', {
+                game: this.server.account,
+                owner: Name.from(owner),
+                entity_id: UInt64.from(entityId),
+                nexus_id: UInt64.from(nexusId),
+                cargo_id: UInt64.from(cargoId),
+                quantity: UInt64.from(quantity),
+            }),
+        ]
+    }
+
+    undeploy(hostId: UInt64Type, targetId: UInt64Type): Action {
+        return this.server.action('undeploy', {
+            host_id: UInt64.from(hostId),
+            target_id: UInt64.from(targetId),
+        })
+    }
+
+    async wrapEntity(
+        owner: NameType,
+        entityId: UInt64Type,
+        nexusId: UInt64Type
+    ): Promise<Action[]> {
+        return [
+            this.platform.action('wrapentity', {
+                game: this.server.account,
+                owner: Name.from(owner),
+                entity_id: UInt64.from(entityId),
+                nexus_id: UInt64.from(nexusId),
+            }),
+        ]
+    }
+
+    placecargo(owner: NameType, hostId: UInt64Type, assetId: UInt64Type): Action {
+        return this.server.action('placecargo', {
+            owner: Name.from(owner),
+            host_id: UInt64.from(hostId),
+            asset_id: UInt64.from(assetId),
+        })
+    }
+
+    placeentity(owner: NameType, assetId: UInt64Type, targetNexusId: UInt64Type): Action {
+        return this.server.action('placeentity', {
             owner: Name.from(owner),
-            entity_type: entityType,
+            asset_id: UInt64.from(assetId),
+            target_nexus_id: UInt64.from(targetNexusId),
+        })
+    }
+
+    transferForUnwrap(owner: NameType, assetId: UInt64Type): Action {
+        return Action.from({
+            account: 'atomicassets',
+            name: 'transfer',
+            authorization: [{actor: Name.from(owner), permission: 'active'}],
+            data: {
+                from: Name.from(owner),
+                to: this.platform.account,
+                asset_ids: [UInt64.from(assetId)],
+                memo: 'unwrap',
+            },
+        })
+    }
+
+    // Two top-level actions the wallet signs to unwrap an NFT into a host's cargo.
+    unwrapCargoTx(owner: NameType, assetId: UInt64Type, hostId: UInt64Type): Action[] {
+        return [this.transferForUnwrap(owner, assetId), this.placecargo(owner, hostId, assetId)]
+    }
+
+    // Two top-level actions the wallet signs to place an entity NFT at a nexus.
+    unwrapEntityTx(owner: NameType, assetId: UInt64Type, targetNexusId: UInt64Type): Action[] {
+        return [
+            this.transferForUnwrap(owner, assetId),
+            this.placeentity(owner, assetId, targetNexusId),
+        ]
+    }
+
+    setRamPayer(newPayer: NameType, assetId: UInt64Type): Action {
+        return Action.from({
+            account: 'atomicassets',
+            name: 'setrampayer',
+            authorization: [{actor: Name.from(newPayer), permission: 'active'}],
+            data: {new_payer: Name.from(newPayer), asset_id: UInt64.from(assetId)},
+        })
+    }
+
+    demolish(entityId: UInt64Type): Action {
+        return this.server.action('demolish', {
             entity_id: UInt64.from(entityId),
-            cargo_id: UInt64.from(cargoId),
-            quantity: UInt64.from(quantity),
         })
     }
 
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }
+
+    commit(oracleId: NameType, epoch: UInt64Type, commit: Checksum256Type): Action {
+        return this.server.action('commit', {
+            oracle_id: Name.from(oracleId),
+            epoch: UInt64.from(epoch),
+            commit: Checksum256.from(commit),
+        })
+    }
+
+    reveal(oracleId: NameType, epoch: UInt64Type, reveal: Checksum256Type): Action {
+        return this.server.action('reveal', {
+            oracle_id: Name.from(oracleId),
+            epoch: UInt64.from(epoch),
+            reveal: Checksum256.from(reveal),
+        })
+    }
+
+    addoracle(oracleId: NameType): Action {
+        return this.server.action('addoracle', {
+            oracle_id: Name.from(oracleId),
+        })
+    }
+
+    removeoracle(oracleId: NameType): Action {
+        return this.server.action('removeoracle', {
+            oracle_id: Name.from(oracleId),
+        })
+    }
+
+    setthreshold(threshold: UInt8Type): Action {
+        return this.server.action('setthreshold', {
+            threshold: UInt8.from(threshold),
+        })
+    }
+
+    cleanrsvp(epoch: UInt64Type, maxRows: UInt64Type): Action {
+        return this.server.action('cleanrsvp', {
+            epoch: UInt64.from(epoch),
+            max_rows: UInt64.from(maxRows),
+        })
+    }
 }

package/src/managers/base.ts

@@ -19,7 +19,7 @@ export abstract class BaseManager {
         return this.context.getGame()
     }
 
-    protected async getState() {
-        return this.context.getState()
+    protected async getState(reload = false) {
+        return this.context.getState(reload)
     }
 }

package/src/managers/construction-types.ts

@@ -0,0 +1,68 @@
+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' | 'finalizing'
+
+export type FinalizerCapability = 'crafter'
+
+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
+}
+
+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
+    name: string
+    capability: FinalizerCapability
+    crafterSpeed: number
+    estimatedDuration: UInt32
+}
+
+export interface InboundTransfer {
+    sourceEntityId: UInt64
+    sourceEntityType: Name
+    sourceName: string
+    itemId: number
+    quantity: number
+    etaSeconds: number
+}
+
+export interface Reservation {
+    targetEntityId: UInt64
+    targetEntityType: Name
+    itemId: number
+    quantity: number
+}