@aephia/atlas-kit 0.7.0-next.1 → 0.7.0-next.3

package/dist/combat/actions/index.js

@@ -277,7 +277,7 @@ export async function planFleetApplyCombatStimulant(ctx, fleet, stimulant, input
     }
     const [currentAccount] = await readContextRawAccounts(ctx, [fleet.address]);
     const account = requireAccount(currentAccount, fleet.address, `Fleet ${fleet.name} (${fleet.address}) is missing. Refresh Fleet discovery and retry applying ${catalogued.cargo.name}.`);
-    const current = fleetAccountDefinition.decode(account);
+    const current = fleetAccountDefinition.decode(account, ctx.programs);
     const snapshotFingerprint = [
         fleet.address,
         fleet.game,
@@ -296,14 +296,14 @@ export async function planFleetApplyCombatStimulant(ctx, fleet, stimulant, input
         current.crewCount,
         rawCargoFingerprint(current),
     ].join('|');
-    if ((await deriveFleetAddress(current)) !== fleet.address ||
+    if ((await deriveFleetAddress(ctx.programs, current)) !== fleet.address ||
         currentFingerprint !== snapshotFingerprint) {
         fail(`Fleet ${fleet.name} (${fleet.address}) changed or does not match its canonical Game, owner, label, state, crew count, or cargo hold. Refresh the Fleet through this context and retry.`, fleet.address);
     }
     if (current.crewCount <= 0) {
         fail(`Fleet ${fleet.name} (${fleet.address}) has no crew and cannot apply a combat stimulant. Crew the Fleet, refresh it through this context, and retry.`, fleet.address);
     }
-    const instruction = adaptApplyCombatStimulantInstruction({
+    const instruction = adaptApplyCombatStimulantInstruction(ctx.programs, {
         authorization: options.authorization,
         fleet: fleet.address,
         game,
@@ -313,7 +313,7 @@ export async function planFleetApplyCombatStimulant(ctx, fleet, stimulant, input
     // that from the Profile vault with the signing key.
     const storage = await planFleetStorage(ctx, instruction, [account.address], options.authorization.profile, 'combat stimulant', catalogued.effects.map(({ stat }) => stimulantStatId(stat)));
     const description = `Apply one ${catalogued.cargo.name} combat stimulant from Fleet ${fleet.name} (${fleet.address}); permission, stacking, charge application, and combat outcomes remain chain-authoritative. ${storage.disclosure}`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'combat.apply-stimulant',
         preconditions: [
             await accountStatePrecondition(account, `Fleet ${fleet.name} retains its configured Game, owning Profile, supported crewed state, and known ${catalogued.cargo.name} cargo balance.`),
@@ -361,9 +361,9 @@ function attackFleetFingerprint(address, fleet, ships) {
         ships,
     ].join('|');
 }
-async function validateCurrentAttackFleet(fleet, account) {
+async function validateCurrentAttackFleet(programs, fleet, account) {
     const currentAccount = requireAccount(account, fleet.address, `Fleet ${fleet.name} (${fleet.address}) is missing. Refresh Fleet discovery and retry the attack.`);
-    const current = fleetAccountDefinition.decode(currentAccount);
+    const current = fleetAccountDefinition.decode(currentAccount, programs);
     const currentFingerprint = [
         currentAccount.address,
         currentAccount.address,
@@ -377,7 +377,7 @@ async function validateCurrentAttackFleet(fleet, account) {
         current.npcFactionId,
         rawShipFingerprint(current),
     ].join('|');
-    if ((await deriveFleetAddress(current)) !== fleet.address ||
+    if ((await deriveFleetAddress(programs, current)) !== fleet.address ||
         currentFingerprint !==
             attackFleetFingerprint(fleet.address, fleet, shipFingerprint(fleet))) {
         fail(`Fleet ${fleet.name} (${fleet.address}) changed or does not match its canonical Game, owner, label, state, crew, AP, faction, or ship composition. Refresh both Fleets and retry.`, fleet.address);
@@ -388,9 +388,9 @@ async function validateCurrentAttackFleet(fleet, account) {
  * chain time (a finished warp counts as Idle), carries its required crew, and
  * has usable AP: stored AP refills right after an attack, but stays unusable
  * until the reload completes. */
-function validateAttackerReadiness(fleet, account, clock) {
+function validateAttackerReadiness(programs, fleet, account, clock) {
     const now = readClock(requireAccount(clock, CLOCK_ADDRESS, 'The Clock sysvar is missing. Refresh chain time and retry the attack.'));
-    const current = fleetAccountDefinition.decode(account);
+    const current = fleetAccountDefinition.decode(account, programs);
     const label = `Attacking Fleet ${fleet.name} (${fleet.address})`;
     const { state } = current;
     if (state.kind !== 'idle' &&
@@ -404,7 +404,7 @@ function validateAttackerReadiness(fleet, account, clock) {
         fail(`${label} has no usable ability power at chain time ${String(now)}: stored AP ${String(current.ap)} with reload completing at ${String(current.apReloadExpiresAt)}. Wait for the reload, refresh the Fleet, and retry.`, fleet.address);
 }
 async function optionalCrewBinding(ctx, fleet) {
-    const address = await deriveFleetCrewBindingAddress(fleet.address);
+    const address = await deriveFleetCrewBindingAddress(ctx.programs, fleet.address);
     const [envelope] = await ctx.data.readMany(fleetCrewBindingAccountDefinition, [address]);
     if (envelope !== undefined &&
         !matchesFleetCrewBindingIdentity(envelope.data, fleet.address, fleet.ownerProfile.address)) {
@@ -417,8 +417,8 @@ async function resolveRewardAccounts(ctx, fleet, registry, config, epochIndex) {
     if (resolvedFaction === 0)
         return { config, registry };
     const [epochAddress, contributionAddress] = await Promise.all([
-        deriveLoyaltyEpochAddress(fleet.game, resolvedFaction, epochIndex),
-        deriveLoyaltyContributionAddress(fleet.game, fleet.ownerProfile.address, resolvedFaction, epochIndex),
+        deriveLoyaltyEpochAddress(ctx.programs, fleet.game, resolvedFaction, epochIndex),
+        deriveLoyaltyContributionAddress(ctx.programs, fleet.game, fleet.ownerProfile.address, resolvedFaction, epochIndex),
     ]);
     const [[epoch], [contribution]] = await Promise.all([
         ctx.data.readMany(loyaltyEpochAccountDefinition, [epochAddress]),
@@ -454,13 +454,16 @@ async function resolveNpcAccounts(ctx, fleet, withFaction) {
     if (fleet.npcFactionId === 0)
         return {};
     const addresses = await Promise.all([
-        deriveFactionOwnershipAddress(fleet.game, 'fleet', fleet.address),
+        deriveFactionOwnershipAddress(ctx.programs, fleet.game, 'fleet', fleet.address),
         ...(withFaction
-            ? [deriveFactionAccountAddress(fleet.game, fleet.npcFactionId)]
+            ? [
+                deriveFactionAccountAddress(ctx.programs, fleet.game, fleet.npcFactionId),
+            ]
             : []),
     ]);
     const [ownership, faction] = await readContextRawAccounts(ctx, addresses);
-    const ownershipData = ownership && factionOwnershipAccountDefinition.decode(ownership);
+    const ownershipData = ownership &&
+        factionOwnershipAccountDefinition.decode(ownership, ctx.programs);
     if (ownership === undefined ||
         ownershipData?.game !== fleet.game ||
         ownershipData.asset.kind !== 'fleet' ||
@@ -470,7 +473,7 @@ async function resolveNpcAccounts(ctx, fleet, withFaction) {
     }
     if (!withFaction)
         return { ownership };
-    const factionData = faction && factionAccountDefinition.decode(faction);
+    const factionData = faction && factionAccountDefinition.decode(faction, ctx.programs);
     if (faction === undefined ||
         factionData?.game !== fleet.game ||
         factionData.factionId !== fleet.npcFactionId) {
@@ -565,16 +568,16 @@ export async function planFleetAttackFleet(ctx, attacker, defender, inputStance,
         fail(`Loot account ${options.loot} already exists. Generate a new unused Loot signer address and retry.`, options.loot);
     }
     const [attackerAccount, defenderAccount] = await Promise.all([
-        validateCurrentAttackFleet(attacker, currentAccounts[0]),
-        validateCurrentAttackFleet(defender, currentAccounts[1]),
+        validateCurrentAttackFleet(ctx.programs, attacker, currentAccounts[0]),
+        validateCurrentAttackFleet(ctx.programs, defender, currentAccounts[1]),
     ]);
-    validateAttackerReadiness(attacker, attackerAccount, currentAccounts[3]);
-    const registryAddress = await deriveAtlasRewardRegistryAddress(game);
+    validateAttackerReadiness(ctx.programs, attacker, attackerAccount, currentAccounts[3]);
+    const registryAddress = await deriveAtlasRewardRegistryAddress(ctx.programs, game);
     const registry = await ctx.data.read(atlasRewardRegistryAccountDefinition, registryAddress);
     if (registry.data.game !== game) {
         fail(`AtlasRewardRegistry ${registryAddress} belongs to another Game. Refresh the configured reward registry and retry.`, registryAddress);
     }
-    const rewardConfig = await deriveAtlasRewardConfigAddress(game, registry.data.activeConfigVersion);
+    const rewardConfig = await deriveAtlasRewardConfigAddress(ctx.programs, game, registry.data.activeConfigVersion);
     const [attackerRewards, defenderRewards, crewBinding, attackerNpc, defenderNpc,] = await Promise.all([
         resolveRewardAccounts(ctx, attacker, registryAddress, rewardConfig, registry.data.currentEpoch),
         resolveRewardAccounts(ctx, defender, registryAddress, rewardConfig, registry.data.currentEpoch),
@@ -583,10 +586,10 @@ export async function planFleetAttackFleet(ctx, attacker, defender, inputStance,
         resolveNpcAccounts(ctx, defender, false),
     ]);
     const [character, defenderCharacter, regionTracker, factionRelationTracker] = await Promise.all([
-        findCharacterPda(attacker.ownerProfile.address, game),
-        findCharacterPda(defender.ownerProfile.address, game),
-        deriveRegionTrackerAddress(game),
-        deriveFactionRelationTrackerAddress(game),
+        findCharacterPda(ctx.programs, attacker.ownerProfile.address, game),
+        findCharacterPda(ctx.programs, defender.ownerProfile.address, game),
+        deriveRegionTrackerAddress(ctx.programs, game),
+        deriveFactionRelationTrackerAddress(ctx.programs, game),
     ]);
     const actorIntent = {
         address: attacker.address,
@@ -612,7 +615,7 @@ export async function planFleetAttackFleet(ctx, attacker, defender, inputStance,
         accounts: xp.accounts,
         describes: 'Both operator XP budgets remain canonical and reconciled; earned XP and bank balances may change.',
     }));
-    const instruction = adaptAttackFleetInstruction({
+    const instruction = adaptAttackFleetInstruction(ctx.programs, {
         ...(attackerNpc.faction === undefined
             ? {}
             : { attackerFactionAccount: attackerNpc.faction.address }),
@@ -658,7 +661,7 @@ export async function planFleetAttackFleet(ctx, attacker, defender, inputStance,
         stance: generatedStance(stance),
     });
     const description = `Attack Fleet ${defender.name} (${defender.address}) with Fleet ${attacker.name} (${attacker.address}) using ${stance.ammoUsage} ammunition; range, randomness, rewards, Loot, damage, and final combat arithmetic remain chain-authoritative.`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'combat.attack-fleet',
         preconditions: [
             {
@@ -738,35 +741,36 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
     if (target.game !== game) {
         fail(`Target Star System ${target.address} belongs to Game ${target.game}, not configured Game ${game}. Refresh the target through this context and retry.`, target.address);
     }
-    if ((await deriveStarSystemAddress(game, target.systemId)) !== target.address) {
+    if ((await deriveStarSystemAddress(ctx.programs, game, target.systemId)) !==
+        target.address) {
         fail(`Target Star System ${target.address} is not the canonical member for Game ${game} and system id ${String(target.systemId)}. Refresh the target through this context and retry.`, target.address);
     }
     if (target.starbase === undefined) {
         fail(`Target Star System ${target.name} (${target.address}) has no shared Starbase. Choose a System with a shared Starbase and retry.`, target.address);
     }
     const [relationTrackerAddress, ownershipAddress, registryAddress, kingTracker, character, regionTracker, crewBindingAddress,] = await Promise.all([
-        deriveFactionRelationTrackerAddress(game),
-        deriveFactionOwnershipAddress(game, 'starbase', target.address),
-        deriveAtlasRewardRegistryAddress(game),
-        deriveKingSystemTrackerAddress(game),
-        findCharacterPda(attacker.ownerProfile.address, game),
-        deriveRegionTrackerAddress(game),
-        deriveFleetCrewBindingAddress(attacker.address),
+        deriveFactionRelationTrackerAddress(ctx.programs, game),
+        deriveFactionOwnershipAddress(ctx.programs, game, 'starbase', target.address),
+        deriveAtlasRewardRegistryAddress(ctx.programs, game),
+        deriveKingSystemTrackerAddress(ctx.programs, game),
+        findCharacterPda(ctx.programs, attacker.ownerProfile.address, game),
+        deriveRegionTrackerAddress(ctx.programs, game),
+        deriveFleetCrewBindingAddress(ctx.programs, attacker.address),
     ]);
     const [[probeRelationsAccount, probeRegistryAccount], attackerNpc, rent] = await Promise.all([
         readContextRawAccounts(ctx, [relationTrackerAddress, registryAddress]),
         resolveNpcAccounts(ctx, attacker, true),
         requireDisabledLevelRent(ctx, game, target, 'the Starbase attack'),
     ]);
-    const probeRelations = factionRelationTrackerAccountDefinition.decode(requireAccount(probeRelationsAccount, relationTrackerAddress, `FactionRelationTracker ${relationTrackerAddress} is missing. Refresh faction relationships and retry.`));
-    const probeRegistry = atlasRewardRegistryAccountDefinition.decode(requireAccount(probeRegistryAccount, registryAddress, `AtlasRewardRegistry ${registryAddress} is missing. Refresh reward configuration and retry.`));
+    const probeRelations = factionRelationTrackerAccountDefinition.decode(requireAccount(probeRelationsAccount, relationTrackerAddress, `FactionRelationTracker ${relationTrackerAddress} is missing. Refresh faction relationships and retry.`), ctx.programs);
+    const probeRegistry = atlasRewardRegistryAccountDefinition.decode(requireAccount(probeRegistryAccount, registryAddress, `AtlasRewardRegistry ${registryAddress} is missing. Refresh reward configuration and retry.`), ctx.programs);
     if (probeRelations.game !== game) {
         fail(`FactionRelationTracker ${relationTrackerAddress} belongs to another Game. Refresh faction relationships and retry.`, relationTrackerAddress);
     }
     if (probeRegistry.game !== game) {
         fail(`AtlasRewardRegistry ${registryAddress} belongs to another Game. Refresh the configured reward registry and retry.`, registryAddress);
     }
-    const rewardConfigAddress = await deriveAtlasRewardConfigAddress(game, probeRegistry.activeConfigVersion);
+    const rewardConfigAddress = await deriveAtlasRewardConfigAddress(ctx.programs, game, probeRegistry.activeConfigVersion);
     const requiresNpcEconomy = attacker.npcFactionId > 0 &&
         probeRelations.dynamicCaptureEnabled &&
         probeRelations.nemesisActive;
@@ -774,8 +778,8 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
     let captorTreasury;
     if (requiresNpcEconomy) {
         [factionEconomicsConfig, captorTreasury] = await Promise.all([
-            deriveFactionEconomicsConfigAddress(game),
-            deriveFactionTreasuryAddress(game, attacker.npcFactionId),
+            deriveFactionEconomicsConfigAddress(ctx.programs, game),
+            deriveFactionTreasuryAddress(ctx.programs, game, attacker.npcFactionId),
         ]);
     }
     const dependencyAddresses = [
@@ -802,17 +806,17 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
     if (current.get(options.loot) !== undefined) {
         fail(`Loot account ${options.loot} already exists. Generate a new unused Loot signer address and retry.`, options.loot);
     }
-    const attackerAccount = await validateCurrentAttackFleet(attacker, current.get(attacker.address));
-    validateAttackerReadiness(attacker, attackerAccount, current.get(CLOCK_ADDRESS));
+    const attackerAccount = await validateCurrentAttackFleet(ctx.programs, attacker, current.get(attacker.address));
+    validateAttackerReadiness(ctx.programs, attacker, attackerAccount, current.get(CLOCK_ADDRESS));
     const systemAccount = requireAccount(current.get(target.address), target.address, `Target Star System ${target.name} (${target.address}) is missing. Refresh world state and retry the attack.`);
-    const currentSystem = starSystemAccountDefinition.decode(systemAccount);
-    if ((await deriveStarSystemAddress(currentSystem.game, currentSystem.systemId)) !== target.address ||
+    const currentSystem = starSystemAccountDefinition.decode(systemAccount, ctx.programs);
+    if ((await deriveStarSystemAddress(ctx.programs, currentSystem.game, currentSystem.systemId)) !== target.address ||
         systemFingerprint({ ...currentSystem, address: systemAccount.address }) !==
             systemFingerprint(target)) {
         fail(`Target Star System ${target.name} (${target.address}) changed or does not match its canonical Game, identity, sequence, or shared Starbase state. Refresh the target and retry.`, target.address);
     }
     const relationsAccount = requireAccount(current.get(relationTrackerAddress), relationTrackerAddress, `FactionRelationTracker ${relationTrackerAddress} is missing. Refresh faction relationships and retry.`);
-    const relations = factionRelationTrackerAccountDefinition.decode(relationsAccount);
+    const relations = factionRelationTrackerAccountDefinition.decode(relationsAccount, ctx.programs);
     if (relations.game !== game ||
         relations.dynamicCaptureEnabled !== probeRelations.dynamicCaptureEnabled ||
         relations.nemesisActive !== probeRelations.nemesisActive) {
@@ -823,7 +827,7 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
         : undefined;
     const ownership = ownershipAccount === undefined
         ? undefined
-        : factionOwnershipAccountDefinition.decode(ownershipAccount);
+        : factionOwnershipAccountDefinition.decode(ownershipAccount, ctx.programs);
     if (ownership === undefined && relations.dynamicCaptureEnabled) {
         fail(`Target Starbase ${target.address} requires canonical FactionOwnership while dynamic capture is enabled. Refresh Starbase ownership and retry.`, ownershipAddress);
     }
@@ -838,20 +842,20 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
     }
     const effectiveOwner = ownership?.controllingFactionId ?? legacyOwner;
     const registryAccount = requireAccount(current.get(registryAddress), registryAddress, `AtlasRewardRegistry ${registryAddress} is missing. Refresh reward configuration and retry.`);
-    const registry = atlasRewardRegistryAccountDefinition.decode(registryAccount);
+    const registry = atlasRewardRegistryAccountDefinition.decode(registryAccount, ctx.programs);
     if (registry.game !== game ||
         registry.activeConfigVersion !== probeRegistry.activeConfigVersion) {
         fail(`AtlasRewardRegistry ${registryAddress} changed or belongs to another Game. Refresh the configured reward registry and retry.`, registryAddress);
     }
     const rewardConfigAccount = requireAccount(current.get(rewardConfigAddress), rewardConfigAddress, `AtlasRewardConfig ${rewardConfigAddress} is missing. Refresh reward configuration and retry.`);
-    const rewardConfig = atlasRewardConfigAccountDefinition.decode(rewardConfigAccount);
+    const rewardConfig = atlasRewardConfigAccountDefinition.decode(rewardConfigAccount, ctx.programs);
     if (rewardConfig.game !== game ||
         rewardConfig.configVersion !== registry.activeConfigVersion ||
         rewardConfig.effectiveEpoch > registry.currentEpoch) {
         fail(`AtlasRewardConfig ${rewardConfigAddress} does not match the configured Game and active registry version or is not yet effective for the current epoch. Refresh reward configuration and retry.`, rewardConfigAddress);
     }
     const kingAccount = requireAccount(current.get(kingTracker), kingTracker, `KingSystemTracker ${kingTracker} is missing. Refresh King-system ownership and retry.`);
-    const king = kingSystemTrackerAccountDefinition.decode(kingAccount);
+    const king = kingSystemTrackerAccountDefinition.decode(kingAccount, ctx.programs);
     const kingTarget = king.systems.find(({ systemId }) => systemId === currentSystem.systemId);
     if (king.game !== game ||
         kingTarget === undefined ||
@@ -859,19 +863,19 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
         fail(`KingSystemTracker ${kingTracker} does not contain target System ${String(currentSystem.systemId)} with its current effective owner ${String(effectiveOwner)}. Refresh King-system ownership and retry.`, kingTracker);
     }
     const characterAccount = requireAccount(current.get(character), character, `Character ${character} is missing for Profile ${attacker.ownerProfile.address}. Refresh the Profile Character registration and retry.`);
-    const characterData = characterAccountDefinition.decode(characterAccount);
+    const characterData = characterAccountDefinition.decode(characterAccount, ctx.programs);
     if (characterData.game !== game ||
         characterData.playerProfile !== attacker.ownerProfile.address) {
         fail(`Character ${character} does not match Profile ${attacker.ownerProfile.address} and configured Game ${game}. Refresh the Profile Character registration and retry.`, character);
     }
     const regionTrackerAccount = requireAccount(current.get(regionTracker), regionTracker, `RegionTracker ${regionTracker} is missing for configured Game ${game}. Refresh world region data and retry.`);
-    const regionTrackerData = regionTrackerAccountDefinition.decode(regionTrackerAccount);
+    const regionTrackerData = regionTrackerAccountDefinition.decode(regionTrackerAccount, ctx.programs);
     if (regionTrackerData.game !== game) {
         fail(`RegionTracker ${regionTracker} does not match configured Game ${game}. Refresh world region data and retry.`, regionTracker);
     }
     // The attack reads the target's stored Region. When the Region map agrees,
     // guard only that Region's access data; otherwise keep the whole tracker.
-    const regionAccess = (await regionsContainingSystem(regionTrackerAccount, systemAccount, game))
+    const regionAccess = (await regionsContainingSystem(ctx.programs, regionTrackerAccount, systemAccount, game))
         .map(({ id }) => id)
         .join() === String(currentSystem.regionId ?? '')
         ? {
@@ -879,14 +883,14 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
             address: regionTracker,
             game,
             system: target.address,
-            accessHash: await hashRegionAccess(regionTrackerAccount, systemAccount, game),
+            accessHash: await hashRegionAccess(ctx.programs, regionTrackerAccount, systemAccount, game),
             describes: `The Region holding target Star System ${target.name} keeps its owner, safety status and risk zone; other Regions may change.`,
         }
         : undefined;
     const crewBindingAccount = current.get(crewBindingAddress);
     const crewBinding = crewBindingAccount === undefined ? undefined : crewBindingAddress;
     if (crewBindingAccount !== undefined) {
-        const data = fleetCrewBindingAccountDefinition.decode(crewBindingAccount);
+        const data = fleetCrewBindingAccountDefinition.decode(crewBindingAccount, ctx.programs);
         if (!matchesFleetCrewBindingIdentity(data, attacker.address, attacker.ownerProfile.address)) {
             fail(`FleetCrewBinding ${crewBindingAddress} does not belong to Fleet ${attacker.address} and Profile ${attacker.ownerProfile.address}. Refresh the Fleet crew relationship and retry.`, crewBindingAddress);
         }
@@ -896,8 +900,8 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
     if (factionEconomicsConfig !== undefined && captorTreasury !== undefined) {
         economicsAccount = requireAccount(current.get(factionEconomicsConfig), factionEconomicsConfig, `FactionEconomicsConfig ${factionEconomicsConfig} is missing. Refresh faction economics and retry.`);
         treasuryAccount = requireAccount(current.get(captorTreasury), captorTreasury, `FactionTreasury ${captorTreasury} is missing. Refresh the captor treasury and retry.`);
-        const economics = factionEconomicsConfigAccountDefinition.decode(economicsAccount);
-        const treasury = factionTreasuryAccountDefinition.decode(treasuryAccount);
+        const economics = factionEconomicsConfigAccountDefinition.decode(economicsAccount, ctx.programs);
+        const treasury = factionTreasuryAccountDefinition.decode(treasuryAccount, ctx.programs);
         if (economics.game !== game) {
             fail(`FactionEconomicsConfig ${factionEconomicsConfig} belongs to another Game. Refresh faction economics and retry.`, factionEconomicsConfig);
         }
@@ -990,11 +994,11 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
         mode: 'starbase-attack',
         game,
         system: target.address,
-        starbaseSeqId: starSystemAccountDefinition.decode(systemAccount).sequenceId,
+        starbaseSeqId: starSystemAccountDefinition.decode(systemAccount, ctx.programs).sequenceId,
         character,
     });
     const description = `Attack with Fleet ${attacker.name} (${attacker.address}) against the shared Starbase at ${target.name} (${target.address}) using ${stance.ammoUsage} ammunition; range, capture-cost debit outcome, randomness, rewards, Loot, damage, and final admissibility remain chain-authoritative.`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'combat.attack-starbase',
         preconditions: [
             ...statePreconditions,
@@ -1006,7 +1010,7 @@ export async function planFleetAttackStarbase(ctx, attacker, target, inputStance
         steps: [
             {
                 describes: `${description} ${runtime.description}`,
-                instruction: adaptAttackStarbaseInstruction({
+                instruction: adaptAttackStarbaseInstruction(ctx.programs, {
                     ...runtime.accounts,
                     ...(attackerNpc.faction === undefined
                         ? {}
@@ -1130,8 +1134,8 @@ export async function planFleetRetrieveLoot(ctx, fleet, loot, inputWant, inputOp
     const selection = validateLootSelection(inputWant, loot, fleet, options.authorization.profile, options.atUnixSeconds);
     const [fleetAccountValue, lootAccountValue] = await readContextRawAccounts(ctx, [fleet.address, loot.address]);
     const fleetAccount = requireAccount(fleetAccountValue, fleet.address, `Fleet ${fleet.name} (${fleet.address}) is missing. Refresh Fleet discovery and retry retrieving Loot.`);
-    const currentFleet = fleetAccountDefinition.decode(fleetAccount);
-    if ((await deriveFleetAddress(currentFleet)) !== fleet.address ||
+    const currentFleet = fleetAccountDefinition.decode(fleetAccount, ctx.programs);
+    if ((await deriveFleetAddress(ctx.programs, currentFleet)) !== fleet.address ||
         currentFleet.game !== fleet.game ||
         currentFleet.ownerProfile !== fleet.ownerProfile.address ||
         currentFleet.name !== fleet.name ||
@@ -1147,7 +1151,7 @@ export async function planFleetRetrieveLoot(ctx, fleet, loot, inputWant, inputOp
         fail(`Fleet ${fleet.name} (${fleet.address}) has no usable ability power at ${String(options.atUnixSeconds)} Unix seconds: stored AP ${String(currentFleet.ap)} with reload completing at ${String(currentFleet.apReloadExpiresAt)}. Retrieving Loot spends the whole AP pool; wait for the reload, refresh the Fleet, and retry.`, fleet.address);
     }
     const lootAccount = requireAccount(lootAccountValue, loot.address, `Loot ${loot.address} is no longer available. Refresh Loot discovery and choose an available account before retrying.`);
-    const currentLoot = lootAccountDefinition.decode(lootAccount);
+    const currentLoot = lootAccountDefinition.decode(lootAccount, ctx.programs);
     if (rawLootFingerprint(lootAccount.address, currentLoot) !==
         lootSnapshotFingerprint(loot)) {
         fail(`Loot ${loot.address} changed or no longer matches its loaded identity, Profile, coordinates, exclusivity, or known inventory. Refresh the Loot snapshot and retry.`, loot.address);
@@ -1155,7 +1159,7 @@ export async function planFleetRetrieveLoot(ctx, fleet, loot, inputWant, inputOp
     const lootCreator = loot.profile.address === options.authorization.profile
         ? undefined
         : loot.profile.address;
-    const instruction = adaptRetrieveLootInstruction({
+    const instruction = adaptRetrieveLootInstruction(ctx.programs, {
         authorization: options.authorization,
         fleet: fleet.address,
         game,
@@ -1171,7 +1175,7 @@ export async function planFleetRetrieveLoot(ctx, fleet, loot, inputWant, inputOp
     // Profile vault before the emptied Loot refunds its rent.
     const storage = await planFleetStorage(ctx, instruction, [fleetAccount.address], options.authorization.profile, 'Loot retrieval');
     const description = `Request ${selection.summary} from Loot ${loot.address} with Fleet ${fleet.name} (${fleet.address}); this spends the Fleet's whole ability power pool. Range, recent-slot randomness, cargo capacity, availability races, and final transfer quantities remain chain-authoritative. ${storage.disclosure}`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'combat.retrieve-loot',
         preconditions: [
             await accountStatePrecondition(fleetAccount, `Fleet ${fleet.name} retains its configured Game, owning Profile, idle state, and normalized crew.`),
@@ -1195,8 +1199,8 @@ async function planFleetStorage(ctx, instruction, addresses, profile, label, sti
     const all = [...addresses, profile, RENT_ADDRESS];
     const rows = await readContextRawAccounts(ctx, all);
     const accounts = new Map(all.map((address, index) => [address, rows[index]]));
-    return planStorageFunding({
-        action: readCombatStorageAction(instruction, accounts, stimulantStats),
+    return planStorageFunding(ctx.programs, {
+        action: readCombatStorageAction(ctx.programs, instruction, accounts, stimulantStats),
         accounts,
         label,
     });