@shipload/sdk 1.0.0-next.64 → 1.0.0-next.66

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.64",
+    "version": "1.0.0-next.66",
     "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
     "repository": {
         "type": "git",

package/src/capabilities/crafting.test.ts

@@ -1,11 +1,25 @@
+import {UInt16, UInt32} from '@wharfkit/antelope'
 import {describe, expect, test} from 'bun:test'
+import type {ServerContract} from '../contracts'
+import {computeInputMass} from '../derivation/crafting'
+import {getRecipe} from '../data/recipes-runtime'
 import {
     calc_craft_energy,
     calcClusterIntake,
     calcClustercraftDuration,
+    craftEnergyCost,
     INTAKE_RATE,
 } from './crafting'
 
+function crafterLane(drain: number): ServerContract.Types.crafter_lane {
+    return {
+        slot_index: UInt16.from(0),
+        speed: UInt16.from(1000),
+        drain: UInt32.from(drain),
+        output_pct: UInt16.from(100),
+    } as unknown as ServerContract.Types.crafter_lane
+}
+
 test('calc_craft_energy does not clamp above the old uint16 ceiling', () => {
     const energy = calc_craft_energy(30, 400_000_000)
     expect(Number(energy)).toBeGreaterThan(65535)
@@ -13,10 +27,10 @@ test('calc_craft_energy does not clamp above the old uint16 ceiling', () => {
 
 describe('calcClusterIntake', () => {
     test('is floor(sourcedMass / INTAKE_RATE)', () => {
-        expect(INTAKE_RATE).toBe(36000)
-        expect(calcClusterIntake(36000)).toBe(1)
-        expect(calcClusterIntake(35999)).toBe(0)
-        expect(calcClusterIntake(19_680_000)).toBe(546)
+        expect(INTAKE_RATE).toBe(360)
+        expect(calcClusterIntake(360)).toBe(1)
+        expect(calcClusterIntake(359)).toBe(0)
+        expect(calcClusterIntake(196_800)).toBe(546)
     })
 
     test('zero sourced mass (all own-hold) charges no intake', () => {
@@ -28,8 +42,39 @@ describe('calcClustercraftDuration', () => {
     test('adds intake to the base craft duration', () => {
         // calc_craft_duration = floor(inputMass/speed) + 1
         const speed = 1000
-        const inputMass = 100_000 // base craft = 100 + 1 = 101s
-        const sourcedMass = 72_000 // intake = 2s
+        const inputMass = 1000 // base craft = 100 + 1 = 101s
+        const sourcedMass = 720 // intake = 2s
         expect(calcClustercraftDuration(speed, inputMass, sourcedMass).toNumber()).toBe(103)
     })
 })
+
+describe('craftEnergyCost', () => {
+    const OUTPUT_ITEM_ID = 10001
+    const DRAIN = 100_000
+
+    test('matches calc_craft_energy against the recipe input mass times units', () => {
+        const recipe = getRecipe(OUTPUT_ITEM_ID)!
+        const lane = crafterLane(DRAIN)
+        const units = 5
+
+        const cost = craftEnergyCost(lane, recipe, units)
+
+        const expected = Number(calc_craft_energy(DRAIN, computeInputMass(OUTPUT_ITEM_ID) * units))
+        expect(cost).toBe(expected)
+    })
+
+    test('is 0 for non-positive units', () => {
+        const recipe = getRecipe(OUTPUT_ITEM_ID)!
+        const lane = crafterLane(DRAIN)
+        expect(craftEnergyCost(lane, recipe, 0)).toBe(0)
+        expect(craftEnergyCost(lane, recipe, -1)).toBe(0)
+    })
+
+    test('scales with unit count', () => {
+        const recipe = getRecipe(OUTPUT_ITEM_ID)!
+        const lane = crafterLane(DRAIN)
+        const one = craftEnergyCost(lane, recipe, 1)
+        const ten = craftEnergyCost(lane, recipe, 10)
+        expect(ten).toBeGreaterThan(one)
+    })
+})

package/src/capabilities/crafting.ts

@@ -1,6 +1,9 @@
 import {UInt32} from '@wharfkit/antelope'
-import {CRAFT_ENERGY_DIVISOR} from '../types'
+import {CRAFT_ENERGY_DIVISOR, MASS_STAT_SCALE} from '../types'
 import type {CrafterStats, EntityCapabilities} from '../types/capabilities'
+import type {ServerContract} from '../contracts'
+import {getItem} from '../data/catalog'
+import type {Recipe} from '../data/recipes-runtime'
 
 export interface CrafterCapability {
     crafter: CrafterStats
@@ -11,12 +14,11 @@ export function capsHasCrafter(caps: EntityCapabilities): boolean {
 }
 
 export function calc_craft_duration(speed: number, totalInputMass: number): UInt32 {
-    const duration = Math.floor(totalInputMass / speed)
+    const duration = Math.floor((totalInputMass * MASS_STAT_SCALE) / speed)
     return UInt32.from(duration + 1)
 }
 
-// Mirrors contract config.hpp INTAKE_RATE (provisional; a numbers pass will retune it).
-export const INTAKE_RATE = 36000
+export const INTAKE_RATE = 360
 
 // Mirrors calc_cluster_intake: whole seconds of intake for cargo sourced off other cluster members.
 export function calcClusterIntake(sourcedMass: number): number {
@@ -39,6 +41,19 @@ export function calc_craft_energy(drain: number, totalInputMass: number): UInt32
     return UInt32.from(Math.min(Math.max(raw + 1, 1000), 4294967295))
 }
 
+export function craftEnergyCost(
+    lane: ServerContract.Types.crafter_lane,
+    recipe: Recipe,
+    units: number
+): number {
+    if (units <= 0) return 0
+    const inputMassPerUnit = recipe.inputs.reduce(
+        (sum, input) => sum + getItem(input.itemId).mass * input.quantity,
+        0
+    )
+    return Number(calc_craft_energy(lane.drain.toNumber(), inputMassPerUnit * units))
+}
+
 // Craft-identical today; forked so build balance can diverge from craft without touching it.
 export function calc_build_duration(speed: number, totalInputMass: number): UInt32 {
     return calc_craft_duration(speed, totalInputMass)

package/src/capabilities/gathering.ts

@@ -1,6 +1,6 @@
 import {UInt32} from '@wharfkit/antelope'
 import type {GathererStats} from '../types/capabilities'
-import {PRECISION} from '../types'
+import {MASS_STAT_SCALE, PRECISION} from '../types'
 
 const GATHER_TIME_SCALE = 100
 export const GATHER_MASS_DIVISOR = 228
@@ -17,7 +17,7 @@ function gather_duration_raw(
 
     if (yieldValue === 0 || richness === 0) return 0
 
-    const massFactor = itemMass / GATHER_MASS_DIVISOR
+    const massFactor = (itemMass * MASS_STAT_SCALE) / GATHER_MASS_DIVISOR
     const depthPenalty = 1 + stratum / DEPTH_PENALTY_DIVISOR
     const richnessMul = richness / 1000
     return (quantity * massFactor * GATHER_TIME_SCALE * depthPenalty) / (yieldValue * richnessMul)

package/src/capabilities/storage.test.ts

@@ -0,0 +1,26 @@
+import {expect, test} from 'bun:test'
+import {UInt32, UInt64} from '@wharfkit/antelope'
+import {hasSpaceForMass, isFull, isFullFromMass} from './storage'
+
+test('hasSpaceForMass accepts raw numbers', () => {
+    expect(hasSpaceForMass(100, 40, 50)).toBe(true)
+    expect(hasSpaceForMass(100, 60, 50)).toBe(false)
+    expect(hasSpaceForMass(100, 50, 50)).toBe(true)
+})
+
+test('hasSpaceForMass accepts wrapped values', () => {
+    expect(hasSpaceForMass(UInt64.from(100), UInt64.from(40), UInt64.from(50))).toBe(true)
+    expect(hasSpaceForMass(UInt64.from(100), UInt32.from(60), UInt32.from(50))).toBe(false)
+})
+
+test('isFullFromMass accepts raw numbers', () => {
+    expect(isFullFromMass(100, 100)).toBe(true)
+    expect(isFullFromMass(100, 101)).toBe(true)
+    expect(isFullFromMass(100, 99)).toBe(false)
+})
+
+test('isFull accepts raw numbers on the entity', () => {
+    expect(isFull({capacity: 100, cargomass: 100})).toBe(true)
+    expect(isFull({capacity: 100, cargomass: 99})).toBe(false)
+    expect(isFull({capacity: UInt32.from(100), cargomass: UInt32.from(120)})).toBe(true)
+})

package/src/capabilities/storage.ts

@@ -1,4 +1,4 @@
-import {UInt16, UInt32, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {UInt16, UInt32, UInt64, type UInt32Type, type UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import type {StorageCapability} from '../types/capabilities'
 import {getItem} from '../data/catalog'
@@ -9,11 +9,11 @@ export interface HasCargo {
 }
 
 export interface HasCapacity {
-    capacity: UInt32
+    capacity: UInt32Type
 }
 
 export interface HasCargomass {
-    cargomass: UInt32
+    cargomass: UInt32Type
 }
 
 interface MassInput {
@@ -75,15 +75,15 @@ export function hasSpaceForMass(
     currentMass: UInt64Type,
     additionalMass: UInt64Type
 ): boolean {
-    return UInt64.from(currentMass).adding(additionalMass).lte(capacity)
+    return UInt64.from(currentMass).adding(additionalMass).lte(UInt64.from(capacity))
 }
 
 export function isFull(entity: HasCapacity & HasCargomass): boolean {
-    return UInt64.from(entity.cargomass).gte(entity.capacity)
+    return UInt64.from(entity.cargomass).gte(UInt64.from(entity.capacity))
 }
 
 export function isFullFromMass(capacity: UInt64Type, cargoMass: UInt64Type): boolean {
-    return UInt64.from(cargoMass).gte(capacity)
+    return UInt64.from(cargoMass).gte(UInt64.from(capacity))
 }
 
 export interface CargoStack {

package/src/contracts/fund.ts

@@ -10,17 +10,24 @@ import {ABI, Asset, Blob, Name, Struct, UInt16, UInt32, UInt64} from '@wharfkit/
 import type {ActionOptions, ContractArgs, PartialBy, Table} from '@wharfkit/contract'
 import {Contract as BaseContract} from '@wharfkit/contract'
 export const abiBlob = Blob.from(
-    'DmVvc2lvOjphYmkvMS4yAA4LYWNjcnVlZF9yb3cAAgdhY2NvdW50BG5hbWUHYmFsYW5jZQVhc3NldAliZW5lZl9yb3cAAgdhY2NvdW50BG5hbWUDYnBzBnVpbnQxNgtiZW5lZmljaWFyeQACB2FjY291bnQEbmFtZQNicHMGdWludDE2BWNsYWltAAETYmVuZWZpY2lhcnlfYWNjb3VudARuYW1lCmN1cnNvcl9yb3cAAQ1uZXh0X2Fzc2V0X2lkBnVpbnQ2NAhsb3RzX3JvdwADCGFzc2V0X2lkBnVpbnQ2NAVncmFkZQRuYW1lCmF1Y3Rpb25faWQGdWludDY0CXJlc2N1ZW5mdAADCWFzc2V0X2lkcwh1aW50NjRbXQJ0bwRuYW1lBG1lbW8Gc3RyaW5nCHNldGJlbmVmAAEIcmVnaXN0cnkNYmVuZWZpY2lhcnlbXQlzZXRtYXJrZXQAAgZtYXJrZXQEbmFtZRFtYWtlcl9tYXJrZXRwbGFjZQRuYW1lCHNldHRlcm1zAAMFZ3JhZGUEbmFtZQxzdGFydGluZ19iaWQFYXNzZXQIZHVyYXRpb24GdWludDMyDHNldHRpbmdzX3JvdwAEBm1hcmtldARuYW1lDnRva2VuX2NvbnRyYWN0BG5hbWUMdG9rZW5fc3ltYm9sBnN5bWJvbBFtYWtlcl9tYXJrZXRwbGFjZQRuYW1lCHNldHRva2VuAAIOdG9rZW5fY29udHJhY3QEbmFtZQx0b2tlbl9zeW1ib2wGc3ltYm9sBHRlbmQAAQhtYXhfbG90cwZ1aW50MzIJdGVybXNfcm93AAMFZ3JhZGUEbmFtZQxzdGFydGluZ19iaWQFYXNzZXQIZHVyYXRpb24GdWludDMyBwAAAAAA6UxEBWNsYWltAAAAyGsqjbC6CXJlc2N1ZW5mdAAAAABLTXWywghzZXRiZW5lZgAAAMgKXiOzwglzZXRtYXJrZXQAAAAAWF6Vs8IIc2V0dGVybXMAAAAAU0Gas8IIc2V0dG9rZW4AAAAAAACQpsoEdGVuZAAGAAAAICl9ETIDaTY0AAALYWNjcnVlZF9yb3cAAAAA4KWmOgNpNjQAAAliZW5lZl9yb3cAAAAAXIqvRgNpNjQAAApjdXJzb3Jfcm93AAAAAACAM40DaTY0AAAIbG90c19yb3cAAACYTZezwgNpNjQAAAxzZXR0aW5nc19yb3cAAAAAACyvygNpNjQAAAl0ZXJtc19yb3cAAAAAAA=='
+    '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'
 )
 export const abi = ABI.from(abiBlob)
 export namespace Types {
     @Struct.type('accrued_row')
     export class accrued_row extends Struct {
         @Struct.field(Name)
-        declare account: Name
+        declare token_contract: Name
         @Struct.field(Asset)
         declare balance: Asset
     }
+    @Struct.type('addtoken')
+    export class addtoken extends Struct {
+        @Struct.field(Name)
+        declare token_contract: Name
+        @Struct.field(Asset.Symbol)
+        declare token_symbol: Asset.Symbol
+    }
     @Struct.type('benef_row')
     export class benef_row extends Struct {
         @Struct.field(Name)
@@ -40,11 +47,54 @@ export namespace Types {
         @Struct.field(Name)
         declare beneficiary_account: Name
     }
+    @Struct.type('collect')
+    export class collect extends Struct {}
+    @Struct.type('collectfees')
+    export class collectfees extends Struct {}
     @Struct.type('cursor_row')
     export class cursor_row extends Struct {
         @Struct.field(UInt64)
         declare next_asset_id: UInt64
     }
+    @Struct.type('deltoken')
+    export class deltoken extends Struct {
+        @Struct.field(Name)
+        declare token_contract: Name
+    }
+    @Struct.type('getlots')
+    export class getlots extends Struct {
+        @Struct.field(UInt64)
+        declare lower_bound: UInt64
+        @Struct.field(UInt32)
+        declare max_lots: UInt32
+    }
+    @Struct.type('gettendable')
+    export class gettendable extends Struct {
+        @Struct.field(UInt32)
+        declare max_lots: UInt32
+    }
+    @Struct.type('lot_info')
+    export class lot_info extends Struct {
+        @Struct.field(UInt64)
+        declare asset_id: UInt64
+        @Struct.field(Name)
+        declare grade: Name
+        @Struct.field(UInt64)
+        declare auction_id: UInt64
+        @Struct.field(UInt16)
+        declare item_id: UInt16
+        @Struct.field(UInt32)
+        declare quantity: UInt32
+        @Struct.field(UInt64)
+        declare stats: UInt64
+    }
+    @Struct.type('lots_result')
+    export class lots_result extends Struct {
+        @Struct.field(lot_info, {array: true})
+        declare lots: lot_info[]
+        @Struct.field(UInt64)
+        declare next: UInt64
+    }
     @Struct.type('lots_row')
     export class lots_row extends Struct {
         @Struct.field(UInt64)
@@ -102,11 +152,16 @@ export namespace Types {
         @Struct.field(Asset.Symbol)
         declare token_symbol: Asset.Symbol
     }
-    @Struct.type('tend')
-    export class tend extends Struct {
+    @Struct.type('sweep')
+    export class sweep extends Struct {
         @Struct.field(UInt32)
         declare max_lots: UInt32
     }
+    @Struct.type('tend')
+    export class tend extends Struct {
+        @Struct.field(UInt64, {array: true})
+        declare asset_ids: UInt64[]
+    }
     @Struct.type('terms_row')
     export class terms_row extends Struct {
         @Struct.field(Name)
@@ -116,6 +171,15 @@ export namespace Types {
         @Struct.field(UInt32)
         declare duration: UInt32
     }
+    @Struct.type('token_row')
+    export class token_row extends Struct {
+        @Struct.field(Name)
+        declare token_contract: Name
+        @Struct.field(Asset.Symbol)
+        declare token_symbol: Asset.Symbol
+    }
+    @Struct.type('wipe')
+    export class wipe extends Struct {}
 }
 export const TableMap = {
     accrued: Types.accrued_row,
@@ -124,6 +188,7 @@ export const TableMap = {
     lots: Types.lots_row,
     settings: Types.settings_row,
     terms: Types.terms_row,
+    tokens: Types.token_row,
 }
 export interface TableTypes {
     accrued: Types.accrued_row
@@ -132,6 +197,7 @@ export interface TableTypes {
     lots: Types.lots_row
     settings: Types.settings_row
     terms: Types.terms_row
+    tokens: Types.token_row
 }
 export type RowType<T> = T extends keyof TableTypes ? TableTypes[T] : any
 export type TableNames = keyof TableTypes
@@ -142,9 +208,25 @@ export namespace ActionParams {
             bps: UInt16Type
         }
     }
+    export interface addtoken {
+        token_contract: NameType
+        token_symbol: Asset.SymbolType
+    }
     export interface claim {
         beneficiary_account: NameType
     }
+    export interface collect {}
+    export interface collectfees {}
+    export interface deltoken {
+        token_contract: NameType
+    }
+    export interface getlots {
+        lower_bound: UInt64Type
+        max_lots: UInt32Type
+    }
+    export interface gettendable {
+        max_lots: UInt32Type
+    }
     export interface rescuenft {
         asset_ids: UInt64Type[]
         to: NameType
@@ -166,20 +248,37 @@ export namespace ActionParams {
         token_contract: NameType
         token_symbol: Asset.SymbolType
     }
-    export interface tend {
+    export interface sweep {
         max_lots: UInt32Type
     }
+    export interface tend {
+        asset_ids: UInt64Type[]
+    }
+    export interface wipe {}
 }
 export interface ActionNameParams {
+    addtoken: ActionParams.addtoken
     claim: ActionParams.claim
+    collect: ActionParams.collect
+    collectfees: ActionParams.collectfees
+    deltoken: ActionParams.deltoken
+    getlots: ActionParams.getlots
+    gettendable: ActionParams.gettendable
     rescuenft: ActionParams.rescuenft
     setbenef: ActionParams.setbenef
     setmarket: ActionParams.setmarket
     setterms: ActionParams.setterms
     settoken: ActionParams.settoken
+    sweep: ActionParams.sweep
     tend: ActionParams.tend
+    wipe: ActionParams.wipe
 }
 export type ActionNames = keyof ActionNameParams
+export interface ActionReturnValues {
+    getlots: Types.lots_result
+    gettendable: UInt64[]
+}
+export type ActionReturnNames = keyof ActionReturnValues
 export class Contract extends BaseContract {
     constructor(args: PartialBy<ContractArgs, 'abi' | 'account'>) {
         super({
@@ -195,6 +294,12 @@ export class Contract extends BaseContract {
     ): Action {
         return super.action(name, data, options)
     }
+    readonly<T extends ActionReturnNames>(
+        name: T,
+        data?: ActionNameParams[T]
+    ): ActionReturnValues[T] {
+        return super.readonly(name, data) as unknown as ActionReturnValues[T]
+    }
     table<T extends TableNames>(name: T, scope?: NameType): Table<RowType<T>> {
         return super.table(name, scope, TableMap[name])
     }

package/src/contracts/platform.ts

@@ -28,7 +28,7 @@ import {
 import type {ActionOptions, ContractArgs, PartialBy, Table} from '@wharfkit/contract'
 import {Contract as BaseContract} from '@wharfkit/contract'
 export const abiBlob = Blob.from(
-    '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'
+    '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'
 )
 export const abi = ABI.from(abiBlob)
 export namespace Types {
@@ -106,6 +106,11 @@ export namespace Types {
         @Struct.field(cargo_item, {array: true})
         declare bundle: cargo_item[]
     }
+    @Struct.type('dbgrefund')
+    export class dbgrefund extends Struct {
+        @Struct.field(Name, {array: true})
+        declare owners: Name[]
+    }
     @Struct.type('debitdeposit')
     export class debitdeposit extends Struct {
         @Struct.field(Name)
@@ -382,6 +387,9 @@ export namespace ActionParams {
         y: Int64Type
         bundle: Type.cargo_item[]
     }
+    export interface dbgrefund {
+        owners: NameType[]
+    }
     export interface debitdeposit {
         owner: NameType
         token: NameType
@@ -464,6 +472,7 @@ export interface ActionNameParams {
     cleartable: ActionParams.cleartable
     close: ActionParams.close
     contribute: ActionParams.contribute
+    dbgrefund: ActionParams.dbgrefund
     debitdeposit: ActionParams.debitdeposit
     enable: ActionParams.enable
     enablegame: ActionParams.enablegame