@shipload/sdk 0.3.1 → 0.3.2

package/src/epoch.ts

@@ -0,0 +1,11 @@
+import {PlatformContract, ServerContract} from './contracts'
+
+export async function getCurrentEpoch(
+    game: PlatformContract.Types.game_row,
+    state: ServerContract.Types.state_row
+): Promise<number> {
+    const current = new Date().getTime()
+    const difference = (current - state.genesis.toDate().getTime()) / 1000
+    const epoch = Math.floor(difference / Number(game.config.epochtime)) + 1
+    return epoch
+}

package/src/hash.ts

@@ -1,10 +1,11 @@
-import {Bytes, Checksum256Type, Checksum512} from '@wharfkit/antelope'
+import {Bytes, Checksum256, Checksum256Type, Checksum512} from '@wharfkit/antelope'
 
 export function hash(seed: Checksum256Type, string: string): Checksum512 {
     const bytes = Bytes.from(`${seed}${string}`, 'utf8')
-    return Checksum512.hash(bytes)
+    return Checksum256.hash(bytes)
 }
 
-export function hashBytes(seed: Checksum256Type, string: string): Uint8Array {
-    return hash(seed, string).array
+export function hash512(seed: Checksum256Type, string: string): Checksum512 {
+    const bytes = Bytes.from(`${seed}${string}`, 'utf8')
+    return Checksum512.hash(bytes)
 }

package/src/index-module.ts

@@ -1,4 +1,5 @@
 export * from './contracts'
+export * from './epoch'
 export * from './hash'
 export * from './travel'
 export * from './types'

package/src/rolls.ts

@@ -1,8 +1,8 @@
 import {Checksum256Type} from '@wharfkit/antelope'
-import {hashBytes} from './hash'
+import {hash512} from './hash'
 
 export function roll(game_seed: Checksum256Type, roll_seed: string): number {
-    const byteArray = hashBytes(game_seed, roll_seed)
+    const hash = hash512(game_seed, roll_seed)
     // Combine the first two bytes to form a uint16_t value
-    return (byteArray[0] << 8) | byteArray[1]
+    return (hash.array[0] << 8) | hash.array[1]
 }

package/src/shipload.ts

@@ -1,42 +1,74 @@
 import {APIClient, UInt64} from '@wharfkit/antelope'
 import {Coordinates, GoodPrice} from './types'
 import {marketprice, marketprices} from './market'
-import {ServerContract} from './contracts'
+import {PlatformContract, ServerContract} from './contracts'
 import {ERROR_SYSTEM_NOT_INITIALIZED} from './errors'
 import {ChainDefinition} from '@wharfkit/session'
 import ContractKit, {Contract} from '@wharfkit/contract'
 
 interface ShiploadOptions {
-    contractName?: string
+    platformContractName?: string
+    serverContractName?: string
     client?: APIClient
 }
 
 interface ShiploadConstructorOptions extends ShiploadOptions {
+    platformContract: Contract
     serverContract: Contract
 }
 
 export class Shipload {
-    private client: APIClient
-    private server: Contract
+    public client: APIClient
+    public server: Contract
+    public platform: Contract
 
-    constructor(chain: ChainDefinition, {client, serverContract}: ShiploadConstructorOptions) {
+    constructor(
+        chain: ChainDefinition,
+        {client, platformContract, serverContract}: ShiploadConstructorOptions
+    ) {
         this.client = client || new APIClient({url: chain.url})
 
+        this.platform = platformContract
+            ? platformContract
+            : new PlatformContract.Contract({client: this.client})
+
         this.server = serverContract
             ? serverContract
             : new ServerContract.Contract({client: this.client})
     }
 
     static async load(chain: ChainDefinition, shiploadOptions: ShiploadOptions): Promise<Shipload> {
+        let platform: Contract = new PlatformContract.Contract({
+            client: new APIClient({url: chain.url}),
+        })
+        if (shiploadOptions.platformContractName) {
+            const client = shiploadOptions.client || new APIClient({url: chain.url})
+            const contractKit = new ContractKit({client})
+            platform = await contractKit.load(shiploadOptions.platformContractName)
+        }
+
         let server: Contract = new ServerContract.Contract({
             client: new APIClient({url: chain.url}),
         })
-        if (shiploadOptions.contractName) {
+        if (shiploadOptions.serverContractName) {
             const client = shiploadOptions.client || new APIClient({url: chain.url})
             const contractKit = new ContractKit({client})
-            server = await contractKit.load(shiploadOptions.contractName)
+            server = await contractKit.load(shiploadOptions.serverContractName)
+        }
+
+        return new Shipload(chain, {
+            ...shiploadOptions,
+            platformContract: platform,
+            serverContract: server,
+        })
+    }
+
+    async getGame(): Promise<PlatformContract.Types.game_row> {
+        const game = await this.platform.table('games').get()
+        if (!game) {
+            throw new Error(ERROR_SYSTEM_NOT_INITIALIZED)
         }
-        return new Shipload(chain, {...shiploadOptions, serverContract: server})
+        return game
     }
 
     async getState(): Promise<ServerContract.Types.state_row> {
@@ -48,12 +80,14 @@ export class Shipload {
     }
 
     async marketprice(location: Coordinates, good_id: number): Promise<UInt64> {
-        const {seed, epochseed} = await this.getState()
-        return marketprice(location, good_id, seed, epochseed)
+        const game = await this.getGame()
+        const state = await this.getState()
+        return marketprice(location, good_id, game.config.seed, state.seed)
     }
 
     async marketprices(location: Coordinates): Promise<GoodPrice[]> {
-        const {seed, epochseed} = await this.getState()
-        return marketprices(location, seed, epochseed)
+        const game = await this.getGame()
+        const state = await this.getState()
+        return marketprices(location, game.config.seed, state.seed)
     }
 }

package/src/travel.ts

@@ -1,7 +1,7 @@
 import {Checksum256, Int64, UInt16, UInt16Type, UInt64, UInt64Type} from '@wharfkit/antelope'
 
 import {ServerContract} from './contracts'
-import {hash} from './hash'
+import {hash512} from './hash'
 import {Distance} from './types'
 
 export function distanceTraveled(ship: ServerContract.Types.ship_row): number {
@@ -53,7 +53,7 @@ export function hasPlanet(
     coordinates: ServerContract.ActionParams.Type.coordinates
 ): boolean {
     const str = ['system', coordinates.x, coordinates.y].join('-')
-    return String(hash(seed, str)).slice(0, 2) === '00'
+    return String(hash512(seed, str)).slice(0, 2) === '00'
 }
 
 export function findNearbyPlanets(