@shipload/sdk 0.3.0 → 0.3.2

package/lib/shipload.d.ts

@@ -1,4 +1,4 @@
-import { Blob, ABI, Struct, Name, UInt64, NameType, UInt64Type, Action, Int64, UInt16, Checksum256, UInt32, TimePoint, UInt8, BlockTimestamp, Int64Type, Checksum256Type, UInt16Type, Checksum512, APIClient } from '@wharfkit/antelope';
+import { Blob, ABI, Struct, Name, UInt64, Checksum256, UInt32, TimePointSec, Checksum256Type, UInt32Type, NameType, UInt64Type, Action, UInt16, Int64, TimePoint, UInt8, BlockTimestamp, Int64Type, UInt16Type, Checksum512, APIClient } from '@wharfkit/antelope';
 import { Contract as Contract$2, PartialBy, ContractArgs, ActionOptions, Table } from '@wharfkit/contract';
 import { ChainDefinition } from '@wharfkit/session';
 
@@ -17,31 +17,81 @@ declare namespace Types$1 {
     class enable extends Struct {
         enabled: boolean;
     }
+    class enablegame extends Struct {
+        contract: Name;
+        enabled: boolean;
+    }
     class foundcompany extends Struct {
         account: Name;
         name: string;
     }
+    class game_config extends Struct {
+        seed: Checksum256;
+        epochtime: UInt32;
+    }
+    class game_meta extends Struct {
+        name: string;
+        description: string;
+        url: string;
+        version: string;
+    }
+    class game_state extends Struct {
+        enabled: boolean;
+        start: TimePointSec;
+        end: TimePointSec;
+    }
+    class game_row extends Struct {
+        contract: Name;
+        config: game_config;
+        meta: game_meta;
+        state: game_state;
+    }
+    class startgame extends Struct {
+        contract: Name;
+        config: game_config;
+        meta: game_meta;
+        state: game_state;
+    }
     class state_row extends Struct {
         enabled: boolean;
     }
-    class test extends Struct {
-        data: string;
+    class updategame extends Struct {
+        contract: Name;
+        meta: game_meta;
     }
     class wipe extends Struct {
     }
 }
 declare const TableMap$1: {
     company: typeof Types$1.company_row;
+    games: typeof Types$1.game_row;
     state: typeof Types$1.state_row;
 };
 interface TableTypes$1 {
     company: Types$1.company_row;
+    games: Types$1.game_row;
     state: Types$1.state_row;
 }
 type RowType$1<T> = T extends keyof TableTypes$1 ? TableTypes$1[T] : any;
 type TableNames$1 = keyof TableTypes$1;
 declare namespace ActionParams$1 {
-    namespace Type { }
+    namespace Type {
+        interface game_config {
+            seed: Checksum256Type;
+            epochtime: UInt32Type;
+        }
+        interface game_meta {
+            name: string;
+            description: string;
+            url: string;
+            version: string;
+        }
+        interface game_state {
+            enabled: boolean;
+            start: TimePointSec;
+            end: TimePointSec;
+        }
+    }
     interface cleartable {
         table_name: NameType;
         scope?: NameType;
@@ -50,12 +100,23 @@ declare namespace ActionParams$1 {
     interface enable {
         enabled: boolean;
     }
+    interface enablegame {
+        contract: NameType;
+        enabled: boolean;
+    }
     interface foundcompany {
         account: NameType;
         name: string;
     }
-    interface test {
-        data: string;
+    interface startgame {
+        contract: NameType;
+        config: Type.game_config;
+        meta: Type.game_meta;
+        state: Type.game_state;
+    }
+    interface updategame {
+        contract: NameType;
+        meta: Type.game_meta;
     }
     interface wipe {
     }
@@ -63,8 +124,10 @@ declare namespace ActionParams$1 {
 interface ActionNameParams$1 {
     cleartable: ActionParams$1.cleartable;
     enable: ActionParams$1.enable;
+    enablegame: ActionParams$1.enablegame;
     foundcompany: ActionParams$1.foundcompany;
-    test: ActionParams$1.test;
+    startgame: ActionParams$1.startgame;
+    updategame: ActionParams$1.updategame;
     wipe: ActionParams$1.wipe;
 }
 type ActionNames$1 = keyof ActionNameParams$1;
@@ -94,6 +157,8 @@ declare const abiBlob: Blob;
 declare const abi: ABI;
 declare namespace Types {
     class advance extends Struct {
+        reveal: string;
+        commit: Checksum256;
     }
     class arrive extends Struct {
         owner: Name;
@@ -108,14 +173,17 @@ declare namespace Types {
         id: UInt64;
         ship_id: UInt64;
         good_id: UInt64;
-        quantity: UInt64;
-        loaded: UInt64;
+        quantity: UInt16;
+        loaded: UInt16;
     }
     class cleartable extends Struct {
         table_name: Name;
         scope?: Name;
         max_rows?: UInt64;
     }
+    class commit extends Struct {
+        commit: Checksum256;
+    }
     class coordinates extends Struct {
         x: Int64;
         y: Int64;
@@ -123,10 +191,6 @@ declare namespace Types {
     class enable extends Struct {
         enabled: boolean;
     }
-    class esttravel extends Struct {
-        id: UInt64;
-        destination: coordinates;
-    }
     class good_price extends Struct {
         id: UInt16;
         price: UInt64;
@@ -134,15 +198,16 @@ declare namespace Types {
     class hash extends Struct {
         value: string;
     }
+    class hash512 extends Struct {
+        value: string;
+    }
     class init extends Struct {
         seed: Checksum256;
-        epochseed: Checksum256;
     }
     class join extends Struct {
         account: Name;
     }
     class loader_stats extends Struct {
-        capacity: UInt16;
         mass: UInt32;
         quantity: UInt16;
         thrust: UInt32;
@@ -159,6 +224,9 @@ declare namespace Types {
         balance: UInt64;
         debt: UInt64;
     }
+    class salt extends Struct {
+        salt: UInt64;
+    }
     class sellgoods extends Struct {
         ship_id: UInt64;
         good_id: UInt64;
@@ -199,9 +267,16 @@ declare namespace Types {
     class state_row extends Struct {
         enabled: boolean;
         epoch: UInt64;
-        epochseed: Checksum256;
-        genesis: BlockTimestamp;
+        salt: UInt64;
         seed: Checksum256;
+        commit: Checksum256;
+        genesis: BlockTimestamp;
+    }
+    class travel extends Struct {
+        owner: Name;
+        id: UInt64;
+        destination: coordinates;
+        recharge: boolean;
     }
     class travel_summary extends Struct {
         stats: ship_stats;
@@ -217,18 +292,9 @@ declare namespace Types {
         loadtime: UInt64;
         time: UInt64;
     }
-    class summary_row extends Struct {
-        key: Name;
-        value: travel_summary;
-    }
-    class test extends Struct {
-        data: string;
-    }
-    class travel extends Struct {
-        owner: Name;
+    class traveltime extends Struct {
         id: UInt64;
         destination: coordinates;
-        recharge: boolean;
     }
     class wipe extends Struct {
     }
@@ -239,7 +305,6 @@ declare const TableMap: {
     sequence: typeof Types.sequence_row;
     ship: typeof Types.ship_row;
     state: typeof Types.state_row;
-    summary: typeof Types.summary_row;
 };
 interface TableTypes {
     cargo: Types.cargo_row;
@@ -247,7 +312,6 @@ interface TableTypes {
     sequence: Types.sequence_row;
     ship: Types.ship_row;
     state: Types.state_row;
-    summary: Types.summary_row;
 }
 type RowType<T> = T extends keyof TableTypes ? TableTypes[T] : any;
 type TableNames = keyof TableTypes;
@@ -259,6 +323,8 @@ declare namespace ActionParams {
         }
     }
     interface advance {
+        reveal: string;
+        commit: Checksum256Type;
     }
     interface arrive {
         owner: NameType;
@@ -274,19 +340,20 @@ declare namespace ActionParams {
         scope?: NameType;
         max_rows?: UInt64Type;
     }
+    interface commit {
+        commit: Checksum256Type;
+    }
     interface enable {
         enabled: boolean;
     }
-    interface esttravel {
-        id: UInt64Type;
-        destination: Type.coordinates;
-    }
     interface hash {
         value: string;
     }
+    interface hash512 {
+        value: string;
+    }
     interface init {
         seed: Checksum256Type;
-        epochseed: Checksum256Type;
     }
     interface join {
         account: NameType;
@@ -298,20 +365,24 @@ declare namespace ActionParams {
     interface marketprices {
         location: Type.coordinates;
     }
+    interface salt {
+        salt: UInt64Type;
+    }
     interface sellgoods {
         ship_id: UInt64Type;
         good_id: UInt64Type;
         quantity: UInt64Type;
     }
-    interface test {
-        data: string;
-    }
     interface travel {
         owner: NameType;
         id: UInt64Type;
         destination: Type.coordinates;
         recharge: boolean;
     }
+    interface traveltime {
+        id: UInt64Type;
+        destination: Type.coordinates;
+    }
     interface wipe {
     }
 }
@@ -320,24 +391,27 @@ interface ActionNameParams {
     arrive: ActionParams.arrive;
     buygoods: ActionParams.buygoods;
     cleartable: ActionParams.cleartable;
+    commit: ActionParams.commit;
     enable: ActionParams.enable;
-    esttravel: ActionParams.esttravel;
     hash: ActionParams.hash;
+    hash512: ActionParams.hash512;
     init: ActionParams.init;
     join: ActionParams.join;
     marketprice: ActionParams.marketprice;
     marketprices: ActionParams.marketprices;
+    salt: ActionParams.salt;
     sellgoods: ActionParams.sellgoods;
-    test: ActionParams.test;
     travel: ActionParams.travel;
+    traveltime: ActionParams.traveltime;
     wipe: ActionParams.wipe;
 }
 type ActionNames = keyof ActionNameParams;
 interface ActionReturnValues {
-    esttravel: Types.travel_summary;
-    hash: Checksum512;
+    hash: Checksum256;
+    hash512: Checksum512;
     marketprice: Types.good_price;
     marketprices: Types.good_price[];
+    traveltime: Types.travel_summary;
 }
 type ActionReturnNames = keyof ActionReturnValues;
 declare class Contract extends Contract$2 {
@@ -379,8 +453,10 @@ declare namespace server {
   };
 }
 
+declare function getCurrentEpoch(game: Types$1.game_row, state: Types.state_row): Promise<number>;
+
 declare function hash(seed: Checksum256Type, string: string): Checksum512;
-declare function hashBytes(seed: Checksum256Type, string: string): Uint8Array;
+declare function hash512(seed: Checksum256Type, string: string): Checksum512;
 
 interface Coordinates {
     x: number;
@@ -394,9 +470,9 @@ interface Dimensions {
     height: number;
 }
 interface Distance {
-    origin: Coordinates;
-    destination: Coordinates;
-    distance: number;
+    origin: ActionParams.Type.coordinates;
+    destination: ActionParams.Type.coordinates;
+    distance: UInt16;
 }
 interface Good {
     id: UInt16;
@@ -411,14 +487,12 @@ interface GoodPrice {
 }
 
 declare function distanceTraveled(ship: Types.ship_row): number;
-declare function distanceBetweenPoints(x1: number, y1: number, x2: number, y2: number): number;
-declare function lerp(origin: Coordinates, destination: Coordinates, time: number): {
-    x: number;
-    y: number;
-};
-declare function rotation(origin: Coordinates, destination: Coordinates): number;
-declare function hasPlanet(seed: Checksum256, coords: Coordinates): boolean;
-declare function findNearbyPlanets(seed: Checksum256, origin: Coordinates, maxDistance?: number): Distance[];
+declare function distanceBetweenCoordinates(origin: ActionParams.Type.coordinates, destination: ActionParams.Type.coordinates): UInt16;
+declare function distanceBetweenPoints(x1: UInt64Type, y1: UInt64Type, x2: UInt64Type, y2: UInt64Type): UInt16;
+declare function lerp(origin: ActionParams.Type.coordinates, destination: ActionParams.Type.coordinates, time: number): ActionParams.Type.coordinates;
+declare function rotation(origin: ActionParams.Type.coordinates, destination: ActionParams.Type.coordinates): number;
+declare function hasPlanet(seed: Checksum256, coordinates: ActionParams.Type.coordinates): boolean;
+declare function findNearbyPlanets(seed: Checksum256, origin: ActionParams.Type.coordinates, maxDistance?: UInt16Type): Distance[];
 
 declare const goods: Good[];
 declare function getGood(good_id: UInt16Type): Good;
@@ -438,20 +512,24 @@ declare const INSUFFICIENT_GOOD_QUANTITY = "Insufficient good quantity";
 declare const REQUIRES_MORE_THAN_ONE = "Requires more than one";
 
 interface ShiploadOptions {
-    contractName?: string;
+    platformContractName?: string;
+    serverContractName?: string;
     client?: APIClient;
 }
 interface ShiploadConstructorOptions extends ShiploadOptions {
+    platformContract: Contract$2;
     serverContract: Contract$2;
 }
 declare class Shipload {
-    private client;
-    private server;
-    constructor(chain: ChainDefinition, { client, serverContract }: ShiploadConstructorOptions);
+    client: APIClient;
+    server: Contract$2;
+    platform: Contract$2;
+    constructor(chain: ChainDefinition, { client, platformContract, serverContract }: ShiploadConstructorOptions);
     static load(chain: ChainDefinition, shiploadOptions: ShiploadOptions): Promise<Shipload>;
+    getGame(): Promise<Types$1.game_row>;
     getState(): Promise<Types.state_row>;
     marketprice(location: Coordinates, good_id: number): Promise<UInt64>;
     marketprices(location: Coordinates): Promise<GoodPrice[]>;
 }
 
-export { CameraPosition, Coordinates, Dimensions, Distance, ERROR_SYSTEM_NOT_INITIALIZED, GOOD_DOES_NOT_EXIST, GOOD_NOT_AVAILABLE_AT_LOCATION, Good, GoodPrice, INSUFFICIENT_BALANCE, INSUFFICIENT_GOOD_QUANTITY, PLAYER_NOT_FOUND, platform as PlatformContract, REQUIRES_MORE_THAN_ONE, SHIP_CANNOT_BUY_TRAVELING, SHIP_NOT_FOUND, server as ServerContract, Shipload as default, distanceBetweenPoints, distanceTraveled, findNearbyPlanets, getGood, goods, hasPlanet, hash, hashBytes, lerp, marketprice, marketprices, priceFromRoll, rotation };
+export { CameraPosition, Coordinates, Dimensions, Distance, ERROR_SYSTEM_NOT_INITIALIZED, GOOD_DOES_NOT_EXIST, GOOD_NOT_AVAILABLE_AT_LOCATION, Good, GoodPrice, INSUFFICIENT_BALANCE, INSUFFICIENT_GOOD_QUANTITY, PLAYER_NOT_FOUND, platform as PlatformContract, REQUIRES_MORE_THAN_ONE, SHIP_CANNOT_BUY_TRAVELING, SHIP_NOT_FOUND, server as ServerContract, Shipload as default, distanceBetweenCoordinates, distanceBetweenPoints, distanceTraveled, findNearbyPlanets, getCurrentEpoch, getGood, goods, hasPlanet, hash, hash512, lerp, marketprice, marketprices, priceFromRoll, rotation };