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

package/src/data/metadata.ts

@@ -320,12 +320,23 @@ export const itemMetadata: Record<number, ItemMetadata> = {
             'A cargo ship built around a large storage hold. The extra mass makes it slower than a Roustabout.',
         color: '#4AE898',
     },
+    10216: {
+        name: 'Nexus',
+        description:
+            'A permanent installation at a world where NFT-backed assets are wrapped, unwrapped, and deployed.',
+        color: '#FFD24C',
+    },
     10218: {
         name: 'Smith',
         description:
             'A crafting ship. One engine, one power core, and a fabricator for crafting away from home.',
         color: '#4AE898',
     },
+    10219: {
+        name: 'Depot',
+        description: 'Planetary storage facility with a loader module slot and four cargo slots.',
+        color: '#EAB308',
+    },
 
     // === Components (T2) ===
     11001: {
@@ -485,6 +496,9 @@ export const entityMetadata: Record<number, EntityMetadata> = {
         moduleSlotLabels: ['Fabricator', 'Fabricator', 'Fabricator', 'Fabricator', 'Fabricator'],
     },
     10209: {moduleSlotLabels: ['Power Core', 'Assembly Arm']},
+    10219: {
+        moduleSlotLabels: ['Shuttle Bay', 'Cargo Hold', 'Cargo Hold', 'Cargo Hold', 'Cargo Hold'],
+    },
     11212: {moduleSlotLabels: ['Power Core', 'Engine', 'Limpet Bay']},
     11213: {moduleSlotLabels: ['Power Core', 'Engine', 'Auxiliary System', 'Limpet Bay']},
     11214: {moduleSlotLabels: ['Power Core', 'Engine', 'Limpet Bay', 'Cargo Hold']},

package/src/data/recipes.json

@@ -1016,54 +1016,6 @@
     ],
     "blendWeights": []
   },
-  {
-    "outputItemId": 10208,
-    "outputMass": 4800000,
-    "inputs": [
-      {
-        "itemId": 10006,
-        "quantity": 1000
-      },
-      {
-        "itemId": 10003,
-        "quantity": 1000
-      },
-      {
-        "itemId": 10007,
-        "quantity": 1000
-      }
-    ],
-    "statSlots": [
-      {
-        "sources": []
-      },
-      {
-        "sources": [
-          {
-            "inputIndex": 1,
-            "statIndex": 0
-          }
-        ]
-      },
-      {
-        "sources": [
-          {
-            "inputIndex": 0,
-            "statIndex": 0
-          }
-        ]
-      },
-      {
-        "sources": [
-          {
-            "inputIndex": 2,
-            "statIndex": 0
-          }
-        ]
-      }
-    ],
-    "blendWeights": []
-  },
   {
     "outputItemId": 10209,
     "outputMass": 1900000,

package/src/derivation/capabilities.ts

@@ -233,6 +233,7 @@ export function computeBatteryCapabilities(
 
 import {
     ITEM_CONTAINER_T1_PACKED,
+    ITEM_DEPOT_T1_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
     ITEM_WORKSHOP_T1_PACKED,
@@ -315,6 +316,7 @@ export function computeGathererYield(str: number, tier: number): number {
 
 const BASE_CAPACITY_FN_BY_KIND: Record<string, (stats: Record<string, number>) => number> = {
     warehouse: (stats) => computeWarehouseHullCapabilities(stats).capacity,
+    depot: (stats) => computeDepotHullCapabilities(stats).capacity,
     workshop: (stats) => computeWorkshopHullCapabilities(stats).capacity,
     extractor: (stats) => computeContainerCapabilities(stats).capacity,
     factory: (stats) => computeContainerCapabilities(stats).capacity,
@@ -361,6 +363,18 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
     }
 }
 
+export function computeDepotHullCapabilities(stats: Record<string, number>): {
+    hullmass: number
+    capacity: number
+} {
+    const statSum = (stats.strength ?? 0) + (stats.hardness ?? 0)
+    const exponent = statSum / 1998.0
+    return {
+        hullmass: computeBaseHullmass(ITEM_DEPOT_T1_PACKED, stats),
+        capacity: Math.floor(50000000 * 6 ** exponent),
+    }
+}
+
 export function computeWorkshopHullCapabilities(stats: Record<string, number>): {
     hullmass: number
     capacity: number

package/src/derivation/recipe-usage.test.ts

@@ -15,7 +15,6 @@ import {
     ITEM_CRAFTER_T1,
     ITEM_BUILDER_T1,
     ITEM_EXTRACTOR_T1_PACKED,
-    ITEM_WORKSHOP_T1_PACKED,
     ITEM_ROUSTABOUT_T1A_PACKED,
     ITEM_PROSPECTOR_T1A_PACKED,
     ITEM_TENDER_T1A_PACKED,
@@ -37,7 +36,6 @@ test('getRecipeConsumers lists every recipe that consumes Sensor', () => {
             ITEM_CRAFTER_T1,
             ITEM_BUILDER_T1,
             ITEM_EXTRACTOR_T1_PACKED,
-            ITEM_WORKSHOP_T1_PACKED,
             ITEM_ROUSTABOUT_T1A_PACKED,
         ].sort((a, b) => a - b)
     )

package/src/format.ts

@@ -32,3 +32,12 @@ export function formatMassScaled(kg: number): string {
     if (tonnes >= 1_000) return `${sign}${trim(tonnes / 1_000)}k t`
     return formatMass(kg)
 }
+
+export function formatInfluence(atomic: bigint | number | string): string {
+    const points = BigInt(String(atomic)) / 10_000n
+    return `${points.toLocaleString('en-US')} pts`
+}
+
+export function formatNeedMultiplier(needFp: bigint | number | string): string {
+    return `×${(Number(BigInt(String(needFp))) / 10_000).toFixed(1)}`
+}

package/src/index-module.ts

@@ -50,14 +50,30 @@ export {
     ClusterManager,
     computeFreeCells,
     NftManager,
+    BalancesManager,
     ConstructionManager,
     JobsManager,
+    InfluenceManager,
 } from './managers'
 export type {GridCell, ClusterCell, Cluster} from './managers'
 export type {
+    CharterProgress,
+    ContributePreview,
+    ContributePreviewRow,
+    FoundedWorld,
+    InfluenceStanding,
+    PendingBallot,
+    VoteCast,
+    VoteOption,
+    VoteStandings,
     PlayerRosterEntry,
     LocationStratum,
     NftConfigForItem,
+    WrapConfig,
+    WrapGate,
+    DepositConfig,
+    PlatformBalance,
+    TokenBalance,
     BuildableTarget,
     BuildState,
     SourceEntityRef,
@@ -77,7 +93,7 @@ export type {
     LaunchStatsInput,
 } from './managers/actions'
 export type {WrapDeposit} from './managers/nft'
-export {resolveLockedAmount} from './managers/nft'
+export {resolveLockedAmount, wrapCostKey} from './managers/nft'
 
 export {
     getItem,
@@ -88,6 +104,7 @@ export {
     getModules,
     getEntityItems,
     resolveItemCategory,
+    itemTypeIndex,
     typeLabel,
     categoryLabel,
     categoryFromIndex,
@@ -356,6 +373,7 @@ export {
     ENTITY_CONTAINER,
     ENTITY_NEXUS,
     ENTITY_HUB,
+    ENTITY_DEPOT,
     getEntityClass,
     getPackedEntityType,
     getKindMeta,
@@ -376,6 +394,7 @@ export {
     isNexus,
     isPlot,
     isHub,
+    isDepot,
 } from './data/kind-registry'
 export type {EntityTypeName, KindMeta, TemplateMeta} from './data/kind-registry'
 export * from './capabilities'
@@ -462,6 +481,7 @@ export {
     computeCrafterCapabilities,
     computeBuilderCapabilities,
     computeWarehouseHullCapabilities,
+    computeDepotHullCapabilities,
     computeStorageCapabilities,
     computeBatteryCapabilities,
     computeContainerCapabilities,
@@ -583,6 +603,7 @@ export {
     computeBaseHullmass,
     computeBaseCapacityShip,
     computeBaseCapacityWarehouse,
+    computeBaseCapacityDepot,
     computeBaseCapacityContainer,
     computeEngineThrust,
     computeEngineDrain,
@@ -613,7 +634,14 @@ export {
     itemTypeCode,
 } from './data/tiers'
 
-export {formatMass, formatMassDelta, formatMassScaled, formatLocation} from './format'
+export {
+    formatInfluence,
+    formatLocation,
+    formatMass,
+    formatMassDelta,
+    formatMassScaled,
+    formatNeedMultiplier,
+} from './format'
 export * from './coordinates'
 
 export {displayName, baseName, describeItem} from './resolution/display-name'
@@ -639,3 +667,5 @@ export type {
     LanePlanEntry,
     PlanTarget,
 } from './planner'
+
+export * from './influence'

package/src/influence/categories.ts

@@ -0,0 +1,32 @@
+import {categoryFromIndex} from '../data/catalog'
+import type {ResourceCategory} from '../types'
+import {
+    RESOURCE_BIOMASS,
+    RESOURCE_CATEGORY_COUNT,
+    RESOURCE_CRYSTAL,
+    RESOURCE_GAS,
+    RESOURCE_ORE,
+    RESOURCE_REGOLITH,
+} from './constants'
+
+const INDEX_BY_CATEGORY: Record<ResourceCategory, number> = {
+    ore: RESOURCE_ORE,
+    gas: RESOURCE_GAS,
+    regolith: RESOURCE_REGOLITH,
+    biomass: RESOURCE_BIOMASS,
+    crystal: RESOURCE_CRYSTAL,
+}
+
+export function categoryIndex(category: ResourceCategory): number {
+    return INDEX_BY_CATEGORY[category]
+}
+
+export function categoryAtIndex(index: number): ResourceCategory {
+    const category = categoryFromIndex(index)
+    if (!category) throw new Error(`influence: invalid resource category index ${index}`)
+    return category
+}
+
+export function allCategoryIndexes(): number[] {
+    return Array.from({length: RESOURCE_CATEGORY_COUNT}, (_, i) => i)
+}

package/src/influence/charters.test.ts

@@ -0,0 +1,126 @@
+import {describe, expect, test} from 'bun:test'
+import {CHARTER_NONE} from './constants'
+import {
+    charterEligible,
+    charterIneligible,
+    charterNode,
+    charterSingletonMandate,
+    charterSpawnNodeFor,
+    effectiveMandate,
+    eligibleCharters,
+    type BuiltCharter,
+    type CharterWorld,
+} from './charters'
+
+const WORKSHOP = 1
+const NEXUS = 2
+const DOCK = 3
+const WORKSHOP_TUNEUP = 4
+const DOCK_TUNEUP = 5
+const DEPOT = 6
+
+const WORKSHOP_ENTITY = 100n
+const DOCK_ENTITY = 300n
+const DEPOT_ENTITY = 600n
+
+function world(built: BuiltCharter[], present?: bigint[]): CharterWorld {
+    if (!present) return {built}
+    return {built, entityExists: (id) => present.includes(id)}
+}
+
+function node(nodeId: number) {
+    const found = charterNode(nodeId)
+    if (!found) throw new Error(`registry is missing node ${nodeId}`)
+    return found
+}
+
+function eligibleIds(w: CharterWorld): number[] {
+    return eligibleCharters(w).map((n) => n.nodeId)
+}
+
+describe('charter eligibility mirror', () => {
+    test('an unbuilt world offers only the root', () => {
+        expect(eligibleIds(world([]))).toEqual([WORKSHOP])
+    })
+
+    test('the root is the mandate by the singleton rule with no ballot', () => {
+        expect(charterSingletonMandate(world([]))).toBe(WORKSHOP)
+    })
+
+    test('completing the root opens the fork and closes the singleton path', () => {
+        const built = world([{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}])
+        expect(eligibleIds(built)).toEqual([NEXUS, DOCK, WORKSHOP_TUNEUP, DEPOT])
+        expect(charterSingletonMandate(built)).toBe(CHARTER_NONE)
+    })
+
+    test('a completed charter reports already-taken', () => {
+        const built = world([{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}])
+        expect(charterIneligible(built, node(WORKSHOP))).toBe('already-taken')
+    })
+
+    test('an unmet prereq reports prereq-missing', () => {
+        expect(charterIneligible(world([]), node(NEXUS))).toBe('prereq-missing')
+        expect(charterIneligible(world([]), node(DOCK_TUNEUP))).toBe('prereq-missing')
+    })
+
+    test('a refit whose spawned target is gone reports refit-target-missing', () => {
+        const built = [{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}]
+        expect(charterEligible(world(built, [WORKSHOP_ENTITY]), node(WORKSHOP_TUNEUP))).toBe(true)
+        expect(charterIneligible(world(built, []), node(WORKSHOP_TUNEUP))).toBe(
+            'refit-target-missing'
+        )
+    })
+
+    test('a demolished target can empty an otherwise singleton eligible set', () => {
+        const built = [
+            {nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY},
+            {nodeId: NEXUS, entityId: 200n},
+            {nodeId: DOCK, entityId: DOCK_ENTITY},
+            {nodeId: DOCK_TUNEUP, entityId: 0n},
+            {nodeId: DEPOT, entityId: DEPOT_ENTITY},
+        ]
+        expect(charterSingletonMandate(world(built, [WORKSHOP_ENTITY, DOCK_ENTITY]))).toBe(
+            WORKSHOP_TUNEUP
+        )
+        expect(charterSingletonMandate(world(built, [DOCK_ENTITY]))).toBe(CHARTER_NONE)
+    })
+
+    test('an absent entity predicate trusts the charter record', () => {
+        const built = world([{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}])
+        expect(charterEligible(built, node(WORKSHOP_TUNEUP))).toBe(true)
+    })
+
+    test('refit targets resolve through the node that spawns the item', () => {
+        expect(charterSpawnNodeFor(node(WORKSHOP_TUNEUP).effect.targetItemId)?.nodeId).toBe(
+            WORKSHOP
+        )
+        expect(charterSpawnNodeFor(node(DOCK_TUNEUP).effect.targetItemId)?.nodeId).toBe(DOCK)
+        expect(charterSpawnNodeFor(0)).toBeUndefined()
+    })
+})
+
+describe('effective mandate', () => {
+    const forked = world([{nodeId: WORKSHOP, entityId: WORKSHOP_ENTITY}])
+
+    test('a stored choice holds inside its own epoch', () => {
+        expect(effectiveMandate({chosen: DOCK, chosenEpoch: 7}, forked, 7)).toBe(DOCK)
+    })
+
+    test('the same stored choice expires one epoch later', () => {
+        expect(effectiveMandate({chosen: DOCK, chosenEpoch: 7}, forked, 8)).toBe(CHARTER_NONE)
+    })
+
+    test('an expired choice falls through to the singleton rule', () => {
+        const unbuilt = world([])
+        expect(effectiveMandate({chosen: NEXUS, chosenEpoch: 7}, unbuilt, 8)).toBe(WORKSHOP)
+    })
+
+    test('a cleared pair reads the singleton rule', () => {
+        expect(effectiveMandate({chosen: CHARTER_NONE, chosenEpoch: 0}, world([]), 3)).toBe(
+            WORKSHOP
+        )
+        expect(effectiveMandate({chosen: CHARTER_NONE, chosenEpoch: 0}, forked, 3)).toBe(
+            CHARTER_NONE
+        )
+    })
+})

package/src/influence/charters.ts

@@ -0,0 +1,120 @@
+import chartersJson from '../data/charters.json'
+import {CHARTER_EFFECT_REFIT_MODULES, CHARTER_EFFECT_SPAWN_ENTITY, CHARTER_NONE} from './constants'
+
+export interface CharterEffect {
+    kind: number
+    itemId: number
+    targetItemId: number
+    slotMask: number
+    stat: number
+}
+
+export interface CharterNode {
+    nodeId: number
+    cost: bigint
+    prereqs: number[]
+    effect: CharterEffect
+}
+
+export const CHARTER_REGISTRY: CharterNode[] = chartersJson.nodes.map((node) => ({
+    nodeId: node.nodeId,
+    cost: BigInt(node.cost),
+    prereqs: [...node.prereqs],
+    effect: {...node.effect},
+}))
+
+export function charterNode(nodeId: number): CharterNode | undefined {
+    if (nodeId === CHARTER_NONE) return undefined
+    return CHARTER_REGISTRY.find((n) => n.nodeId === nodeId)
+}
+
+export type CharterIneligibility = 'already-taken' | 'prereq-missing' | 'refit-target-missing'
+
+export const CHARTER_INELIGIBILITY_MESSAGES: Record<CharterIneligibility, string> = {
+    'already-taken': 'charter is already completed at this world',
+    'prereq-missing': 'charter prerequisites are not completed',
+    'refit-target-missing': 'charter refit target not found at this world',
+}
+
+export interface BuiltCharter {
+    nodeId: number
+    entityId: bigint
+}
+
+export interface CharterWorld {
+    built: BuiltCharter[]
+    entityExists?: (entityId: bigint) => boolean
+}
+
+export interface ChosenCharter {
+    chosen: number
+    chosenEpoch: number
+}
+
+function builtCharter(world: CharterWorld, nodeId: number): BuiltCharter | undefined {
+    return world.built.find((row) => row.nodeId === nodeId)
+}
+
+export function charterSpawnNodeFor(targetItemId: number): CharterNode | undefined {
+    return CHARTER_REGISTRY.find(
+        (node) =>
+            node.effect.kind === CHARTER_EFFECT_SPAWN_ENTITY && node.effect.itemId === targetItemId
+    )
+}
+
+export function charterPrereqsMet(world: CharterWorld, node: CharterNode): boolean {
+    return node.prereqs.every(
+        (prereq) => prereq === CHARTER_NONE || builtCharter(world, prereq) !== undefined
+    )
+}
+
+export function charterEffectTargetEntity(world: CharterWorld, node: CharterNode): bigint {
+    const spawn = charterSpawnNodeFor(node.effect.targetItemId)
+    if (!spawn) return 0n
+    const record = builtCharter(world, spawn.nodeId)
+    if (!record) return 0n
+    if (world.entityExists && !world.entityExists(record.entityId)) return 0n
+    return record.entityId
+}
+
+export function charterEffectTargetPresent(world: CharterWorld, node: CharterNode): boolean {
+    if (node.effect.kind !== CHARTER_EFFECT_REFIT_MODULES) return true
+    return charterEffectTargetEntity(world, node) !== 0n
+}
+
+export function charterIneligible(
+    world: CharterWorld,
+    node: CharterNode
+): CharterIneligibility | undefined {
+    if (builtCharter(world, node.nodeId) !== undefined) return 'already-taken'
+    if (!charterPrereqsMet(world, node)) return 'prereq-missing'
+    if (!charterEffectTargetPresent(world, node)) return 'refit-target-missing'
+    return undefined
+}
+
+export function charterEligible(world: CharterWorld, node: CharterNode): boolean {
+    return charterIneligible(world, node) === undefined
+}
+
+export function eligibleCharters(world: CharterWorld): CharterNode[] {
+    return CHARTER_REGISTRY.filter((node) => charterEligible(world, node))
+}
+
+export function charterSingletonMandate(world: CharterWorld): number {
+    let only = CHARTER_NONE
+    for (const node of CHARTER_REGISTRY) {
+        if (!charterEligible(world, node)) continue
+        if (only !== CHARTER_NONE) return CHARTER_NONE
+        only = node.nodeId
+    }
+    return only
+}
+
+export function effectiveMandate(
+    stored: ChosenCharter,
+    world: CharterWorld,
+    epoch: number
+): number {
+    if (stored.chosen !== CHARTER_NONE && stored.chosenEpoch === epoch) return stored.chosen
+    return charterSingletonMandate(world)
+}

package/src/influence/citizenry.ts

@@ -0,0 +1,38 @@
+import {Checksum256, type Checksum256Type} from '@wharfkit/antelope'
+import {Coordinates, type CoordinatesType, LocationType} from '../types'
+import {hash512, uint16} from '../utils/hash'
+import {deriveLocationStatic, getSystemName} from '../utils/system'
+import citizenryAdjectives from '../data/citizenry-adjectives.json'
+import citizenryNouns from '../data/citizenry-nouns.json'
+
+const CITIZENRY_FORMS: ((world: string, noun: string, adjective: string) => string)[] = [
+    (w, n) => `${w} ${n}`,
+    (w, n, a) => `${a} ${w} ${n}`,
+    (w, n, a) => `${a} ${n} of ${w}`,
+]
+
+const FORMS_WITH_ADJECTIVE = 2
+
+export function citizenryName(
+    gameSeed: Checksum256Type,
+    coordinates: CoordinatesType
+): string | undefined {
+    const coords = Coordinates.from(coordinates)
+    const location = deriveLocationStatic(gameSeed, coords)
+    if (Number(location.type) !== LocationType.PLANET) return undefined
+
+    const world = getSystemName(gameSeed, coords)
+    const roll = hash512(
+        Checksum256.from(gameSeed),
+        `citizenry-${coords.x.toString()}-${coords.y.toString()}`
+    )
+    const form = CITIZENRY_FORMS[roll.array[0] % CITIZENRY_FORMS.length]
+    const noun = citizenryNouns[uint16(roll, 1) % citizenryNouns.length]
+    const adjective = citizenryAdjectives[uint16(roll, 3) % citizenryAdjectives.length]
+    return form(world, noun, adjective)
+}
+
+export function citizenryPatternCount(): number {
+    const plainForms = CITIZENRY_FORMS.length - FORMS_WITH_ADJECTIVE
+    return citizenryNouns.length * (plainForms + FORMS_WITH_ADJECTIVE * citizenryAdjectives.length)
+}

package/src/influence/constants.ts

@@ -0,0 +1,63 @@
+export const INFLUENCE_ATOMIC_PER_POINT = 10_000
+export const NEED_FP_SCALE = 10_000
+export const WEIGHT_FP_SCALE = 10_000
+export const MASS_KG_PER_TONNE = 1_000
+
+export const INFLUENCE_WEIGHT_FP_MAX = 1_000_000n
+export const INFLUENCE_NEED_FP_MAX = 1_000_000n
+export const INFLUENCE_MASS_KG_MAX = 1n << 48n
+
+export const DECAY_RETAIN_NUM = 19n
+export const DECAY_RETAIN_DEN = 20n
+export const DECAY_MAX_ITERATIONS = 1_024
+
+export const W_EFF_ATOMIC_PER_KG = BigInt(INFLUENCE_ATOMIC_PER_POINT / MASS_KG_PER_TONNE)
+
+export const DECOMP_MAX_BUCKETS = 12
+export const DECOMP_MAX_DEPTH = 8
+export const DECOMP_RAW_KG_MAX = 100_000_000
+export const DECOMP_PROCESSED_KG_MAX = 100_000_000
+
+export const RESOURCE_ORE = 0
+export const RESOURCE_GAS = 1
+export const RESOURCE_REGOLITH = 2
+export const RESOURCE_BIOMASS = 3
+export const RESOURCE_CRYSTAL = 4
+export const RESOURCE_CATEGORY_COUNT = 5
+
+export const CIVIC_LOADER_STAT = 213
+export const CIVIC_LOADER_TIER = 1
+export const DEFAULT_ORBITAL_Z = 800
+
+export const GRADE_STANDARD = 0
+export const GRADE_PREMIUM = 1
+export const MINTREADY_DEFAULT_CAP = 10
+
+export const BAR_SEED = 102_363
+export const BAR_STEP_UNIT = 20
+export const BAR_STEP_UP = BAR_STEP_UNIT * 9
+export const BAR_STEP_DOWN = BAR_STEP_UNIT
+
+export const CHARTER_NONE = 0
+export const CHARTER_WORKSHOP = 1
+export const CHARTER_EFFECT_SPAWN_ENTITY = 1
+export const CHARTER_EFFECT_REFIT_MODULES = 2
+export const VOTE_READY_DEFAULT_MAX = 20
+export const CHARTER_WORKSHOP_COST = 2_000_000_000n
+export const CHARTER_BASELINE_STAT = 213
+export const CHARTER_MAX_PREREQS = 4
+
+export const INFLUENCE_D1_SEED = 45_369
+export const DEMAND_TRIPLE_SEED = {peak: 20_000n, base: 10_000n, floor: 1_000n}
+
+export function poolKey(category: number, tier: number, grade: number): bigint {
+    return (BigInt(category) << 16n) | (BigInt(tier) << 8n) | BigInt(grade)
+}
+
+export function influenceWeightKey(category: number, tier: number): bigint {
+    return (BigInt(category) << 8n) | BigInt(tier)
+}
+
+export function atomicToPoints(atomic: bigint | number | string): number {
+    return Math.floor(Number(BigInt(atomic.toString())) / INFLUENCE_ATOMIC_PER_POINT)
+}

package/src/influence/decay.ts

@@ -0,0 +1,20 @@
+import {DECAY_MAX_ITERATIONS, DECAY_RETAIN_DEN, DECAY_RETAIN_NUM} from './constants'
+
+export function decayActive(active: bigint, epochsElapsed: number): bigint {
+    const iterations = epochsElapsed > DECAY_MAX_ITERATIONS ? DECAY_MAX_ITERATIONS : epochsElapsed
+    let value = active
+    for (let i = 0; i < iterations && value > 0n; i++) {
+        value = (value * DECAY_RETAIN_NUM) / DECAY_RETAIN_DEN
+    }
+    return value
+}
+
+export interface DecayableStanding {
+    active: bigint
+    lastUpdateEpoch: number
+}
+
+export function normalizeActive(standing: DecayableStanding, epoch: number): bigint {
+    const elapsed = epoch > standing.lastUpdateEpoch ? epoch - standing.lastUpdateEpoch : 0
+    return decayActive(standing.active, elapsed)
+}