@shipload/sdk 1.0.0-next.16 → 1.0.0-next.18

package/src/derivation/stratum.ts

@@ -1,7 +1,8 @@
 import {Bytes, Checksum256, type Checksum256Type} from '@wharfkit/antelope'
 import {hash512} from '../utils/hash'
 import {Coordinates, type CoordinatesType} from '../types'
-import {getEligibleResources, getResourceWeight, YIELD_THRESHOLD} from './resources'
+import {getItem} from '../data/catalog'
+import {getEligibleResources, getResourceWeight, yieldThresholdAt} from './resources'
 import {RESERVE_TIERS, rollTier, rollWithinTier} from './tiers'
 
 export interface StratumInfo {
@@ -33,15 +34,8 @@ export function deriveStratum(
 
     const rawReserve = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
 
-    let reserve = 0
-    if (rawReserve <= YIELD_THRESHOLD) {
-        const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0
-        const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0
-        const tier = rollTier(tierRoll, stratum)
-        reserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier])
-    }
-
-    if (reserve === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
+    if (rawReserve > yieldThresholdAt(stratum))
+        return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
 
     const eligible = getEligibleResources(locationType, subtype, stratum)
     if (eligible.length === 0) return {itemId: 0, seed: 0n, richness: 0, reserve: 0}
@@ -66,6 +60,12 @@ export function deriveStratum(
         }
     }
 
+    const tierRoll = ((bytes[18] << 8) | bytes[19]) >>> 0
+    const withinRoll = ((bytes[20] << 8) | bytes[21]) >>> 0
+    const tier = rollTier(tierRoll, stratum)
+    const unitMass = getItem(selectedItemId).mass
+    const reserve = rollWithinTier(withinRoll, RESERVE_TIERS[tier], unitMass)
+
     const seedBigInt =
         (BigInt(bytes[8]) << 56n) |
         (BigInt(bytes[9]) << 48n) |
@@ -76,15 +76,11 @@ export function deriveStratum(
         (BigInt(bytes[14]) << 8n) |
         BigInt(bytes[15])
 
-    const rawRichness = (bytes[16] << 8) | bytes[17]
-    const normalized = rawRichness / 65535
-    const baseRichness = Math.floor(normalized * normalized * 999) + 1
-
-    let depthBonus = 0
-    if (stratum > 1) {
-        depthBonus = (50 * Math.log(stratum)) / Math.log(65535)
-    }
-    const richness = Math.min(Math.floor(baseRichness + depthBonus), 1000)
+    let byteSum = 0
+    for (let i = 22; i <= 33; i++) byteSum += bytes[i]
+    const z = (byteSum - 1530) / 256
+    const roll = 500 + 100 * z
+    const richness = Math.max(1, Math.min(999, Math.round(roll)))
 
     return {itemId: selectedItemId, seed: seedBigInt, richness, reserve}
 }

package/src/derivation/tiers.ts

@@ -1,3 +1,5 @@
+import {getItem} from '../data/catalog'
+
 export type ReserveTier = 'small' | 'medium' | 'large' | 'massive' | 'motherlode'
 
 export interface TierRange {
@@ -6,11 +8,11 @@ export interface TierRange {
 }
 
 export const RESERVE_TIERS: Record<ReserveTier, TierRange> = {
-    small: {min: 15, max: 60},
-    medium: {min: 100, max: 200},
-    large: {min: 400, max: 700},
-    massive: {min: 1000, max: 2500},
-    motherlode: {min: 4000, max: 10000},
+    small: {min: 3_600_000, max: 14_400_000},
+    medium: {min: 24_000_000, max: 48_000_000},
+    large: {min: 96_000_000, max: 168_000_000},
+    massive: {min: 240_000_000, max: 600_000_000},
+    motherlode: {min: 960_000_000, max: 2_400_000_000},
 }
 
 const SHALLOW_THRESHOLDS = {
@@ -47,8 +49,27 @@ export function rollTier(tierRoll: number, stratum: number): ReserveTier {
     return 'motherlode'
 }
 
-export function rollWithinTier(withinRoll: number, range: TierRange): number {
+export function rollWithinTier(
+    withinRoll: number,
+    range: TierRange,
+    resourceUnitMass: number
+): number {
     const u = withinRoll / 65535
     const skewed = u * u
-    return Math.floor(range.min + skewed * (range.max - range.min))
+    const depositMass = range.min + skewed * (range.max - range.min)
+    return Math.max(1, Math.floor(depositMass / resourceUnitMass))
+}
+
+const RESERVE_TIER_ENTRIES = Object.entries(RESERVE_TIERS) as Array<[ReserveTier, TierRange]>
+
+export function tierOfReserve(reserve: number, itemId: number): ReserveTier | null {
+    if (reserve <= 0) return null
+    const unitMass = getItem(itemId).mass
+    if (unitMass <= 0) return null
+    const impliedMassLow = reserve * unitMass
+    const impliedMassHigh = impliedMassLow + unitMass
+    for (const [tier, range] of RESERVE_TIER_ENTRIES) {
+        if (impliedMassHigh > range.min && impliedMassLow <= range.max) return tier
+    }
+    return null
 }

package/src/index-module.ts

@@ -47,8 +47,9 @@ export {
     LocationsManager,
     EpochsManager,
     ActionsManager,
+    NftManager,
 } from './managers'
-export type {LocationStratum} from './managers'
+export type {LocationStratum, NftConfigForItem} from './managers'
 export type {EntityRefInput} from './managers/actions'
 
 export {
@@ -96,6 +97,9 @@ export {
     DEPTH_THRESHOLD_T5,
     LOCATION_MIN_DEPTH,
     LOCATION_MAX_DEPTH,
+    yieldThresholdAt,
+    YIELD_FRACTION_SHALLOW,
+    YIELD_FRACTION_DEEP,
     PLANET_SUBTYPE_GAS_GIANT,
     PLANET_SUBTYPE_ROCKY,
     PLANET_SUBTYPE_TERRESTRIAL,
@@ -106,9 +110,12 @@ export {
 
 export type {StratumInfo, ResourceStats, DerivedStratum} from './derivation'
 
-export {RESERVE_TIERS, TIER_ROLL_MAX, rollTier, rollWithinTier} from './derivation'
+export {RESERVE_TIERS, TIER_ROLL_MAX, tierOfReserve, rollTier, rollWithinTier} from './derivation'
 export type {ReserveTier, TierRange} from './derivation'
 
+export {getEffectiveReserve} from './derivation'
+export type {EffectiveReserveInput} from './derivation'
+
 export {getStatDefinitions, getStatName, resolveStats} from './derivation'
 export type {StatDefinition, NamedStats} from './derivation'
 
@@ -331,10 +338,25 @@ export type {
 export {deserializeAtomicData} from './nft/atomicdata'
 export type {SchemaField, RawData} from './nft/atomicdata'
 
+export {
+    buildImmutableData,
+    buildResourceImmutable,
+    buildComponentImmutable,
+    buildModuleImmutable,
+    buildEntityImmutable,
+    computeNftImageUrl,
+} from './nft/buildImmutableData'
+export type {
+    AtomicAttributeType,
+    ImmutableEntry,
+    ImmutableModuleSlot,
+} from './nft/buildImmutableData'
+
 export {
     fetchAtomicAssetsForOwner,
     fetchAtomicSchemas,
     decodeAtomicAsset,
+    buildMintAssetAction,
     ATOMICASSETS_ACCOUNT,
     SHIPLOAD_COLLECTION,
 } from './nft/atomicassets'
@@ -343,6 +365,7 @@ export type {
     AtomicSchemaRow,
     DecodedAtomicAsset,
     FetchAssetsOptions,
+    MintAssetParams,
 } from './nft/atomicassets'
 
 export {
@@ -360,7 +383,6 @@ export {
     computeGathererYield,
     computeGathererDrain,
     computeGathererDepth,
-    computeGathererSpeed,
     computeLoaderMass,
     computeLoaderThrust,
     computeCrafterSpeed,

package/src/managers/actions.ts

@@ -13,6 +13,12 @@ import {
 import {BaseManager} from './base'
 import type {CoordinatesType} from '../types'
 import {ServerContract} from '../contracts'
+import {
+    buildImmutableData,
+    type ImmutableModuleSlot,
+    moduleSlotsForImmutable,
+} from '../nft/buildImmutableData'
+import {buildMintAssetAction, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 
 export type EntityRefInput = {
     entityType: NameType
@@ -183,20 +189,81 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    wrap(
+    private async buildPairedMintAction(args: {
+        owner: NameType
+        itemId: number
+        quantity: number
+        stats: bigint
+        originX: number
+        originY: number
+        moduleSlots: ImmutableModuleSlot[]
+    }): Promise<Action> {
+        const nftCfg = await this.context.nft.getNftConfigForItem(args.itemId)
+        if (!nftCfg) {
+            throw new Error(`item ${args.itemId} has no nftconfig`)
+        }
+        const immutableData = buildImmutableData(
+            args.itemId,
+            args.quantity,
+            args.stats,
+            args.originX,
+            args.originY,
+            args.moduleSlots
+        )
+        return buildMintAssetAction({
+            authorizedMinter: Name.from(args.owner),
+            collectionName: SHIPLOAD_COLLECTION,
+            schemaName: nftCfg.schemaName,
+            templateId: nftCfg.templateId,
+            newAssetOwner: Name.from(args.owner),
+            immutableData,
+        })
+    }
+
+    async wrap(
         owner: NameType,
         entityId: UInt64Type,
         nexusId: UInt64Type,
         cargoId: UInt64Type,
         quantity: UInt64Type
-    ): Action {
-        return this.server.action('wrap', {
-            owner: Name.from(owner),
-            entity_id: UInt64.from(entityId),
-            nexus_id: UInt64.from(nexusId),
-            cargo_id: UInt64.from(cargoId),
-            quantity: UInt64.from(quantity),
+    ): Promise<Action[]> {
+        const cargoIdKey = UInt64.from(cargoId)
+        const entityIdKey = UInt64.from(entityId)
+        const [cargoRow, entityRow] = (await Promise.all([
+            this.server.table('cargo').get(cargoIdKey),
+            this.server.table('entity').get(entityIdKey),
+        ])) as [
+            ServerContract.Types.cargo_row | undefined,
+            ServerContract.Types.entity_row | undefined,
+        ]
+        if (!cargoRow) {
+            throw new Error(`cargo row ${cargoIdKey} not found`)
+        }
+        if (!entityRow) {
+            throw new Error(`entity ${entityIdKey} not found`)
+        }
+
+        const quantityValue = UInt64.from(quantity)
+        const mintAction = await this.buildPairedMintAction({
+            owner,
+            itemId: Number(cargoRow.item_id.toString()),
+            quantity: Number(quantityValue.toString()),
+            stats: BigInt(cargoRow.stats.toString()),
+            originX: Number(entityRow.coordinates.x.toString()),
+            originY: Number(entityRow.coordinates.y.toString()),
+            moduleSlots: moduleSlotsForImmutable(cargoRow.modules),
         })
+
+        return [
+            this.server.action('wrap', {
+                owner: Name.from(owner),
+                entity_id: UInt64.from(entityId),
+                nexus_id: UInt64.from(nexusId),
+                cargo_id: cargoIdKey,
+                quantity: quantityValue,
+            }),
+            mintAction,
+        ]
     }
 
     undeploy(hostId: UInt64Type, targetId: UInt64Type): Action {
@@ -206,11 +273,36 @@ export class ActionsManager extends BaseManager {
         })
     }
 
-    wrapEntity(entityId: UInt64Type, nexusId: UInt64Type): Action {
-        return this.server.action('wrapentity', {
-            entity_id: UInt64.from(entityId),
-            nexus_id: UInt64.from(nexusId),
+    async wrapEntity(
+        owner: NameType,
+        entityId: UInt64Type,
+        nexusId: UInt64Type
+    ): Promise<Action[]> {
+        const entityIdKey = UInt64.from(entityId)
+        const entityRow = (await this.server.table('entity').get(entityIdKey)) as
+            | ServerContract.Types.entity_row
+            | undefined
+        if (!entityRow) {
+            throw new Error(`entity ${entityIdKey} not found`)
+        }
+
+        const mintAction = await this.buildPairedMintAction({
+            owner,
+            itemId: Number(entityRow.item_id.toString()),
+            quantity: 1,
+            stats: BigInt(entityRow.stats.toString()),
+            originX: Number(entityRow.coordinates.x.toString()),
+            originY: Number(entityRow.coordinates.y.toString()),
+            moduleSlots: moduleSlotsForImmutable(entityRow.modules),
         })
+
+        return [
+            this.server.action('wrapentity', {
+                entity_id: entityIdKey,
+                nexus_id: UInt64.from(nexusId),
+            }),
+            mintAction,
+        ]
     }
 
     deploynft(owner: NameType, assetId: UInt64Type, targetNexusId: UInt64Type): Action {

package/src/managers/context.ts

@@ -8,6 +8,7 @@ import {PlayersManager} from './players'
 import {LocationsManager} from './locations'
 import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
+import {NftManager} from './nft'
 import {SubscriptionsManager} from '../subscriptions/manager'
 
 export class GameContext {
@@ -16,6 +17,7 @@ export class GameContext {
     private _locations?: LocationsManager
     private _epochs?: EpochsManager
     private _actions?: ActionsManager
+    private _nft?: NftManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
 
@@ -63,6 +65,13 @@ export class GameContext {
         return this._actions
     }
 
+    get nft(): NftManager {
+        if (!this._nft) {
+            this._nft = new NftManager(this)
+        }
+        return this._nft
+    }
+
     setSubscriptionsUrl(url: string) {
         this._subscriptionsUrl = url
     }

package/src/managers/index.ts

@@ -7,3 +7,5 @@ export {LocationsManager} from './locations'
 export type {LocationStratum} from './locations'
 export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'
+export {NftManager} from './nft'
+export type {NftConfigForItem} from './nft'

package/src/managers/nft.ts

@@ -0,0 +1,28 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+
+export interface NftConfigForItem {
+    templateId: number
+    schemaName: string
+}
+
+export class NftManager extends BaseManager {
+    private cache = new Map<string, NftConfigForItem | null>()
+
+    async getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined> {
+        const id = UInt64.from(itemId)
+        const key = id.toString()
+        if (this.cache.has(key)) {
+            return this.cache.get(key) ?? undefined
+        }
+        const row = (await this.server.table('nftconfig').get(id)) as
+            | ServerContract.Types.nftconfig_row
+            | undefined
+        const result: NftConfigForItem | null = row
+            ? {templateId: Number(row.template_id), schemaName: String(row.schema_name)}
+            : null
+        this.cache.set(key, result)
+        return result ?? undefined
+    }
+}

package/src/nft/atomicassets.ts

@@ -1,10 +1,133 @@
-import {type APIClient, Name, type NameType, UInt64} from '@wharfkit/antelope'
+import {
+    ABI,
+    type ABIDef,
+    Action,
+    type APIClient,
+    type NameType,
+    Name,
+    PermissionLevel,
+    UInt64,
+} from '@wharfkit/antelope'
 import {deserializeAtomicData, type SchemaField} from './atomicdata'
 import {deserializeAsset, type NFTCargoItem, type NFTModuleSlot} from './deserializers'
+import type {ImmutableEntry} from './buildImmutableData'
+
+const PLACEHOLDER_AUTH = PermissionLevel.from({
+    actor: '............1',
+    permission: '............2',
+})
 
 export const ATOMICASSETS_ACCOUNT = 'atomicassets'
 export const SHIPLOAD_COLLECTION = 'shipload'
 
+const ATOMIC_ATTRIBUTE_VARIANT_NAME =
+    'variant_int8_int16_int32_int64_uint8_uint16_uint32_uint64_float32_float64_string_INT8_VEC_INT16_VEC_INT32_VEC_INT64_VEC_UINT8_VEC_UINT16_VEC_UINT32_VEC_UINT64_VEC_FLOAT_VEC_DOUBLE_VEC_STRING_VEC'
+
+const MINTASSET_ABI_DEF: ABIDef = {
+    version: 'eosio::abi/1.2',
+    types: [
+        {new_type_name: 'ATOMIC_ATTRIBUTE', type: ATOMIC_ATTRIBUTE_VARIANT_NAME},
+        {new_type_name: 'ATTRIBUTE_MAP', type: 'pair_string_ATOMIC_ATTRIBUTE[]'},
+        {new_type_name: 'INT8_VEC', type: 'bytes'},
+        {new_type_name: 'INT16_VEC', type: 'int16[]'},
+        {new_type_name: 'INT32_VEC', type: 'int32[]'},
+        {new_type_name: 'INT64_VEC', type: 'int64[]'},
+        {new_type_name: 'UINT8_VEC', type: 'bytes'},
+        {new_type_name: 'UINT16_VEC', type: 'uint16[]'},
+        {new_type_name: 'UINT32_VEC', type: 'uint32[]'},
+        {new_type_name: 'UINT64_VEC', type: 'uint64[]'},
+        {new_type_name: 'FLOAT_VEC', type: 'float32[]'},
+        {new_type_name: 'DOUBLE_VEC', type: 'float64[]'},
+        {new_type_name: 'STRING_VEC', type: 'string[]'},
+    ],
+    structs: [
+        {
+            name: 'pair_string_ATOMIC_ATTRIBUTE',
+            base: '',
+            fields: [
+                {name: 'first', type: 'string'},
+                {name: 'second', type: 'ATOMIC_ATTRIBUTE'},
+            ],
+        },
+        {
+            name: 'mintasset',
+            base: '',
+            fields: [
+                {name: 'authorized_minter', type: 'name'},
+                {name: 'collection_name', type: 'name'},
+                {name: 'schema_name', type: 'name'},
+                {name: 'template_id', type: 'int32'},
+                {name: 'new_asset_owner', type: 'name'},
+                {name: 'immutable_data', type: 'ATTRIBUTE_MAP'},
+                {name: 'mutable_data', type: 'ATTRIBUTE_MAP'},
+                {name: 'tokens_to_back', type: 'asset[]'},
+            ],
+        },
+    ],
+    actions: [{name: 'mintasset', type: 'mintasset', ricardian_contract: ''}],
+    variants: [
+        {
+            name: ATOMIC_ATTRIBUTE_VARIANT_NAME,
+            types: [
+                'int8',
+                'int16',
+                'int32',
+                'int64',
+                'uint8',
+                'uint16',
+                'uint32',
+                'uint64',
+                'float32',
+                'float64',
+                'string',
+                'INT8_VEC',
+                'INT16_VEC',
+                'INT32_VEC',
+                'INT64_VEC',
+                'UINT8_VEC',
+                'UINT16_VEC',
+                'UINT32_VEC',
+                'UINT64_VEC',
+                'FLOAT_VEC',
+                'DOUBLE_VEC',
+                'STRING_VEC',
+            ],
+        },
+    ],
+}
+
+export interface MintAssetParams {
+    authorizedMinter: NameType
+    collectionName: NameType
+    schemaName: NameType
+    templateId: number
+    newAssetOwner: NameType
+    immutableData: ImmutableEntry[]
+}
+
+const MINTASSET_ABI = ABI.from(MINTASSET_ABI_DEF)
+
+export function buildMintAssetAction(params: MintAssetParams): Action {
+    return Action.from(
+        {
+            account: Name.from(ATOMICASSETS_ACCOUNT),
+            name: Name.from('mintasset'),
+            authorization: [PLACEHOLDER_AUTH],
+            data: {
+                authorized_minter: Name.from(params.authorizedMinter),
+                collection_name: Name.from(params.collectionName),
+                schema_name: Name.from(params.schemaName),
+                template_id: params.templateId,
+                new_asset_owner: Name.from(params.newAssetOwner),
+                immutable_data: params.immutableData,
+                mutable_data: [],
+                tokens_to_back: [],
+            },
+        },
+        MINTASSET_ABI
+    )
+}
+
 export interface AtomicAssetRow {
     asset_id: string
     collection_name: string