@shipload/sdk 0.2.1 → 0.3.0

package/lib/shipload.d.ts

@@ -1,5 +1,6 @@
-import { Blob, ABI, Struct, Name, UInt64, NameType, UInt64Type, Action, Int64, Checksum256, UInt16, UInt32, TimePoint, UInt8, BlockTimestamp, Int64Type, Checksum256Type, Checksum512 } from '@wharfkit/antelope';
+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 { Contract as Contract$2, PartialBy, ContractArgs, ActionOptions, Table } from '@wharfkit/contract';
+import { ChainDefinition } from '@wharfkit/session';
 
 declare const abiBlob$1: Blob;
 declare const abi$1: ABI;
@@ -99,7 +100,6 @@ declare namespace Types {
         id: UInt64;
     }
     class buygoods extends Struct {
-        buyer: Name;
         ship_id: UInt64;
         good_id: UInt64;
         quantity: UInt64;
@@ -109,6 +109,7 @@ declare namespace Types {
         ship_id: UInt64;
         good_id: UInt64;
         quantity: UInt64;
+        loaded: UInt64;
     }
     class cleartable extends Struct {
         table_name: Name;
@@ -126,6 +127,10 @@ declare namespace Types {
         id: UInt64;
         destination: coordinates;
     }
+    class good_price extends Struct {
+        id: UInt16;
+        price: UInt64;
+    }
     class hash extends Struct {
         value: string;
     }
@@ -142,13 +147,19 @@ declare namespace Types {
         quantity: UInt16;
         thrust: UInt32;
     }
+    class marketprice extends Struct {
+        location: coordinates;
+        good_id: UInt16;
+    }
+    class marketprices extends Struct {
+        location: coordinates;
+    }
     class player_row extends Struct {
         owner: Name;
         balance: UInt64;
         debt: UInt64;
     }
     class sellgoods extends Struct {
-        seller: Name;
         ship_id: UInt64;
         good_id: UInt64;
         quantity: UInt64;
@@ -157,10 +168,12 @@ declare namespace Types {
         key: Name;
         value: UInt64;
     }
+    class ship_state extends Struct {
+        energy: UInt32;
+    }
     class ship_stats extends Struct {
         capacity: UInt32;
         drain: UInt32;
-        energy: UInt32;
         mass: UInt64;
         orbit: UInt16;
         recharge: UInt32;
@@ -178,6 +191,7 @@ declare namespace Types {
         location: coordinates;
         skin: UInt8;
         tier: UInt8;
+        state: ship_state;
         stats: ship_stats;
         loaders: loader_stats;
         travelplan?: travel_plan;
@@ -251,7 +265,6 @@ declare namespace ActionParams {
         id: UInt64Type;
     }
     interface buygoods {
-        buyer: NameType;
         ship_id: UInt64Type;
         good_id: UInt64Type;
         quantity: UInt64Type;
@@ -278,8 +291,14 @@ declare namespace ActionParams {
     interface join {
         account: NameType;
     }
+    interface marketprice {
+        location: Type.coordinates;
+        good_id: UInt16Type;
+    }
+    interface marketprices {
+        location: Type.coordinates;
+    }
     interface sellgoods {
-        seller: NameType;
         ship_id: UInt64Type;
         good_id: UInt64Type;
         quantity: UInt64Type;
@@ -306,6 +325,8 @@ interface ActionNameParams {
     hash: ActionParams.hash;
     init: ActionParams.init;
     join: ActionParams.join;
+    marketprice: ActionParams.marketprice;
+    marketprices: ActionParams.marketprices;
     sellgoods: ActionParams.sellgoods;
     test: ActionParams.test;
     travel: ActionParams.travel;
@@ -315,6 +336,8 @@ type ActionNames = keyof ActionNameParams;
 interface ActionReturnValues {
     esttravel: Types.travel_summary;
     hash: Checksum512;
+    marketprice: Types.good_price;
+    marketprices: Types.good_price[];
 }
 type ActionReturnNames = keyof ActionReturnValues;
 declare class Contract extends Contract$2 {
@@ -356,7 +379,8 @@ declare namespace server {
   };
 }
 
-declare function hash(seed: Checksum256Type, string: string): string;
+declare function hash(seed: Checksum256Type, string: string): Checksum512;
+declare function hashBytes(seed: Checksum256Type, string: string): Uint8Array;
 
 interface Coordinates {
     x: number;
@@ -374,16 +398,60 @@ interface Distance {
     destination: Coordinates;
     distance: number;
 }
+interface Good {
+    id: UInt16;
+    name: string;
+    description: string;
+    base_price: UInt64;
+    mass: UInt64;
+}
+interface GoodPrice {
+    id: UInt16;
+    price: UInt64;
+}
 
-declare function distance(ship: Types.ship_row): number;
+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 const goods: Good[];
+declare function getGood(good_id: UInt16Type): Good;
 
+declare function marketprice(location: Coordinates, good_id: UInt16Type, gameSeed: Checksum256Type, epochSeed: Checksum256Type): Promise<UInt64>;
+declare function marketprices(location: Coordinates, gameSeed: Checksum256Type, epochSeed: Checksum256Type): Promise<GoodPrice[]>;
+declare function priceFromRoll(basePrice: UInt64Type, roll: number): UInt64;
+
+declare const ERROR_SYSTEM_NOT_INITIALIZED = "System not initialized";
+declare const GOOD_DOES_NOT_EXIST = "Good does not exist";
+declare const GOOD_NOT_AVAILABLE_AT_LOCATION = "Good not available at location";
+declare const PLAYER_NOT_FOUND = "Player not found";
+declare const SHIP_NOT_FOUND = "Ship not found";
+declare const SHIP_CANNOT_BUY_TRAVELING = "Ship cannot buy while traveling";
+declare const INSUFFICIENT_BALANCE = "Insufficient balance";
+declare const INSUFFICIENT_GOOD_QUANTITY = "Insufficient good quantity";
+declare const REQUIRES_MORE_THAN_ONE = "Requires more than one";
+
+interface ShiploadOptions {
+    contractName?: string;
+    client?: APIClient;
+}
+interface ShiploadConstructorOptions extends ShiploadOptions {
+    serverContract: Contract$2;
+}
 declare class Shipload {
+    private client;
+    private server;
+    constructor(chain: ChainDefinition, { client, serverContract }: ShiploadConstructorOptions);
+    static load(chain: ChainDefinition, shiploadOptions: ShiploadOptions): Promise<Shipload>;
+    getState(): Promise<Types.state_row>;
+    marketprice(location: Coordinates, good_id: number): Promise<UInt64>;
+    marketprices(location: Coordinates): Promise<GoodPrice[]>;
 }
 
-export { CameraPosition, Coordinates, Dimensions, Distance, platform as PlatformContract, server as ServerContract, Shipload as default, distance, hasPlanet, hash, lerp, 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, distanceBetweenPoints, distanceTraveled, findNearbyPlanets, getGood, goods, hasPlanet, hash, hashBytes, lerp, marketprice, marketprices, priceFromRoll, rotation };

package/lib/shipload.js

@@ -4,7 +4,11 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 var antelope = require('@wharfkit/antelope');
-var contract = require('@wharfkit/contract');
+var ContractKit = require('@wharfkit/contract');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ContractKit__default = /*#__PURE__*/_interopDefaultLegacy(ContractKit);
 
 const abiBlob$1 = antelope.Blob.from('DmVvc2lvOjphYmkvMS4yAAcKY2xlYXJ0YWJsZQADCnRhYmxlX25hbWUEbmFtZQVzY29wZQVuYW1lPwhtYXhfcm93cwd1aW50NjQ/C2NvbXBhbnlfcm93AAIHYWNjb3VudARuYW1lBG5hbWUGc3RyaW5nBmVuYWJsZQABB2VuYWJsZWQEYm9vbAxmb3VuZGNvbXBhbnkAAgdhY2NvdW50BG5hbWUEbmFtZQZzdHJpbmcJc3RhdGVfcm93AAEHZW5hYmxlZARib29sBHRlc3QAAQRkYXRhBnN0cmluZwR3aXBlAAAFAICKx+RrVEQKY2xlYXJ0YWJsZQAAAAAAqHjMVAZlbmFibGXzAS0tLQoKc3BlY192ZXJzaW9uOiAiMC4yLjAiCnRpdGxlOiBlbmFibGUKc3VtbWFyeTogJ0VuYWJsZS9kaXNhYmxlIHBsYXRmb3JtJwppY29uOiBodHRwczovL2F2YXRhcnMuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3UvMTU4MTEzNzgyI2QzYmYyOTBmZGRlZGRiYjdkMzJhYTg5N2U5ZjdlOWUxM2EyYWU0NDk1NjE0MmUyM2ViNDdiNzcwOTZhMmVhOGQKCi0tLQoKRW5hYmxlIG9yIGRpc2FibGUgdGhlIHBsYXRmb3JtIGNvbnRyYWN0LuCnqZKiNDVdDGZvdW5kY29tcGFueYMCLS0tCgpzcGVjX3ZlcnNpb246ICIwLjIuMCIKdGl0bGU6IGZvdW5kY29tcGFueQpzdW1tYXJ5OiAnRm91bmQgYSBuZXcgY29tcGFueScKaWNvbjogaHR0cHM6Ly9hdmF0YXJzLmdpdGh1YnVzZXJjb250ZW50LmNvbS91LzE1ODExMzc4MiNkM2JmMjkwZmRkZWRkYmI3ZDMyYWE4OTdlOWY3ZTllMTNhMmFlNDQ5NTYxNDJlMjNlYjQ3Yjc3MDk2YTJlYThkCgotLS0KCkZvdW5kIGEgbmV3IGNvbXBhbnkgaW4gdGhlIFNoaXBsb2FkIHBsYXRmb3JtIGNvbnRyYWN0LgAAAAAAkLHKBHRlc3QAAAAAAACgquMEd2lwZQACAAAAwE9TJUUDaTY0AAALY29tcGFueV9yb3cAAAAAAJVNxgNpNjQAAAlzdGF0ZV9yb3cBE1NoaXBsb2FkIChQbGF0Zm9ybSkTU2hpcGxvYWQgKFBsYXRmb3JtKQAAAAA=');
 const abi$1 = antelope.ABI.from(abiBlob$1);
@@ -87,7 +91,7 @@ const TableMap$1 = {
     company: Types$1.company_row,
     state: Types$1.state_row,
 };
-class Contract$1 extends contract.Contract {
+class Contract$1 extends ContractKit.Contract {
     constructor(args) {
         super({
             client: args.client,
@@ -112,7 +116,7 @@ var platform = /*#__PURE__*/Object.freeze({
     Contract: Contract$1
 });
 
-const abiBlob = antelope.Blob.from('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');
+const abiBlob = antelope.Blob.from('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');
 const abi = antelope.ABI.from(abiBlob);
 var Types;
 (function (Types) {
@@ -136,9 +140,6 @@ var Types;
     Types.arrive = arrive;
     let buygoods = class buygoods extends antelope.Struct {
     };
-    tslib.__decorate([
-        antelope.Struct.field(antelope.Name)
-    ], buygoods.prototype, "buyer", void 0);
     tslib.__decorate([
         antelope.Struct.field(antelope.UInt64)
     ], buygoods.prototype, "ship_id", void 0);
@@ -166,6 +167,9 @@ var Types;
     tslib.__decorate([
         antelope.Struct.field(antelope.UInt64)
     ], cargo_row.prototype, "quantity", void 0);
+    tslib.__decorate([
+        antelope.Struct.field(antelope.UInt64)
+    ], cargo_row.prototype, "loaded", void 0);
     cargo_row = tslib.__decorate([
         antelope.Struct.type('cargo_row')
     ], cargo_row);
@@ -218,6 +222,18 @@ var Types;
         antelope.Struct.type('esttravel')
     ], esttravel);
     Types.esttravel = esttravel;
+    let good_price = class good_price extends antelope.Struct {
+    };
+    tslib.__decorate([
+        antelope.Struct.field(antelope.UInt16)
+    ], good_price.prototype, "id", void 0);
+    tslib.__decorate([
+        antelope.Struct.field(antelope.UInt64)
+    ], good_price.prototype, "price", void 0);
+    good_price = tslib.__decorate([
+        antelope.Struct.type('good_price')
+    ], good_price);
+    Types.good_price = good_price;
     let hash = class hash extends antelope.Struct {
     };
     tslib.__decorate([
@@ -266,6 +282,27 @@ var Types;
         antelope.Struct.type('loader_stats')
     ], loader_stats);
     Types.loader_stats = loader_stats;
+    let marketprice = class marketprice extends antelope.Struct {
+    };
+    tslib.__decorate([
+        antelope.Struct.field(coordinates)
+    ], marketprice.prototype, "location", void 0);
+    tslib.__decorate([
+        antelope.Struct.field(antelope.UInt16)
+    ], marketprice.prototype, "good_id", void 0);
+    marketprice = tslib.__decorate([
+        antelope.Struct.type('marketprice')
+    ], marketprice);
+    Types.marketprice = marketprice;
+    let marketprices = class marketprices extends antelope.Struct {
+    };
+    tslib.__decorate([
+        antelope.Struct.field(coordinates)
+    ], marketprices.prototype, "location", void 0);
+    marketprices = tslib.__decorate([
+        antelope.Struct.type('marketprices')
+    ], marketprices);
+    Types.marketprices = marketprices;
     let player_row = class player_row extends antelope.Struct {
     };
     tslib.__decorate([
@@ -283,9 +320,6 @@ var Types;
     Types.player_row = player_row;
     let sellgoods = class sellgoods extends antelope.Struct {
     };
-    tslib.__decorate([
-        antelope.Struct.field(antelope.Name)
-    ], sellgoods.prototype, "seller", void 0);
     tslib.__decorate([
         antelope.Struct.field(antelope.UInt64)
     ], sellgoods.prototype, "ship_id", void 0);
@@ -311,6 +345,15 @@ var Types;
         antelope.Struct.type('sequence_row')
     ], sequence_row);
     Types.sequence_row = sequence_row;
+    let ship_state = class ship_state extends antelope.Struct {
+    };
+    tslib.__decorate([
+        antelope.Struct.field(antelope.UInt32)
+    ], ship_state.prototype, "energy", void 0);
+    ship_state = tslib.__decorate([
+        antelope.Struct.type('ship_state')
+    ], ship_state);
+    Types.ship_state = ship_state;
     let ship_stats = class ship_stats extends antelope.Struct {
     };
     tslib.__decorate([
@@ -319,9 +362,6 @@ var Types;
     tslib.__decorate([
         antelope.Struct.field(antelope.UInt32)
     ], ship_stats.prototype, "drain", void 0);
-    tslib.__decorate([
-        antelope.Struct.field(antelope.UInt32)
-    ], ship_stats.prototype, "energy", void 0);
     tslib.__decorate([
         antelope.Struct.field(antelope.UInt64)
     ], ship_stats.prototype, "mass", void 0);
@@ -373,6 +413,9 @@ var Types;
     tslib.__decorate([
         antelope.Struct.field(antelope.UInt8)
     ], ship_row.prototype, "tier", void 0);
+    tslib.__decorate([
+        antelope.Struct.field(ship_state)
+    ], ship_row.prototype, "state", void 0);
     tslib.__decorate([
         antelope.Struct.field(ship_stats)
     ], ship_row.prototype, "stats", void 0);
@@ -503,7 +546,7 @@ const TableMap = {
     state: Types.state_row,
     summary: Types.summary_row,
 };
-class Contract extends contract.Contract {
+class Contract extends ContractKit.Contract {
     constructor(args) {
         super({
             client: args.client,
@@ -533,16 +576,24 @@ var server = /*#__PURE__*/Object.freeze({
 
 function hash(seed, string) {
     const bytes = antelope.Bytes.from(`${seed}${string}`, 'utf8');
-    return String(antelope.Checksum512.hash(bytes));
+    return antelope.Checksum512.hash(bytes);
+}
+function hashBytes(seed, string) {
+    return hash(seed, string).array;
 }
 
-function distance(ship) {
+function distanceTraveled(ship) {
     if (ship.travelplan) {
         const { departure, duration } = ship.travelplan;
         return (+new Date() - +departure.toDate()) / (Number(duration) * 1000);
     }
     return 0;
 }
+function distanceBetweenPoints(x1, y1, x2, y2) {
+    const x = Math.pow(x1 - x2, 2);
+    const y = Math.pow(y1 - y2, 2);
+    return Math.sqrt(x + y);
+}
 function lerp(origin, destination, time) {
     return {
         x: (1 - time) * origin.x + time * destination.x,
@@ -554,18 +605,275 @@ function rotation(origin, destination) {
 }
 function hasPlanet(seed, coords) {
     const str = ['system', coords.x, coords.y].join('-');
-    return hash(seed, str).slice(0, 2) === '00';
+    return String(hash(seed, str)).slice(0, 2) === '00';
+}
+function findNearbyPlanets(seed, origin, maxDistance = 20) {
+    const nearbySystems = [];
+    const xMin = origin.x - maxDistance;
+    const xMax = origin.x + maxDistance;
+    const yMin = origin.y - maxDistance;
+    const yMax = origin.y + maxDistance;
+    for (let x = xMin; x <= xMax; x++) {
+        for (let y = yMin; y <= yMax; y++) {
+            const samePlace = x === origin.x && y === origin.y;
+            if (!samePlace) {
+                const distance = distanceBetweenPoints(origin.x, origin.y, x, y);
+                if (distance <= maxDistance) {
+                    const system = hasPlanet(seed, { x, y });
+                    if (system) {
+                        nearbySystems.push({ origin, destination: { x, y }, distance });
+                    }
+                }
+            }
+        }
+    }
+    return nearbySystems;
 }
 
+const goods = [
+    {
+        id: antelope.UInt16.from(1),
+        name: 'FizzGlo',
+        description: 'Pops with flavor! A neon drink that makes your burps glow.',
+        base_price: antelope.UInt64.from(200),
+        mass: antelope.UInt64.from(500),
+    },
+    {
+        id: antelope.UInt16.from(2),
+        name: 'ZapSnacks',
+        description: 'Electric taste! Spicy edible energy sparks for a tongue-tingling experience.',
+        base_price: antelope.UInt64.from(300),
+        mass: antelope.UInt64.from(2000),
+    },
+    {
+        id: antelope.UInt16.from(3),
+        name: 'Blob Buddies',
+        description: 'Squishy friends! Clingy, cute and mood-matching pet blobs for every home!',
+        base_price: antelope.UInt64.from(400),
+        mass: antelope.UInt64.from(10000),
+    },
+    {
+        id: antelope.UInt16.from(4),
+        name: 'TuneTooth',
+        description: 'Whistle while you eat! Edible instrument treats that play tunes when chewed.',
+        base_price: antelope.UInt64.from(600),
+        mass: antelope.UInt64.from(3000),
+    },
+    {
+        id: antelope.UInt16.from(5),
+        name: 'SunPods',
+        description: 'Miniature suns in your pocket providing on-demand light & warmth.',
+        base_price: antelope.UInt64.from(800),
+        mass: antelope.UInt64.from(1000),
+    },
+    {
+        id: antelope.UInt16.from(6),
+        name: 'Fuzzix',
+        description: 'Pocket-sized quantum fluff generator for instant comfy.',
+        base_price: antelope.UInt64.from(1000),
+        mass: antelope.UInt64.from(4000),
+    },
+    {
+        id: antelope.UInt16.from(7),
+        name: 'GlowGo',
+        description: 'Ingestible bioluminescent jelly, your inside glows in the dark!',
+        base_price: antelope.UInt64.from(140),
+        mass: antelope.UInt64.from(3000),
+    },
+    {
+        id: antelope.UInt16.from(8),
+        name: 'KrackleKaps',
+        description: 'Capsules packed with tiny firecrackers, spice up meals and parties.',
+        base_price: antelope.UInt64.from(180),
+        mass: antelope.UInt64.from(2000),
+    },
+    {
+        id: antelope.UInt16.from(9),
+        name: 'PlasmaMints',
+        description: 'Hypercharged candy giving plasma breath capable of cutting through steel.',
+        base_price: antelope.UInt64.from(220),
+        mass: antelope.UInt64.from(500),
+    },
+    {
+        id: antelope.UInt16.from(10),
+        name: 'TimeTreats',
+        description: 'Confectionery morsels releasing slow-mo effect over a limited period.',
+        base_price: antelope.UInt64.from(250),
+        mass: antelope.UInt64.from(3000),
+    },
+    {
+        id: antelope.UInt16.from(11),
+        name: 'QuantumQuencher',
+        description: 'Bottled hyper-fluid quenching thirst across multiple parallel realities simultaneously.',
+        base_price: antelope.UInt64.from(300),
+        mass: antelope.UInt64.from(6000),
+    },
+    {
+        id: antelope.UInt16.from(12),
+        name: 'TransmatterTruffles',
+        description: 'Delectable chocolates instantly teleporting consumers short distances.',
+        base_price: antelope.UInt64.from(350),
+        mass: antelope.UInt64.from(4000),
+    },
+    {
+        id: antelope.UInt16.from(13),
+        name: 'MemoryGum',
+        description: 'Chewable gum storing or replaying memories while being chewed.',
+        base_price: antelope.UInt64.from(400),
+        mass: antelope.UInt64.from(500),
+    },
+    {
+        id: antelope.UInt16.from(14),
+        name: 'SymbioSnack',
+        description: 'Edible alien larvae adopting owner’s taste preference upon consumption.',
+        base_price: antelope.UInt64.from(500),
+        mass: antelope.UInt64.from(1000),
+    },
+];
+function getGood(good_id) {
+    const good = goods.find((g) => g.id.equals(good_id));
+    if (!good) {
+        throw new Error('Good does not exist');
+    }
+    return good;
+}
+
+function roll(game_seed, roll_seed) {
+    const byteArray = hashBytes(game_seed, roll_seed);
+    return (byteArray[0] << 8) | byteArray[1];
+}
+
+function marketprice(location, good_id, gameSeed, epochSeed) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        const good = getGood(good_id);
+        const rollSeed = `${location.x}${epochSeed}${location.y}${good_id}`;
+        const rollValue = roll(gameSeed, rollSeed);
+        return priceFromRoll(good.base_price, rollValue);
+    });
+}
+function marketprices(location, gameSeed, epochSeed) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        return Promise.all(goods.map((good) => tslib.__awaiter(this, void 0, void 0, function* () {
+            const price = yield marketprice(location, good.id, gameSeed, epochSeed);
+            return { price, id: good.id };
+        })));
+    });
+}
+function priceFromRoll(basePrice, roll) {
+    basePrice = Number(basePrice);
+    let price;
+    if (roll < 13) {
+        price = basePrice * 2.25;
+    }
+    else if (roll < 176) {
+        price = basePrice * 1.75;
+    }
+    else if (roll < 996) {
+        price = basePrice * 1.4;
+    }
+    else if (roll < 2966) {
+        price = basePrice * 1.225;
+    }
+    else if (roll < 19568) {
+        price = basePrice * 1.07;
+    }
+    else if (roll < 45988) {
+        price = 0;
+    }
+    else if (roll < 62508) {
+        price = basePrice * 0.925;
+    }
+    else if (roll < 64518) {
+        price = basePrice * 0.77;
+    }
+    else if (roll < 65437) {
+        price = basePrice * 0.595;
+    }
+    else if (roll < 65523) {
+        price = basePrice * 0.41;
+    }
+    else {
+        price = basePrice * 0.285;
+    }
+    return antelope.UInt64.from(price);
+}
+
+const ERROR_SYSTEM_NOT_INITIALIZED = 'System not initialized';
+const GOOD_DOES_NOT_EXIST = 'Good does not exist';
+const GOOD_NOT_AVAILABLE_AT_LOCATION = 'Good not available at location';
+const PLAYER_NOT_FOUND = 'Player not found';
+const SHIP_NOT_FOUND = 'Ship not found';
+const SHIP_CANNOT_BUY_TRAVELING = 'Ship cannot buy while traveling';
+const INSUFFICIENT_BALANCE = 'Insufficient balance';
+const INSUFFICIENT_GOOD_QUANTITY = 'Insufficient good quantity';
+const REQUIRES_MORE_THAN_ONE = 'Requires more than one';
+
 class Shipload {
+    constructor(chain, { client, serverContract }) {
+        this.client = client || new antelope.APIClient({ url: chain.url });
+        this.server = serverContract
+            ? serverContract
+            : new Contract({ client: this.client });
+    }
+    static load(chain, shiploadOptions) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            let server$1 = new Contract({
+                client: new antelope.APIClient({ url: chain.url }),
+            });
+            if (shiploadOptions.contractName) {
+                const client = shiploadOptions.client || new antelope.APIClient({ url: chain.url });
+                const contractKit = new ContractKit__default["default"]({ client });
+                server$1 = yield contractKit.load(shiploadOptions.contractName);
+            }
+            return new Shipload(chain, Object.assign(Object.assign({}, shiploadOptions), { serverContract: server$1 }));
+        });
+    }
+    getState() {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const state = yield this.server.table('state').get();
+            if (!state) {
+                throw new Error(ERROR_SYSTEM_NOT_INITIALIZED);
+            }
+            return state;
+        });
+    }
+    marketprice(location, good_id) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const { seed, epochseed } = yield this.getState();
+            return marketprice(location, good_id, seed, epochseed);
+        });
+    }
+    marketprices(location) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const { seed, epochseed } = yield this.getState();
+            return marketprices(location, seed, epochseed);
+        });
+    }
 }
 
+exports.ERROR_SYSTEM_NOT_INITIALIZED = ERROR_SYSTEM_NOT_INITIALIZED;
+exports.GOOD_DOES_NOT_EXIST = GOOD_DOES_NOT_EXIST;
+exports.GOOD_NOT_AVAILABLE_AT_LOCATION = GOOD_NOT_AVAILABLE_AT_LOCATION;
+exports.INSUFFICIENT_BALANCE = INSUFFICIENT_BALANCE;
+exports.INSUFFICIENT_GOOD_QUANTITY = INSUFFICIENT_GOOD_QUANTITY;
+exports.PLAYER_NOT_FOUND = PLAYER_NOT_FOUND;
 exports.PlatformContract = platform;
+exports.REQUIRES_MORE_THAN_ONE = REQUIRES_MORE_THAN_ONE;
+exports.SHIP_CANNOT_BUY_TRAVELING = SHIP_CANNOT_BUY_TRAVELING;
+exports.SHIP_NOT_FOUND = SHIP_NOT_FOUND;
 exports.ServerContract = server;
 exports["default"] = Shipload;
-exports.distance = distance;
+exports.distanceBetweenPoints = distanceBetweenPoints;
+exports.distanceTraveled = distanceTraveled;
+exports.findNearbyPlanets = findNearbyPlanets;
+exports.getGood = getGood;
+exports.goods = goods;
 exports.hasPlanet = hasPlanet;
 exports.hash = hash;
+exports.hashBytes = hashBytes;
 exports.lerp = lerp;
+exports.marketprice = marketprice;
+exports.marketprices = marketprices;
+exports.priceFromRoll = priceFromRoll;
 exports.rotation = rotation;
 //# sourceMappingURL=shipload.js.map