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

package/src/influence/valuation.ts

@@ -0,0 +1,154 @@
+import {getItem} from '../data/catalog'
+import {categoryIndex} from './categories'
+import {
+    INFLUENCE_ATOMIC_PER_POINT,
+    INFLUENCE_MASS_KG_MAX,
+    INFLUENCE_NEED_FP_MAX,
+    INFLUENCE_WEIGHT_FP_MAX,
+    MASS_KG_PER_TONNE,
+    NEED_FP_SCALE,
+    WEIGHT_FP_SCALE,
+    W_EFF_ATOMIC_PER_KG,
+} from './constants'
+import {findDecomp} from './decomp'
+import type {DemandView} from './demand'
+import {needForCategory} from './demand'
+import {getStatCount, statsSumSq} from './quality'
+
+const UINT64_MAX = (1n << 64n) - 1n
+
+export interface InfluencePricing {
+    d1: number
+    weight(category: number, tier: number): bigint
+}
+
+export interface ValuedItem {
+    itemId: number
+    quantity: number
+    stats: bigint
+}
+
+export function weightedQualityAtomic(
+    weightedKgFp: bigint,
+    sumSq: number,
+    nStats: number,
+    d1: number,
+    needFp: bigint
+): bigint {
+    if (nStats <= 0 || d1 <= 0) throw new Error('influence: invalid quality divisor')
+    const num = weightedKgFp * BigInt(sumSq) * needFp
+    const den =
+        (BigInt(MASS_KG_PER_TONNE) *
+            BigInt(WEIGHT_FP_SCALE) *
+            BigInt(nStats) *
+            BigInt(d1) *
+            BigInt(NEED_FP_SCALE)) /
+        BigInt(INFLUENCE_ATOMIC_PER_POINT)
+    return num / den
+}
+
+export function resourceValueAtomic(
+    massKg: bigint,
+    weightFp: bigint,
+    sumSq: number,
+    nStats: number,
+    d1: number,
+    needFp: bigint
+): bigint {
+    if (massKg > INFLUENCE_MASS_KG_MAX) throw new Error('influence: mass out of range')
+    if (weightFp > INFLUENCE_WEIGHT_FP_MAX) throw new Error('influence: weight out of range')
+    if (needFp > INFLUENCE_NEED_FP_MAX) throw new Error('influence: need out of range')
+    return weightedQualityAtomic(massKg * weightFp, sumSq, nStats, d1, needFp)
+}
+
+export function componentBaseAtomic(
+    weightedRawKgFp: bigint,
+    sumSq: number,
+    nStats: number,
+    d1: number
+): bigint {
+    return weightedQualityAtomic(weightedRawKgFp, sumSq, nStats, d1, BigInt(NEED_FP_SCALE))
+}
+
+export function componentEffortAtomic(processedKgPerUnit: number, quantity: number): bigint {
+    const processed = BigInt(processedKgPerUnit) * BigInt(quantity)
+    if (processed > INFLUENCE_MASS_KG_MAX) {
+        throw new Error('influence: processed mass out of range')
+    }
+    return processed * W_EFF_ATOMIC_PER_KG
+}
+
+export function valueCargoItem(
+    item: ValuedItem,
+    demand: DemandView,
+    pricing: InfluencePricing
+): bigint {
+    const def = getItem(item.itemId)
+    if (def.type !== 'resource' && def.type !== 'component') {
+        throw new Error('item class cannot be valued')
+    }
+
+    const nStats = getStatCount(item.itemId)
+    const sumSq = statsSumSq(item.stats, nStats)
+
+    if (def.type === 'resource') {
+        if (def.category === undefined) throw new Error('resource has no category')
+        const category = categoryIndex(def.category)
+        const weightFp = pricing.weight(category, def.tier)
+        const needFp = needForCategory(demand, category)
+        const perUnit = resourceValueAtomic(
+            BigInt(def.mass),
+            weightFp,
+            sumSq,
+            nStats,
+            pricing.d1,
+            needFp
+        )
+        const total = perUnit * BigInt(item.quantity)
+        if (total > UINT64_MAX) throw new Error('influence: resource value overflow')
+        return total
+    }
+
+    const entry = findDecomp(item.itemId)
+    if (!entry) throw new Error('item has no decomposition')
+
+    let weighted = 0n
+    for (const bucket of entry.buckets) {
+        weighted += BigInt(bucket.rawKg) * pricing.weight(bucket.category, bucket.tier)
+    }
+
+    const perUnit = componentBaseAtomic(weighted, sumSq, nStats, pricing.d1)
+    const total = perUnit * BigInt(item.quantity)
+    if (total > UINT64_MAX) throw new Error('influence: component value overflow')
+
+    const withEffort = total + componentEffortAtomic(entry.processedKg, item.quantity)
+    if (withEffort > UINT64_MAX) throw new Error('influence: component value overflow')
+    return withEffort
+}
+
+export function valueContribution(
+    bundle: ValuedItem[],
+    demand: DemandView,
+    pricing: InfluencePricing
+): bigint {
+    let total = 0n
+    for (const item of bundle) total += valueCargoItem(item, demand, pricing)
+    if (total > UINT64_MAX) throw new Error('influence: contribution value overflow')
+    return total
+}
+
+export function pricingFromWeights(
+    d1: number,
+    weights: Iterable<{category: number; tier: number; weightFp: bigint | number | string}>
+): InfluencePricing {
+    const table = new Map<number, bigint>()
+    for (const row of weights) {
+        table.set(row.category * 16 + row.tier, BigInt(row.weightFp.toString()))
+    }
+    return {
+        d1,
+        weight(category: number, tier: number): bigint {
+            return table.get(category * 16 + tier) ?? 0n
+        },
+    }
+}

package/src/managers/actions.ts

@@ -1,8 +1,11 @@
 import {
     Action,
+    Asset,
+    type AssetType,
     Bytes,
     Checksum256,
     type Checksum256Type,
+    ExtendedAsset,
     Int64,
     type Int64Type,
     Name,
@@ -18,7 +21,7 @@ import {
 } from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {Coordinates, PRECISION, type ClusterSlotType, type CoordinatesType} from '../types'
-import {ServerContract} from '../contracts'
+import {ServerContract, TokenContract} from '../contracts'
 import {ATOMICASSETS_ABI, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 import {getItem} from '../data/catalog'
 
@@ -164,6 +167,8 @@ export type EntityRefInput = {
 export type WaypointInput = {x: Int64Type; y: Int64Type}
 
 export class ActionsManager extends BaseManager {
+    private tokenContracts = new Map<string, TokenContract.Contract>()
+
     travel(shipId: UInt64Type, destination: CoordinatesType, recharge = true): Action {
         const x = Int64.from(destination.x)
         const y = Int64.from(destination.y)
@@ -315,6 +320,30 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    depotstore(
+        shipId: UInt64Type,
+        depotId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.server.action('depotstore', {
+            ship_id: UInt64.from(shipId),
+            depot_id: UInt64.from(depotId),
+            items,
+        })
+    }
+
+    depottake(
+        shipId: UInt64Type,
+        depotId: UInt64Type,
+        items: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.server.action('depottake', {
+            ship_id: UInt64.from(shipId),
+            depot_id: UInt64.from(depotId),
+            items,
+        })
+    }
+
     shuttle(
         carrierId: UInt64Type,
         fromId: UInt64Type,
@@ -511,6 +540,35 @@ export class ActionsManager extends BaseManager {
         return this.server.action('canceljob', params)
     }
 
+    upgradejob(
+        targetId: UInt64Type,
+        dockId: UInt64Type,
+        targetItemId: UInt16Type,
+        inputs: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        const params: ServerContract.ActionParams.upgradejob = {
+            target_id: UInt64.from(targetId),
+            dock_id: UInt64.from(dockId),
+            target_item_id: UInt16.from(targetItemId),
+            inputs,
+        }
+        return this.server.action('upgradejob', params)
+    }
+
+    claimupgrade(jobId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.claimupgrade = {
+            job_id: UInt64.from(jobId),
+        }
+        return this.server.action('claimupgrade', params)
+    }
+
+    cancelupgrade(jobId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.cancelupgrade = {
+            job_id: UInt64.from(jobId),
+        }
+        return this.server.action('cancelupgrade', params)
+    }
+
     setsocket(workshopId: UInt64Type, slot: UInt8Type, open: boolean): Action {
         const params: ServerContract.ActionParams.setsocket = {
             workshop_id: UInt64.from(workshopId),
@@ -599,6 +657,12 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    abandonplot(plotId: UInt64Type): Action {
+        return this.server.action('abandonplot', {
+            plot_id: UInt64.from(plotId),
+        })
+    }
+
     addmodule(
         entityId: UInt64Type,
         moduleIndex: number,
@@ -637,6 +701,88 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    open(owner: NameType, tokenContract: NameType, tokenSymbol: Asset.SymbolType): Action {
+        return this.platform.action('open', {
+            owner: Name.from(owner),
+            token_contract: Name.from(tokenContract),
+            token_symbol: Asset.Symbol.from(tokenSymbol),
+        })
+    }
+
+    close(owner: NameType, tokenContract: NameType, tokenSymbol: Asset.SymbolType): Action {
+        return this.platform.action('close', {
+            owner: Name.from(owner),
+            token_contract: Name.from(tokenContract),
+            token_symbol: Asset.Symbol.from(tokenSymbol),
+        })
+    }
+
+    withdraw(
+        owner: NameType,
+        quantity: AssetType,
+        tokenContract: NameType,
+        memo = 'withdraw'
+    ): Action {
+        return this.platform.action('withdraw', {
+            owner: Name.from(owner),
+            quantity: ExtendedAsset.from({
+                quantity: Asset.from(quantity),
+                contract: Name.from(tokenContract),
+            }),
+            memo,
+        })
+    }
+
+    tokenContract(account: NameType): TokenContract.Contract {
+        const name = Name.from(account)
+        const key = String(name)
+        let contract = this.tokenContracts.get(key)
+        if (!contract) {
+            contract = new TokenContract.Contract({client: this.client, account: name})
+            this.tokenContracts.set(key, contract)
+        }
+        return contract
+    }
+
+    tokenTransfer(
+        from: NameType,
+        to: NameType,
+        quantity: AssetType,
+        tokenContract: NameType,
+        memo = ''
+    ): Action {
+        return this.tokenContract(tokenContract).action('transfer', {
+            from: Name.from(from),
+            to: Name.from(to),
+            quantity: Asset.from(quantity),
+            memo,
+        })
+    }
+
+    // `open` is an idempotent no-op; omitting it is what produces the "call open first" abort.
+    deposit(
+        owner: NameType,
+        quantity: AssetType,
+        tokenContract: NameType,
+        opts: {memo?: string; open?: boolean} = {}
+    ): Action[] {
+        const amount = Asset.from(quantity)
+        const actions: Action[] = []
+        if (opts.open !== false) {
+            actions.push(this.open(owner, tokenContract, amount.symbol))
+        }
+        actions.push(
+            this.tokenTransfer(
+                owner,
+                this.platform.account,
+                amount,
+                tokenContract,
+                opts.memo ?? 'deposit'
+            )
+        )
+        return actions
+    }
+
     async wrap(
         owner: NameType,
         entityId: UInt64Type,
@@ -655,8 +801,8 @@ export class ActionsManager extends BaseManager {
                 quantity: UInt64.from(quantity),
             }),
         ]
-        const claimRam =
-            opts.claimRam ?? (this.atomicAssetsAccount ?? 'atomicassets') !== 'atomicassets'
+        // setlastpayer is what fires logrampayer and clears the wrap gate; skipping it strands it.
+        const claimRam = opts.claimRam ?? true
         if (claimRam) {
             actions.push(this.setLastPayer(owner, SHIPLOAD_COLLECTION))
         }
@@ -690,8 +836,8 @@ export class ActionsManager extends BaseManager {
                 nexus_id: UInt64.from(nexusId),
             }),
         ]
-        const claimRam =
-            opts.claimRam ?? (this.atomicAssetsAccount ?? 'atomicassets') !== 'atomicassets'
+        // setlastpayer is what fires logrampayer and clears the wrap gate; skipping it strands it.
+        const claimRam = opts.claimRam ?? true
         if (claimRam) {
             actions.push(this.setLastPayer(owner, SHIPLOAD_COLLECTION))
         }
@@ -835,4 +981,80 @@ export class ActionsManager extends BaseManager {
             max_rows: UInt64.from(maxRows),
         })
     }
+
+    found(player: NameType, entityId: UInt64Type, location: CoordinatesType): Action {
+        return this.server.action('found', {
+            player: Name.from(player),
+            entity_id: UInt64.from(entityId),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })
+    }
+
+    naturalize(player: NameType, location: CoordinatesType): Action {
+        return this.server.action('naturalize', {
+            player: Name.from(player),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })
+    }
+
+    contribute(
+        player: NameType,
+        entityId: UInt64Type,
+        location: CoordinatesType,
+        bundle: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action {
+        return this.platform.action('contribute', {
+            game: this.server.account,
+            player: Name.from(player),
+            entity_id: UInt64.from(entityId),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+            bundle,
+        })
+    }
+
+    // addcontrib asserts the citizenship rows exist, so naturalize must precede contribute.
+    firstContribution(
+        player: NameType,
+        entityId: UInt64Type,
+        location: CoordinatesType,
+        bundle: ServerContract.ActionParams.Type.cargo_item[]
+    ): Action[] {
+        return [
+            this.naturalize(player, location),
+            this.contribute(player, entityId, location, bundle),
+        ]
+    }
+
+    mintready(maxMints?: UInt32Type): Action {
+        const params: {max_mints?: UInt32} = {}
+        if (maxMints !== undefined) {
+            params.max_mints = UInt32.from(maxMints)
+        }
+        return this.server.action('mintready', params)
+    }
+
+    charterready(location: CoordinatesType): Action {
+        return this.server.action('charterready', {
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })
+    }
+
+    votecharter(player: NameType, location: CoordinatesType, nodeId: UInt32Type): Action {
+        return this.server.action('votecharter', {
+            player: Name.from(player),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+            node_id: UInt32.from(nodeId),
+        })
+    }
+
+    voteready(maxBallots: UInt32Type = UInt32.from(0)): Action {
+        return this.server.action('voteready', {
+            max_ballots: UInt32.from(maxBallots),
+        })
+    }
 }

package/src/managers/balances.test.ts

@@ -0,0 +1,161 @@
+import {describe, expect, test} from 'bun:test'
+import {Asset, type Name} from '@wharfkit/antelope'
+import {BalancesManager} from './balances'
+import type {GameContext} from './context'
+import {PlatformContract} from '../contracts'
+
+interface StubOptions {
+    depositConfig?: {token_contract: string; token_symbol: string} | null
+    balances?: {token_contract: string; balance: string}[] | null
+    wallet?: string[]
+}
+
+function stubContext(options: StubOptions = {}) {
+    const counts = {depositcfg: 0, balance: 0, currency: 0}
+    const rows = (options.balances ?? []).map((row) => PlatformContract.Types.balance_row.from(row))
+    const platform = {
+        table(name: string) {
+            if (name === 'depositcfg') {
+                return {
+                    get: async () => {
+                        counts.depositcfg++
+                        return options.depositConfig
+                            ? PlatformContract.Types.depositcfg_row.from(options.depositConfig)
+                            : undefined
+                    },
+                }
+            }
+            return {
+                get: async (key: Name) => {
+                    counts.balance++
+                    return rows.find((row) => row.token_contract.equals(key))
+                },
+                all: async () => {
+                    counts.balance++
+                    return rows
+                },
+            }
+        },
+    }
+    const client = {
+        v1: {
+            chain: {
+                get_currency_balance: async () => {
+                    counts.currency++
+                    return (options.wallet ?? []).map((value) => Asset.from(value))
+                },
+            },
+        },
+    }
+    const context = {platform, client} as unknown as GameContext
+    return {manager: new BalancesManager(context), counts}
+}
+
+const SCRAP = {token_contract: 'scrap.gm', token_symbol: '0,SCRAP'}
+
+describe('getDepositConfig', () => {
+    test('reads the configured deposit token', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP})
+        const config = await manager.getDepositConfig()
+        expect(String(config?.tokenContract)).toBe('scrap.gm')
+        expect(String(config?.symbol)).toBe('0,SCRAP')
+    })
+
+    test('caches the config across calls', async () => {
+        const {manager, counts} = stubContext({depositConfig: SCRAP})
+        await manager.getDepositConfig()
+        await manager.getDepositConfig()
+        expect(counts.depositcfg).toBe(1)
+        await manager.getDepositConfig(true)
+        expect(counts.depositcfg).toBe(2)
+    })
+
+    test('caches a missing config as null without refetching', async () => {
+        const {manager, counts} = stubContext({depositConfig: null})
+        expect(await manager.getDepositConfig()).toBeNull()
+        expect(await manager.getDepositConfig()).toBeNull()
+        expect(counts.depositcfg).toBe(1)
+    })
+})
+
+describe('getPlatformBalance', () => {
+    test('returns null when the owner has never opened a row', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, balances: []})
+        expect(await manager.getPlatformBalance('alice')).toBeNull()
+    })
+
+    test('returns a zero balance for an opened but empty row', async () => {
+        const {manager} = stubContext({
+            depositConfig: SCRAP,
+            balances: [{token_contract: 'scrap.gm', balance: '0 SCRAP'}],
+        })
+        const balance = await manager.getPlatformBalance('alice')
+        expect(balance).not.toBeNull()
+        expect(String(balance?.balance)).toBe('0 SCRAP')
+        expect(balance?.balance.units.toNumber()).toBe(0)
+        expect(balance?.balance.symbol.precision).toBe(0)
+        expect(String(balance?.owner)).toBe('alice')
+    })
+
+    test('defaults to the deposit token and honours an explicit contract', async () => {
+        const {manager} = stubContext({
+            depositConfig: SCRAP,
+            balances: [
+                {token_contract: 'scrap.gm', balance: '12 SCRAP'},
+                {token_contract: 'eosio.token', balance: '3.0000 EOS'},
+            ],
+        })
+        expect(String((await manager.getPlatformBalance('alice'))?.balance)).toBe('12 SCRAP')
+        expect(String((await manager.getPlatformBalance('alice', 'eosio.token'))?.balance)).toBe(
+            '3.0000 EOS'
+        )
+    })
+
+    test('returns null when no deposit token is configured', async () => {
+        const {manager, counts} = stubContext({depositConfig: null})
+        expect(await manager.getPlatformBalance('alice')).toBeNull()
+        expect(counts.balance).toBe(0)
+    })
+})
+
+describe('getPlatformBalances', () => {
+    test('returns every row the owner holds', async () => {
+        const {manager} = stubContext({
+            depositConfig: SCRAP,
+            balances: [
+                {token_contract: 'scrap.gm', balance: '12 SCRAP'},
+                {token_contract: 'eosio.token', balance: '3.0000 EOS'},
+            ],
+        })
+        const balances = await manager.getPlatformBalances('alice')
+        expect(balances.map((row) => String(row.balance))).toEqual(['12 SCRAP', '3.0000 EOS'])
+        expect(balances.map((row) => String(row.tokenContract))).toEqual([
+            'scrap.gm',
+            'eosio.token',
+        ])
+    })
+
+    test('returns an empty array for an owner with no rows', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, balances: []})
+        expect(await manager.getPlatformBalances('alice')).toEqual([])
+    })
+})
+
+describe('getWalletBalance', () => {
+    test('reads the wallet balance for the deposit token', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, wallet: ['500 SCRAP']})
+        const balance = await manager.getWalletBalance('alice')
+        expect(String(balance?.balance)).toBe('500 SCRAP')
+        expect(String(balance?.tokenContract)).toBe('scrap.gm')
+    })
+
+    test('returns null when the account holds none of the token', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, wallet: []})
+        expect(await manager.getWalletBalance('alice')).toBeNull()
+    })
+
+    test('ignores balances of other symbols on the same contract', async () => {
+        const {manager} = stubContext({depositConfig: SCRAP, wallet: ['1.0000 OTHER']})
+        expect(await manager.getWalletBalance('alice')).toBeNull()
+    })
+})

package/src/managers/balances.ts

@@ -0,0 +1,93 @@
+import {Asset, Name, type NameType} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {PlatformContract} from '../contracts'
+
+export interface DepositConfig {
+    tokenContract: Name
+    symbol: Asset.Symbol
+}
+
+export interface PlatformBalance {
+    owner: Name
+    tokenContract: Name
+    balance: Asset
+}
+
+export interface TokenBalance {
+    account: Name
+    tokenContract: Name
+    balance: Asset
+}
+
+export class BalancesManager extends BaseManager {
+    private depositConfig?: DepositConfig | null
+
+    async getDepositConfig(reload = false): Promise<DepositConfig | null> {
+        if (!reload && this.depositConfig !== undefined) {
+            return this.depositConfig
+        }
+        const row = (await this.platform.table('depositcfg').get()) as
+            | PlatformContract.Types.depositcfg_row
+            | undefined
+        this.depositConfig = row
+            ? {tokenContract: row.token_contract, symbol: row.token_symbol}
+            : null
+        return this.depositConfig
+    }
+
+    private async resolveTokenContract(tokenContract?: NameType): Promise<Name | null> {
+        if (tokenContract) return Name.from(tokenContract)
+        const config = await this.getDepositConfig()
+        return config ? config.tokenContract : null
+    }
+
+    async getPlatformBalances(owner: NameType): Promise<PlatformBalance[]> {
+        const account = Name.from(owner)
+        const rows = (await this.platform
+            .table('balance', account)
+            .all()) as PlatformContract.Types.balance_row[]
+        return rows.map((row) => ({
+            owner: account,
+            tokenContract: row.token_contract,
+            balance: row.balance,
+        }))
+    }
+
+    // Null means no balance row at all: deposits abort until `open`. A zero row is a valid state.
+    async getPlatformBalance(
+        owner: NameType,
+        tokenContract?: NameType
+    ): Promise<PlatformBalance | null> {
+        const contract = await this.resolveTokenContract(tokenContract)
+        if (!contract) return null
+        const account = Name.from(owner)
+        const row = (await this.platform.table('balance', account).get(contract)) as
+            | PlatformContract.Types.balance_row
+            | undefined
+        if (!row) return null
+        return {owner: account, tokenContract: row.token_contract, balance: row.balance}
+    }
+
+    async getWalletBalance(
+        account: NameType,
+        tokenContract?: NameType,
+        symbolCode?: Asset.SymbolCodeType
+    ): Promise<TokenBalance | null> {
+        const contract = await this.resolveTokenContract(tokenContract)
+        if (!contract) return null
+        let code = symbolCode ? Asset.SymbolCode.from(symbolCode) : undefined
+        if (!code) {
+            const config = await this.getDepositConfig()
+            code = config?.symbol.code
+        }
+        const holder = Name.from(account)
+        const balances = await this.client.v1.chain.get_currency_balance(
+            contract,
+            holder,
+            code ? String(code) : undefined
+        )
+        const balance = balances.find((asset) => !code || asset.symbol.code.equals(code))
+        if (!balance) return null
+        return {account: holder, tokenContract: contract, balance}
+    }
+}