@shipload/sdk 1.0.0-next.63 → 1.0.0-next.65

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}
+    }
+}

package/src/managers/context.ts

@@ -11,6 +11,7 @@ import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
 import {ClusterManager} from './cluster'
 import {NftManager} from './nft'
+import {BalancesManager} from './balances'
 import {JobsManager} from './jobs'
 import {InfluenceManager} from './influence'
 import {SubscriptionsManager} from '../subscriptions/manager'
@@ -24,6 +25,7 @@ export class GameContext {
     private _actions?: ActionsManager
     private _clusters?: ClusterManager
     private _nft?: NftManager
+    private _balances?: BalancesManager
     private _jobs?: JobsManager
     private _influence?: InfluenceManager
     private _subscriptions?: SubscriptionsManager
@@ -95,6 +97,13 @@ export class GameContext {
         return this._nft
     }
 
+    get balances(): BalancesManager {
+        if (!this._balances) {
+            this._balances = new BalancesManager(this)
+        }
+        return this._balances
+    }
+
     get jobs(): JobsManager {
         if (!this._jobs) {
             this._jobs = new JobsManager(this)

package/src/managers/index.ts

@@ -11,7 +11,9 @@ export {ActionsManager} from './actions'
 export {ClusterManager, computeFreeCells} from './cluster'
 export type {GridCell, ClusterCell, Cluster} from './cluster'
 export {NftManager} from './nft'
-export type {NftConfigForItem} from './nft'
+export type {NftConfigForItem, WrapConfig, WrapGate} from './nft'
+export {BalancesManager} from './balances'
+export type {DepositConfig, PlatformBalance, TokenBalance} from './balances'
 export {JobsManager} from './jobs'
 export {InfluenceManager} from './influence'
 export type {
@@ -19,6 +21,7 @@ export type {
     ContributePreview,
     ContributePreviewRow,
     FoundedWorld,
+    FoundedWorldRef,
     InfluenceStanding,
     PendingBallot,
     VoteCast,

package/src/managers/influence.ts

@@ -73,6 +73,12 @@ export interface FoundedWorld {
     founded: number
 }
 
+export interface FoundedWorldRef {
+    x: number
+    y: number
+    mandate: number
+}
+
 export interface VoteOption {
     nodeId: number
     cost: bigint
@@ -247,6 +253,25 @@ export class InfluenceManager extends BaseManager {
         return (await this.server.readonly('getmintcfg')) as ServerContract.Types.mintcfg_result
     }
 
+    async getMintReady(): Promise<number> {
+        return Number(await this.server.readonly('getmintready'))
+    }
+
+    async getVoteReady(): Promise<number> {
+        return Number(await this.server.readonly('getvoteready'))
+    }
+
+    async getCharterReady(): Promise<FoundedWorldRef[]> {
+        const result = (await this.server.readonly(
+            'getchrtready'
+        )) as ServerContract.Types.charterready_result
+        return result.worlds.map((w) => ({
+            x: Number(w.x),
+            y: Number(w.y),
+            mandate: Number(w.mandate),
+        }))
+    }
+
     async getVotes(location: CoordinatesType): Promise<VoteStandings> {
         const result = (await this.server.readonly('getvotes', {
             x: Int64.from(location.x),

package/src/managers/nft.test.ts

@@ -1,5 +1,5 @@
 import {describe, expect, test} from 'bun:test'
-import {resolveLockedAmount} from './nft'
+import {resolveLockedAmount, wrapCostKey} from './nft'
 
 describe('resolveLockedAmount', () => {
     test('no fee refunds the full cost', () => {
@@ -12,3 +12,10 @@ describe('resolveLockedAmount', () => {
         expect(resolveLockedAmount(101n, 250)).toBe(99n) // fee = floor(101*250/10000)=2
     })
 })
+
+describe('wrapCostKey', () => {
+    test('packs item type and tier as (type << 8) | tier', () => {
+        expect(wrapCostKey(0, 1).toString()).toBe('1')
+        expect(wrapCostKey(3, 2).toString()).toBe('770')
+    })
+})

package/src/managers/nft.ts

@@ -1,4 +1,4 @@
-import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {Name, UInt64, type NameType, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import type {PlatformContract, ServerContract} from '../contracts'
 
@@ -7,6 +7,17 @@ export interface NftConfigForItem {
     schemaName: string
 }
 
+export interface WrapConfig {
+    feePctBasisPoints: number
+    feeAccount: Name
+}
+
+export interface WrapGate {
+    owner: Name
+    game: Name
+    lastAssetId: UInt64
+}
+
 export interface WrapDeposit {
     cost: bigint
     refund: bigint
@@ -21,8 +32,13 @@ export function resolveLockedAmount(cost: bigint, feePctBasisPoints: number): bi
     return cost - fee
 }
 
+export function wrapCostKey(itemType: number, tier: number): UInt64 {
+    return UInt64.from((BigInt(itemType) << 8n) | BigInt(tier))
+}
+
 export class NftManager extends BaseManager {
     private cache = new Map<string, NftConfigForItem | null>()
+    private wrapConfig?: WrapConfig | null
 
     async getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined> {
         const id = UInt64.from(itemId)
@@ -40,31 +56,55 @@ export class NftManager extends BaseManager {
         return result ?? undefined
     }
 
-    async getWrapDeposit(itemType: number, tier: number): Promise<WrapDeposit | null> {
-        const key = UInt64.from((BigInt(itemType) << 8n) | BigInt(tier))
-        const costRow = (await this.server.table('wrapcost').get(key)) as
+    async getWrapConfig(reload = false): Promise<WrapConfig | null> {
+        if (!reload && this.wrapConfig !== undefined) {
+            return this.wrapConfig
+        }
+        const row = (await this.server.table('wrapconfig').get()) as
+            | ServerContract.Types.wrapconfig_row
+            | undefined
+        this.wrapConfig = row
+            ? {feePctBasisPoints: Number(row.fee_pct), feeAccount: row.fee_account}
+            : null
+        return this.wrapConfig
+    }
+
+    async getWrapCost(itemType: number, tier: number): Promise<bigint> {
+        const row = (await this.server.table('wrapcost').get(wrapCostKey(itemType, tier))) as
             | ServerContract.Types.wrapcost_row
             | undefined
-        const cost = costRow ? BigInt(costRow.amount.toString()) : 0n
+        return row ? BigInt(row.amount.toString()) : 0n
+    }
+
+    async getWrapDeposit(
+        itemType: number,
+        tier: number,
+        opts: {reload?: boolean} = {}
+    ): Promise<WrapDeposit | null> {
+        const cost = await this.getWrapCost(itemType, tier)
         if (cost === 0n) return null
 
-        const cfg = (await this.server.table('wrapconfig').get()) as
-            | ServerContract.Types.wrapconfig_row
-            | undefined
-        const feePctBasisPoints = cfg ? Number(cfg.fee_pct) : 0
+        const wrapConfig = await this.getWrapConfig(opts.reload)
+        const feePctBasisPoints = wrapConfig ? wrapConfig.feePctBasisPoints : 0
 
-        const depositCfg = (await this.platform.table('depositcfg').get()) as
-            | PlatformContract.Types.depositcfg_row
-            | undefined
-        if (!depositCfg) return null
+        const depositConfig = await this.context.balances.getDepositConfig(opts.reload)
+        if (!depositConfig) return null
 
         return {
             cost,
             refund: resolveLockedAmount(cost, feePctBasisPoints),
             feePct: feePctBasisPoints / 100,
-            symbol: depositCfg.token_symbol.code.toString(),
-            precision: depositCfg.token_symbol.precision,
-            tokenContract: depositCfg.token_contract.toString(),
+            symbol: depositConfig.symbol.code.toString(),
+            precision: depositConfig.symbol.precision,
+            tokenContract: depositConfig.tokenContract.toString(),
         }
     }
+
+    async getWrapGate(owner: NameType): Promise<WrapGate | null> {
+        const row = (await this.platform.table('wrapgate').get(Name.from(owner))) as
+            | PlatformContract.Types.wrapgate_row
+            | undefined
+        if (!row) return null
+        return {owner: row.owner, game: row.game, lastAssetId: row.last_asset_id}
+    }
 }

package/src/shipload.ts

@@ -1,7 +1,7 @@
 import {APIClient} from '@wharfkit/antelope'
 import {PlatformContract, ServerContract} from './contracts'
 import type {ChainDefinition} from '@wharfkit/common'
-import ContractKit, {type Contract} from '@wharfkit/contract'
+import {ContractKit, type Contract} from '@wharfkit/contract'
 
 import {GameContext} from './managers/context'
 import type {EntitiesManager} from './managers/entities'
@@ -12,6 +12,7 @@ import type {EpochsManager} from './managers/epochs'
 import type {ActionsManager} from './managers/actions'
 import type {ClusterManager} from './managers/cluster'
 import type {NftManager} from './managers/nft'
+import type {BalancesManager} from './managers/balances'
 import type {JobsManager} from './managers/jobs'
 import type {InfluenceManager} from './managers/influence'
 import type {SubscriptionsManager} from './subscriptions/manager'
@@ -134,6 +135,10 @@ export class Shipload {
         return this._context.nft
     }
 
+    get balances(): BalancesManager {
+        return this._context.balances
+    }
+
     get jobs(): JobsManager {
         return this._context.jobs
     }

package/src/utils/hash.ts

@@ -9,3 +9,7 @@ export function hash512(seed: Checksum256Type, string: string): Checksum512 {
     const bytes = Bytes.from(`${seed}${string}`, 'utf8')
     return Checksum512.hash(bytes)
 }
+
+export function uint16(hash: Checksum512, offset: number): number {
+    return (hash.array[offset] << 8) | hash.array[offset + 1]
+}

package/src/utils/system.ts

@@ -1,5 +1,5 @@
 import {Checksum256, type Checksum256Type, type Checksum512, UInt8} from '@wharfkit/antelope'
-import {hash512} from './hash'
+import {hash512, uint16} from './hash'
 import {Coordinates, type CoordinatesType, LocationType} from '../types'
 import {ServerContract} from '../contracts'
 import {deriveLocationSize} from '../derivation/location-size'
@@ -47,10 +47,6 @@ export function getLocationTypeName(type: LocationType): string {
     }
 }
 
-function uint16(hash: Checksum512, offset: number): number {
-    return (hash.array[offset] << 8) | hash.array[offset + 1]
-}
-
 function generatePlanetName(hashResult: Checksum512): string {
     const syllableCount = 2 + (hashResult.array[0] % 2)
     const name: string[] = []