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

package/dist/claim-stakes/actions/index.js

@@ -298,11 +298,11 @@ export async function planPlaceClaimStake(ctx, body, player, input) {
     if (body.game !== game) {
         fail(`Celestial Body ${body.address} does not match the configured Game ${game}. Refresh the Body through this context and retry.`, body.address);
     }
-    const canonicalBody = await deriveCelestialBodyAddress(game, body.id);
+    const canonicalBody = await deriveCelestialBodyAddress(ctx.programs, game, body.id);
     if (canonicalBody !== body.address) {
         fail(`Celestial Body ${body.address} is not the canonical Body ${String(body.id)} for the configured Game. Refresh the Body and retry.`, body.address);
     }
-    const character = await requireProfileStarbasePlayer(player, options.authorization.profile, game);
+    const character = await requireProfileStarbasePlayer(ctx.programs, player, options.authorization.profile, game);
     if (body.system.address !== player.system.address) {
         fail(`Celestial Body ${body.address} belongs to System ${body.system.address}, but Starbase Player ${player.address} belongs to System ${player.system.address}. Choose both snapshots from the same System and retry.`, body.address);
     }
@@ -348,11 +348,11 @@ export async function planPlaceClaimStake(ctx, body, player, input) {
     const currentBodyAccount = requireAccount(bodyAccount, body.address, `Celestial Body ${body.address} is missing. Refresh the Body and retry placement.`);
     const currentPlayerAccount = requireAccount(playerAccount, player.address, `Starbase Player ${player.address} is missing. Refresh it and retry placement.`);
     const currentSystemAccount = requireAccount(systemAccount, body.system.address, `Star System ${body.system.address} is missing. Refresh the System and retry placement.`);
-    const currentBody = celestialBodyAccountDefinition.decode(currentBodyAccount);
-    const currentPlayer = starbasePlayerAccountDefinition.decode(currentPlayerAccount);
-    const { account: currentCharacterAccount, current: currentCharacter } = requireProfileCharacter(characterAccount, character, options.authorization.profile, game, 'placement');
-    const currentSystem = starSystemAccountDefinition.decode(currentSystemAccount);
-    const canonicalSystem = await deriveStarSystemAddress(game, currentSystem.systemId);
+    const currentBody = celestialBodyAccountDefinition.decode(currentBodyAccount, ctx.programs);
+    const currentPlayer = starbasePlayerAccountDefinition.decode(currentPlayerAccount, ctx.programs);
+    const { account: currentCharacterAccount, current: currentCharacter } = requireProfileCharacter(ctx.programs, characterAccount, character, options.authorization.profile, game, 'placement');
+    const currentSystem = starSystemAccountDefinition.decode(currentSystemAccount, ctx.programs);
+    const canonicalSystem = await deriveStarSystemAddress(ctx.programs, game, currentSystem.systemId);
     if (canonicalSystem !== body.system.address ||
         currentSystem.game !== game ||
         currentSystem.starbase === undefined) {
@@ -406,9 +406,9 @@ export async function planPlaceClaimStake(ctx, body, player, input) {
     const rentDeposit = options.initialRentAmount ?? 0n;
     if (currentCharacter.atlasRaw < placementFee + rentDeposit)
         fail(`Character ${character} has ${String(currentCharacter.atlasRaw)} raw ATLAS, below the ${String(placementFee)} raw placement fee plus ${String(rentDeposit)} raw initial rent. Add ATLAS or lower the rent, then retry.`, character);
-    const profileFaction = await deriveProfileFactionAddress(options.authorization.profile);
-    const currencyCache = await deriveCurrencyCache(game).then(([address]) => address);
-    const instruction = adaptPlaceClaimStakeInstruction({
+    const profileFaction = await deriveProfileFactionAddress(ctx.programs, options.authorization.profile);
+    const currencyCache = await deriveCurrencyCache(ctx.programs, game).then(([address]) => address);
+    const instruction = adaptPlaceClaimStakeInstruction(ctx.programs, {
         authorization: options.authorization,
         celestialBody: body.address,
         character,
@@ -426,7 +426,7 @@ export async function planPlaceClaimStake(ctx, body, player, input) {
     // The new stake and the claimed plot are funded from the Profile vault.
     const storage = await planClaimStakeStorage(ctx, instruction, options.authorization.profile, [freshGame.account, currentBodyAccount, currentSystemAccount], 'Claim Stake placement');
     const description = `Place ${definition.name} on Planet ${body.name} (${body.address}) with bundled hub ${hub.name}, ${String(hub.neededCrew)} crew, a ${String(placementFee)} raw ATLAS placement fee and ${String(rentDeposit)} raw initial rent. ${storage.disclosure}`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'claim-stakes.place',
         preconditions: [
             ...(await Promise.all([
@@ -462,8 +462,8 @@ async function planClaimStakeStorage(ctx, instruction, profile, known, label) {
         [profile, profileAccount],
         [RENT_ADDRESS, rentAccount],
     ]);
-    return planStorageFunding({
-        action: readClaimStakeStorageAction(instruction, accounts),
+    return planStorageFunding(ctx.programs, {
+        action: readClaimStakeStorageAction(ctx.programs, instruction, accounts),
         accounts,
         label,
     });
@@ -512,14 +512,14 @@ function requireCommittedCrewVersion(current, stake, outcome) {
 // `action` completes the shared remedies ("retry <action>").
 /** Requires the loaded Claim Stake to belong to the configured Game and to the
  * authorization Profile, and returns that Profile's canonical Character. */
-async function requireOwnedStake(stake, game, profile) {
+async function requireOwnedStake(programs, stake, game, profile) {
     if (stake.game !== game) {
         fail(`Claim Stake ${stake.address} does not match the configured Game ${game}. Refresh it through this context and retry.`, stake.address);
     }
     if (stake.ownerProfile.address !== profile) {
         fail(`Claim Stake ${stake.address} belongs to Profile ${stake.ownerProfile.address}, not authorization Profile ${profile}. Choose a Claim Stake this Profile owns, refresh it, and retry.`, stake.address);
     }
-    return findCharacterPda(profile, game);
+    return findCharacterPda(programs, profile, game);
 }
 /** Reads and decodes the fresh Claim Stake and Body, with `extra` accounts in
  * the same batch. */
@@ -533,8 +533,8 @@ async function readOwnedStake(ctx, stake, action, extra = []) {
     const bodyAccount = requireAccount(bodyCandidate, stake.body.address, `Celestial Body ${stake.body.address} is missing. Refresh the Claim Stake Body and retry ${action}.`);
     return {
         bodyAccount,
-        currentBody: celestialBodyAccountDefinition.decode(bodyAccount),
-        currentStake: claimStakeAccountDefinition.decode(stakeAccount),
+        currentBody: celestialBodyAccountDefinition.decode(bodyAccount, ctx.programs),
+        currentStake: claimStakeAccountDefinition.decode(stakeAccount, ctx.programs),
         extraAccounts,
         stakeAccount,
     };
@@ -586,11 +586,11 @@ function sameTransferFleet(current, fleet, game, profile) {
 }
 /** Requires the fresh Body to be the Claim Stake's canonical Planet in the
  * configured Game at the Claim Stake's System generation. */
-async function requireStakePlanet(currentBody, stake, game, action) {
+async function requireStakePlanet(programs, currentBody, stake, game, action) {
     if (currentBody.kind !== 'planet' ||
         currentBody.game !== game ||
         currentBody.systemSequenceId !== stake.systemSeqId ||
-        (await deriveCelestialBodyAddress(game, currentBody.id)) !==
+        (await deriveCelestialBodyAddress(programs, game, currentBody.id)) !==
             stake.body.address) {
         fail(`Celestial Body ${stake.body.address} does not match the Claim Stake's configured Game, canonical Planet identity, or System generation. Refresh the Body and Claim Stake before retrying ${action}.`, stake.body.address);
     }
@@ -611,16 +611,16 @@ function requireStakeRegistered(claimedPlots, stake, starbaseLevel, action) {
 /** {@link requireStakePlanet} for building changes. An eviction is reported
  * first: a takeover or destruction also advances the System generation, which
  * would otherwise hide the real cause behind a refresh remedy. */
-async function requireDesignStakePlanet(currentBody, stake, game, action) {
+async function requireDesignStakePlanet(programs, currentBody, stake, game, action) {
     if (currentBody.kind === 'planet')
         requireStakeRegistered(currentBody.details.claimedPlots, stake, 'css', action);
-    return requireStakePlanet(currentBody, stake, game, action);
+    return requireStakePlanet(programs, currentBody, stake, game, action);
 }
 /** Requires and decodes the canonical Character of the authorization Profile in
  * the configured Game. */
-function requireProfileCharacter(candidate, character, profile, game, action) {
+function requireProfileCharacter(programs, candidate, character, profile, game, action) {
     const account = requireAccount(candidate, character, `Canonical Character ${character} is missing. Refresh the Profile Character and retry ${action}.`);
-    const current = characterAccountDefinition.decode(account);
+    const current = characterAccountDefinition.decode(account, programs);
     if (current.playerProfile !== profile || current.game !== game) {
         fail(`Character ${character} does not match authorization Profile ${profile} and configured Game ${game}. Refresh the Character and retry ${action}.`, character);
     }
@@ -631,17 +631,17 @@ function requireProfileCharacter(candidate, character, profile, game, action) {
  * canonical, current System with an active Starbase that lists the Body, and a
  * Starbase Player of the Profile, Character and System. */
 async function readStakeStarbase(ctx, stake, game, system, character, profile, action, extra = []) {
-    const player = await deriveStarbasePlayerAddress(system, character);
+    const player = await deriveStarbasePlayerAddress(ctx.programs, system, character);
     const [systemCandidate, playerCandidate, ...extraAccounts] = await readContextRawAccounts(ctx, [system, player, ...extra]);
     const systemAccount = requireAccount(systemCandidate, system, `Star System ${system} is missing. Refresh the Claim Stake's System and retry ${action}.`);
     const playerAccount = requireAccount(playerCandidate, player, `Starbase Player ${player} is missing for authorization Profile ${profile}. Register or refresh it in the Claim Stake's System before retrying ${action}.`);
-    const currentSystem = starSystemAccountDefinition.decode(systemAccount);
-    const currentPlayer = starbasePlayerAccountDefinition.decode(playerAccount);
+    const currentSystem = starSystemAccountDefinition.decode(systemAccount, ctx.programs);
+    const currentPlayer = starbasePlayerAccountDefinition.decode(playerAccount, ctx.programs);
     if (currentSystem.game !== game ||
         currentSystem.sequenceId !== stake.systemSeqId ||
         currentSystem.starbase === undefined ||
         !currentSystem.celestialBodyAddresses.includes(stake.body.address) ||
-        (await deriveStarSystemAddress(game, currentSystem.systemId)) !== system) {
+        (await deriveStarSystemAddress(ctx.programs, game, currentSystem.systemId)) !== system) {
         fail(`Star System ${system} does not match the configured Game, canonical identity, Claim Stake generation, active nested Starbase, or Claim Stake Body relationship. Refresh the System and retry ${action}.`, system);
     }
     if (currentPlayer.playerProfile !== profile ||
@@ -659,13 +659,13 @@ async function readStakeStarbase(ctx, stake, game, system, character, profile, a
         systemAccount,
     };
 }
-async function claimStakeCurrencyCache(game) {
-    const [currencyCache] = await deriveCurrencyCache(game);
+async function claimStakeCurrencyCache(programs, game) {
+    const [currencyCache] = await deriveCurrencyCache(programs, game);
     return currencyCache;
 }
 /** Requires the canonical CurrencyCache and returns its Plan guard. */
-async function requireCurrencyCache(candidate, currencyCache, game, action, planName) {
-    await validateCurrencyCache(requireAccount(candidate, currencyCache, `Canonical CurrencyCache ${currencyCache} is missing for configured Game ${game}. Refresh the Game currency configuration and retry ${action}.`), game, planName);
+async function requireCurrencyCache(programs, candidate, currencyCache, game, action, planName) {
+    await validateCurrencyCache(programs, requireAccount(candidate, currencyCache, `Canonical CurrencyCache ${currencyCache} is missing for configured Game ${game}. Refresh the Game currency configuration and retry ${action}.`), game, planName);
     return {
         kind: 'currency-cache',
         address: currencyCache,
@@ -729,7 +729,7 @@ export async function planClaimStakeBuildingChanges(ctx, stake, input) {
     if (stake.state.kind === 'deactivated') {
         fail(`Claim Stake ${stake.address} is deactivated; building changes require an active or design Claim Stake. Refresh it or choose another owned Claim Stake before retrying.`, stake.address);
     }
-    const character = await requireOwnedStake(stake, game, profile);
+    const character = await requireOwnedStake(ctx.programs, stake, game, profile);
     const action = 'building changes';
     const [freshGame, loaded, rent] = await Promise.all([
         readFreshGameClaimStakeConfiguration(ctx),
@@ -747,17 +747,17 @@ export async function planClaimStakeBuildingChanges(ctx, stake, input) {
     if (currentStake.constructionRemainingSeconds > 0n) {
         fail(`Claim Stake ${stake.address} records ${String(currentStake.constructionRemainingSeconds)} seconds of construction remaining, and a stake under construction cannot change its buildings. The stored time advances only when a production tick processes the stake: wait for construction to finish, let a production tick record it, refresh the Claim Stake, and retry.`, stake.address);
     }
-    const planetBody = await requireDesignStakePlanet(loaded.currentBody, stake, game, action);
+    const planetBody = await requireDesignStakePlanet(ctx.programs, loaded.currentBody, stake, game, action);
     const { system } = planetBody;
-    const { account: characterAccount } = requireProfileCharacter(loaded.extraAccounts[0], character, profile, game, action);
+    const { account: characterAccount } = requireProfileCharacter(ctx.programs, loaded.extraAccounts[0], character, profile, game, action);
     const [ownership, profileFaction] = await Promise.all([
-        deriveFactionOwnershipAddress(game, 'starbase', system),
-        deriveProfileFactionAddress(profile),
+        deriveFactionOwnershipAddress(ctx.programs, game, 'starbase', system),
+        deriveProfileFactionAddress(ctx.programs, profile),
     ]);
     const { currentPlayer, currentSystem, extraAccounts: [ownershipAccount, profileFactionCandidate], player, playerAccount, starbase, systemAccount, } = await readStakeStarbase(ctx, stake, game, system, character, profile, action, [ownership, profileFaction]);
     requireStakeRegistered(planetBody.details.claimedPlots, stake, starbase.level, action);
     const profileFactionAccount = requireAccount(profileFactionCandidate, profileFaction, `ProfileFaction ${profileFaction} is missing for authorization Profile ${profile}. Choose or repair the Profile faction, refresh it, and retry building changes.`);
-    const currentProfileFaction = profileFactionIdentityAccountDefinition.decode(profileFactionAccount);
+    const currentProfileFaction = profileFactionIdentityAccountDefinition.decode(profileFactionAccount, ctx.programs);
     if (currentProfileFaction.profile !== profile) {
         fail(`ProfileFaction ${profileFaction} does not match authorization Profile ${profile}. Refresh or repair the Profile faction before retrying building changes.`, profileFaction);
     }
@@ -767,7 +767,7 @@ export async function planClaimStakeBuildingChanges(ctx, stake, input) {
         ownershipPrecondition = accountAbsentPrecondition(ownership, `The canonical Starbase FactionOwnership ${ownership} remains unallocated so the chain applies its legacy controller gate.`);
     }
     else {
-        const currentOwnership = factionOwnershipAccountDefinition.decode(ownershipAccount);
+        const currentOwnership = factionOwnershipAccountDefinition.decode(ownershipAccount, ctx.programs);
         if (currentOwnership.game !== game ||
             currentOwnership.asset.kind !== 'starbase' ||
             currentOwnership.asset.system !== system ||
@@ -920,9 +920,9 @@ export async function planClaimStakeBuildingChanges(ctx, stake, input) {
     if (currentStake.production.cargoPod.storageCost > resourceStorageRaw) {
         fail(`The resulting Claim Stake design provides ${String(resourceStorageRaw)} raw storage capacity, below the fresh known cargo usage of ${String(currentStake.production.cargoPod.storageCost)}. Keep enough storage buildings, remove cargo, refresh the Claim Stake, and retry building changes.`, stake.address);
     }
-    const currencyCache = await claimStakeCurrencyCache(game);
+    const currencyCache = await claimStakeCurrencyCache(ctx.programs, game);
     const xp = await resolveClaimStakeXp(ctx, game, stake.address);
-    const instruction = adaptClaimStakeBuildingChangesInstruction({
+    const instruction = adaptClaimStakeBuildingChangesInstruction(ctx.programs, {
         ...xp.accounts,
         authorization: options.authorization,
         buildingChanges: options.buildingChanges.map(({ buildingId, kind, quantity }) => [buildingId, kind === 'add' ? quantity : -quantity]),
@@ -940,7 +940,7 @@ export async function planClaimStakeBuildingChanges(ctx, stake, input) {
     // The grown design is funded from the Profile vault.
     const storage = await planClaimStakeStorage(ctx, instruction, profile, [stakeAccount], 'Claim Stake building changes');
     const description = `Change buildings on Claim Stake ${stake.address}: ${descriptions.join('; ')}. ${storage.disclosure}`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'claim-stakes.building-changes',
         preconditions: [
             ...(await Promise.all([
@@ -1007,7 +1007,7 @@ export async function planFinalizeClaimStakeBuildingChanges(ctx, stake, input) {
     if (stake.state.kind !== 'design') {
         fail(`Claim Stake ${stake.address} is not in design state. Refresh it and finalize only a pending building design.`, stake.address);
     }
-    const character = await requireOwnedStake(stake, game, profile);
+    const character = await requireOwnedStake(ctx.programs, stake, game, profile);
     if (stake.rentBalanceRaw <= 0n) {
         fail(`Claim Stake ${stake.address} has a known delinquent rent balance of ${String(stake.rentBalanceRaw)} raw units. Top up rent, refresh the Claim Stake, and retry finalization.`, stake.address);
     }
@@ -1033,16 +1033,16 @@ export async function planFinalizeClaimStakeBuildingChanges(ctx, stake, input) {
         fail(`Claim Stake ${stake.address} changed or does not match its loaded ownership, Body, definitions, buildings, design sequence, rent, or System generation. Refresh it and retry finalization.`, stake.address);
     }
     requireCommittedCrewVersion(currentStake, stake, 'finalized');
-    const planet = await requireDesignStakePlanet(loaded.currentBody, stake, game, action);
+    const planet = await requireDesignStakePlanet(ctx.programs, loaded.currentBody, stake, game, action);
     const { system } = planet;
-    const { account: characterAccount } = requireProfileCharacter(loaded.extraAccounts[0], character, profile, game, action);
-    const currencyCache = await claimStakeCurrencyCache(game);
+    const { account: characterAccount } = requireProfileCharacter(ctx.programs, loaded.extraAccounts[0], character, profile, game, action);
+    const currencyCache = await claimStakeCurrencyCache(ctx.programs, game);
     const { currentSystem, extraAccounts: [currencyCandidate], player, playerAccount, starbase, systemAccount, } = await readStakeStarbase(ctx, stake, game, system, character, profile, action, [currencyCache]);
     requireStakeRegistered(planet.details.claimedPlots, stake, starbase.level, action);
-    const currencyGuard = await requireCurrencyCache(currencyCandidate, currencyCache, game, action, 'Claim Stake finalization');
+    const currencyGuard = await requireCurrencyCache(ctx.programs, currencyCandidate, currencyCache, game, action, 'Claim Stake finalization');
     const description = `Finalize building changes on Claim Stake ${stake.address}. A building refund that opens a Starbase Player cargo line, or a new resource that raises the stake's rent floor, is funded from the Profile vault with the signing key, which this Plan does not bound; simulate before signing.`;
     const xp = await resolveClaimStakeXp(ctx, game, stake.address, character);
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'claim-stakes.finalize-building-changes',
         preconditions: [
             xp.guard,
@@ -1060,7 +1060,7 @@ export async function planFinalizeClaimStakeBuildingChanges(ctx, stake, input) {
         steps: [
             {
                 describes: description,
-                instruction: adaptFinalizeClaimStakeBuildingChangesInstruction({
+                instruction: adaptFinalizeClaimStakeBuildingChangesInstruction(ctx.programs, {
                     ...xp.accounts,
                     authorization: options.authorization,
                     celestialBody: stake.body.address,
@@ -1111,7 +1111,7 @@ export async function planCancelClaimStakeBuildingChanges(ctx, stake, input) {
     if (stake.state.kind !== 'design') {
         fail(`Claim Stake ${stake.address} is not in design state. Refresh it and cancel only a pending building design.`, stake.address);
     }
-    const character = await requireOwnedStake(stake, game, profile);
+    const character = await requireOwnedStake(ctx.programs, stake, game, profile);
     const action = 'cancellation';
     const [{ bodyAccount, currentBody, currentStake, stakeAccount }, rent] = await Promise.all([
         readOwnedStake(ctx, stake, action),
@@ -1123,15 +1123,15 @@ export async function planCancelClaimStakeBuildingChanges(ctx, stake, input) {
         !sameQuantities(currentStake.state.buildings, stake.state.buildings)) {
         fail(`Claim Stake ${stake.address} changed or does not match its loaded ownership, Body, definitions, buildings, design sequence, or System generation. Refresh it and retry cancellation.`, stake.address);
     }
-    const planet = await requireDesignStakePlanet(currentBody, stake, game, action);
+    const planet = await requireDesignStakePlanet(ctx.programs, currentBody, stake, game, action);
     const { system } = planet;
-    const currencyCache = await claimStakeCurrencyCache(game);
+    const currencyCache = await claimStakeCurrencyCache(ctx.programs, game);
     const { currentSystem, extraAccounts: [currencyCandidate], player, playerAccount, starbase, systemAccount, } = await readStakeStarbase(ctx, stake, game, system, character, profile, action, [currencyCache]);
     requireStakeRegistered(planet.details.claimedPlots, stake, starbase.level, action);
-    const currencyGuard = await requireCurrencyCache(currencyCandidate, currencyCache, game, action, 'Claim Stake cancellation');
+    const currencyGuard = await requireCurrencyCache(ctx.programs, currencyCandidate, currencyCache, game, action, 'Claim Stake cancellation');
     const description = `Cancel the pending building design on Claim Stake ${stake.address} and return it to active state.`;
     const xp = await resolveClaimStakeXp(ctx, game, stake.address);
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'claim-stakes.cancel-building-changes',
         preconditions: [
             xp.guard,
@@ -1147,7 +1147,7 @@ export async function planCancelClaimStakeBuildingChanges(ctx, stake, input) {
         steps: [
             {
                 describes: description,
-                instruction: adaptCancelClaimStakeBuildingChangesInstruction({
+                instruction: adaptCancelClaimStakeBuildingChangesInstruction(ctx.programs, {
                     ...xp.accounts,
                     authorization: options.authorization,
                     celestialBody: stake.body.address,
@@ -1195,7 +1195,7 @@ export async function planDeconstructClaimStake(ctx, stake, input) {
     if (stake.state.kind !== 'active') {
         fail(`Claim Stake ${stake.address} is not in active state. Refresh it, finalize or cancel any pending design, and retry deconstruction.`, stake.address);
     }
-    const character = await requireOwnedStake(stake, game, profile);
+    const character = await requireOwnedStake(ctx.programs, stake, game, profile);
     const action = 'deconstruction';
     const [freshGame, { bodyAccount, currentBody, currentStake, stakeAccount }, rent,] = await Promise.all([
         readFreshGameClaimStakeConfiguration(ctx),
@@ -1210,7 +1210,7 @@ export async function planDeconstructClaimStake(ctx, stake, input) {
         fail(`Claim Stake ${stake.address} changed or does not match its loaded ownership, Body, definitions, buildings, active state, or System generation. Refresh it and retry deconstruction.`, stake.address);
     }
     requireCommittedCrewVersion(currentStake, stake, 'deconstructed');
-    const planet = await requireStakePlanet(currentBody, stake, game, action);
+    const planet = await requireStakePlanet(ctx.programs, currentBody, stake, game, action);
     const { system } = planet;
     if (freshGame.data.claimStakes.sequenceId !== stake.claimStakeDefinitionSeqId) {
         fail(`Claim Stake ${stake.address} definition generation is stale against the current Game catalog. Refresh the Claim Stake and definitions to rule out stale local data. If the on-chain generation still differs, use a Claim Stake matching the current catalog before retrying deconstruction.`, stake.address);
@@ -1265,12 +1265,12 @@ export async function planDeconstructClaimStake(ctx, stake, input) {
     }
     const claimStakeLevel = CLAIM_STAKE_PLOT_LEVELS[row];
     const [currencyCache, [xpAccrual]] = await Promise.all([
-        claimStakeCurrencyCache(game),
-        deriveStructureXpAccrualAddress(stake.address),
+        claimStakeCurrencyCache(ctx.programs, game),
+        deriveStructureXpAccrualAddress(ctx.programs, stake.address),
     ]);
     const { currentSystem, extraAccounts: [characterCandidate, currencyCandidate, ledgerCandidate], player, playerAccount, systemAccount, } = await readStakeStarbase(ctx, stake, game, system, character, profile, action, [character, currencyCache, xpAccrual]);
-    const { account: characterAccount } = requireProfileCharacter(characterCandidate, character, profile, game, action);
-    const currencyGuard = await requireCurrencyCache(currencyCandidate, currencyCache, game, action, 'Claim Stake deconstruction');
+    const { account: characterAccount } = requireProfileCharacter(ctx.programs, characterCandidate, character, profile, game, action);
+    const currencyGuard = await requireCurrencyCache(ctx.programs, currencyCandidate, currencyCache, game, action, 'Claim Stake deconstruction');
     // Deconstruction closes an existing XP ledger; a stake without one accrued nothing.
     const xp = ledgerCandidate === undefined
         ? {
@@ -1279,7 +1279,7 @@ export async function planDeconstructClaimStake(ctx, stake, input) {
         }
         : await resolveClaimStakeXp(ctx, game, stake.address, character);
     const description = `Deconstruct Claim Stake ${stake.address} and discard its bundled hub ${bundledHub.name}; rent settlement, cargo return, account closure, and any refund remain chain-authoritative.`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'claim-stakes.deconstruct',
         preconditions: [
             ...(await Promise.all([
@@ -1297,7 +1297,7 @@ export async function planDeconstructClaimStake(ctx, stake, input) {
         steps: [
             {
                 describes: description,
-                instruction: adaptDeconstructClaimStakeInstruction({
+                instruction: adaptDeconstructClaimStakeInstruction(ctx.programs, {
                     ...xp.accounts,
                     authorization: options.authorization,
                     celestialBody: stake.body.address,
@@ -1350,7 +1350,7 @@ export async function planTopUpClaimStakeRent(ctx, stake, input) {
     // Under Disabled rent a top-up has no lifecycle gate: a Deactivated stake
     // accepts one, and that is how its owner avoids eviction.
     const loadedState = stake.state;
-    const character = await requireOwnedStake(stake, game, profile);
+    const character = await requireOwnedStake(ctx.programs, stake, game, profile);
     const action = 'the rent top-up';
     const [{ bodyAccount, currentBody, currentStake, extraAccounts: [characterCandidate], stakeAccount, }, rent,] = await Promise.all([
         readOwnedStake(ctx, stake, action, [character]),
@@ -1361,14 +1361,14 @@ export async function planTopUpClaimStakeRent(ctx, stake, input) {
         !sameStakeState(currentStake.state, loadedState)) {
         fail(`Claim Stake ${stake.address} changed or does not match its loaded ownership, Body, definitions, buildings, rent balance, lifecycle state, or System generation. Refresh it and retry the rent top-up.`, stake.address);
     }
-    const { system } = await requireStakePlanet(currentBody, stake, game, action);
-    const { account: characterAccount, current: currentCharacter } = requireProfileCharacter(characterCandidate, character, profile, game, action);
+    const { system } = await requireStakePlanet(ctx.programs, currentBody, stake, game, action);
+    const { account: characterAccount, current: currentCharacter } = requireProfileCharacter(ctx.programs, characterCandidate, character, profile, game, action);
     if (currentCharacter.atlasRaw < options.amount) {
         fail(`Character ${character} has only ${String(currentCharacter.atlasRaw)} known raw ATLAS, below the requested ${String(options.amount)} raw rent top-up. Reduce the amount or add ATLAS, refresh the Character, and retry.`, character);
     }
     const { currentSystem, player, playerAccount, systemAccount } = await readStakeStarbase(ctx, stake, game, system, character, profile, action);
     const description = `Top up Claim Stake ${stake.address} rent with ${String(options.amount)} raw rent units; rent arithmetic remains chain-authoritative.`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'claim-stakes.top-up-rent',
         preconditions: [
             ...(await Promise.all([
@@ -1383,7 +1383,7 @@ export async function planTopUpClaimStakeRent(ctx, stake, input) {
         steps: [
             {
                 describes: description,
-                instruction: adaptTopUpClaimStakeRentInstruction({
+                instruction: adaptTopUpClaimStakeRentInstruction(ctx.programs, {
                     amount: options.amount,
                     authorization: options.authorization,
                     celestialBody: stake.body.address,
@@ -1488,14 +1488,14 @@ export async function planStartClaimStakeFleetTransfer(ctx, fleet, stake, input)
     if (stake.state.kind !== 'active') {
         fail(`Claim Stake ${stake.address} is ${stake.state.kind}, but starting a Fleet transfer requires an active Claim Stake. Activate or restore it, refresh it, and retry.`, stake.address);
     }
-    const character = await requireOwnedStake(stake, game, profile);
+    const character = await requireOwnedStake(ctx.programs, stake, game, profile);
     const action = 'the Fleet transfer';
     const [{ bodyAccount, currentBody, currentStake, extraAccounts: [fleetCandidate, characterCandidate], stakeAccount, }, rent,] = await Promise.all([
         readOwnedStake(ctx, stake, action, [fleet.address, character]),
         requireDisabledStakeRent(ctx, game, stake.address, action),
     ]);
     const fleetAccount = requireAccount(fleetCandidate, fleet.address, `Fleet ${fleet.name} is missing. Refresh it and retry the Fleet transfer.`);
-    const currentFleet = fleetAccountDefinition.decode(fleetAccount);
+    const currentFleet = fleetAccountDefinition.decode(fleetAccount, ctx.programs);
     if (!Number.isSafeInteger(currentFleet.crewCount) ||
         currentFleet.crewCount <= 0) {
         fail(crewFailure, fleet.address);
@@ -1503,22 +1503,22 @@ export async function planStartClaimStakeFleetTransfer(ctx, fleet, stake, input)
     if (!sameTransferFleet(currentFleet, fleet, game, profile) ||
         currentFleet.state.kind !== 'idle' ||
         currentFleet.crewCount !== fleet.crewCount ||
-        (await deriveFleetAddress(currentFleet)) !== fleet.address) {
+        (await deriveFleetAddress(ctx.programs, currentFleet)) !== fleet.address) {
         fail(`Fleet ${fleet.name} changed or no longer matches its loaded Game, owner, canonical address, name, idle state, normalized crew, cargo, or capacities. Refresh it and create a new Claim Stake transfer Plan.`, fleet.address);
     }
     if (!sameTransferStake(currentStake, stake, game, profile)) {
         fail(`Claim Stake ${stake.address} changed or no longer matches its loaded Game, owner, Body, active state, resources, capacity, or System generation. Refresh it and create a new Fleet transfer Plan.`, stake.address);
     }
-    const { system } = await requireStakePlanet(currentBody, stake, game, action);
-    const { account: characterAccount } = requireProfileCharacter(characterCandidate, character, profile, game, action);
+    const { system } = await requireStakePlanet(ctx.programs, currentBody, stake, game, action);
+    const { account: characterAccount } = requireProfileCharacter(ctx.programs, characterCandidate, character, profile, game, action);
     const [currencyCache, crewBinding] = await Promise.all([
-        claimStakeCurrencyCache(game),
-        deriveFleetCrewBindingAddress(fleet.address),
+        claimStakeCurrencyCache(ctx.programs, game),
+        deriveFleetCrewBindingAddress(ctx.programs, fleet.address),
     ]);
     const { currentSystem, extraAccounts: [currencyCandidate, crewCandidate], player, playerAccount, systemAccount, } = await readStakeStarbase(ctx, stake, game, system, character, profile, action, [currencyCache, crewBinding]);
-    const currencyGuard = await requireCurrencyCache(currencyCandidate, currencyCache, game, action, 'Claim Stake Fleet transfer');
+    const currencyGuard = await requireCurrencyCache(ctx.programs, currencyCandidate, currencyCache, game, action, 'Claim Stake Fleet transfer');
     if (crewCandidate !== undefined) {
-        const currentCrewBinding = fleetCrewBindingAccountDefinition.decode(crewCandidate);
+        const currentCrewBinding = fleetCrewBindingAccountDefinition.decode(crewCandidate, ctx.programs);
         if (crewCandidate.address !== crewBinding ||
             !matchesFleetCrewBindingIdentity(currentCrewBinding, fleet.address, profile)) {
             fail(`FleetCrewBinding ${crewCandidate.address} does not match Fleet ${fleet.address}, its owner Profile, or its canonical PDA. Refresh the Fleet crew registration or remove the invalid binding before retrying.`, crewCandidate.address);
@@ -1544,7 +1544,7 @@ export async function planStartClaimStakeFleetTransfer(ctx, fleet, stake, input)
         ...describeCargoRequests('unload', options.unload),
     ];
     const xp = await resolveClaimStakeXp(ctx, game, stake.address);
-    const instruction = adaptStartClaimStakeFleetTransferInstruction({
+    const instruction = adaptStartClaimStakeFleetTransferInstruction(ctx.programs, {
         ...xp.accounts,
         authorization: options.authorization,
         celestialBody: stake.body.address,
@@ -1564,7 +1564,7 @@ export async function planStartClaimStakeFleetTransfer(ctx, fleet, stake, input)
     // its rent floor, then from the Profile vault.
     const storage = await planClaimStakeStorage(ctx, instruction, profile, [fleetAccount, stakeAccount], 'Claim Stake Fleet transfer start');
     const description = `Start fleet ${fleet.name}'s transfer to Claim Stake ${stake.address}: ${descriptions.join('; ')}. Loaded cargo, including Fuel and Ammunition, arrives in the Fleet cargo hold; unloads come from the cargo hold only. Range and transfer duration remain chain-authoritative. ${storage.disclosure}`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'claim-stakes.start-fleet-transfer',
         preconditions: [
             xp.guard,
@@ -1639,15 +1639,15 @@ export async function planRecoverClaimStakeFleetTransfer(ctx, fleet, stake, inpu
     if (options.atUnixSeconds < fleet.state.endAtUnixSeconds) {
         fail(`Fleet ${fleet.name}'s Claim Stake transfer lock has not elapsed at Unix timestamp ${String(options.atUnixSeconds)}; it ends at ${String(fleet.state.endAtUnixSeconds)}. Wait until the lock elapses, provide a current timestamp, and retry recovery.`, fleet.address);
     }
-    const character = await requireOwnedStake(stake, game, options.authorization.profile);
+    const character = await requireOwnedStake(ctx.programs, stake, game, options.authorization.profile);
     const [fleetCandidate, stakeCandidate] = await readContextRawAccounts(ctx, [
         fleet.address,
         stake.address,
     ]);
     const fleetAccount = requireAccount(fleetCandidate, fleet.address, `Fleet ${fleet.name} is missing. Refresh it and retry Claim Stake transfer recovery.`);
     const stakeAccount = requireAccount(stakeCandidate, stake.address, `Claim Stake ${stake.address} is missing. Refresh it and retry Fleet transfer recovery.`);
-    const currentFleet = fleetAccountDefinition.decode(fleetAccount);
-    const currentStake = claimStakeAccountDefinition.decode(stakeAccount);
+    const currentFleet = fleetAccountDefinition.decode(fleetAccount, ctx.programs);
+    const currentStake = claimStakeAccountDefinition.decode(stakeAccount, ctx.programs);
     if (!sameTransferFleet(currentFleet, fleet, game, options.authorization.profile) ||
         currentFleet.state.kind !== 'claimStakeTransfer' ||
         currentFleet.state.claimStake !== stake.address ||
@@ -1655,7 +1655,7 @@ export async function planRecoverClaimStakeFleetTransfer(ctx, fleet, stake, inpu
         currentFleet.state.endAtUnixSeconds !== fleet.state.endAtUnixSeconds ||
         !sameCargoAmounts(currentFleet.state.load, fleet.state.load) ||
         !sameCargoAmounts(currentFleet.state.unload, fleet.state.unload) ||
-        (await deriveFleetAddress(currentFleet)) !== fleet.address) {
+        (await deriveFleetAddress(ctx.programs, currentFleet)) !== fleet.address) {
         fail(`Fleet ${fleet.name} changed or no longer matches its loaded owner, Game, canonical address, Claim Stake transfer snapshot, cargo, or capacities. Refresh it and retry recovery.`, fleet.address);
     }
     if (!sameTransferStake(currentStake, stake, game, options.authorization.profile)) {
@@ -1715,7 +1715,7 @@ export async function planRecoverClaimStakeFleetTransfer(ctx, fleet, stake, inpu
         fail(`Fleet ${fleet.name}'s Claim Stake transfer is currently executable. Use the permissionless normal exit path; recovery is only for a locally proven non-executable transfer.`, fleet.address);
     }
     const description = `Recover fleet ${fleet.name} from its stuck Claim Stake transfer (${reason}); no cargo moves and the Fleet returns to idle.`;
-    return buildPlannerPlan({
+    return buildPlannerPlan(ctx.programs, {
         kind: 'claim-stakes.recover-fleet-transfer',
         preconditions: await Promise.all([
             accountStatePrecondition(fleetAccount, `Fleet ${fleet.name} retains its owner and exact elapsed, non-executable Claim Stake transfer snapshot.`),
@@ -1729,7 +1729,7 @@ export async function planRecoverClaimStakeFleetTransfer(ctx, fleet, stake, inpu
         steps: [
             {
                 describes: description,
-                instruction: adaptRecoverClaimStakeFleetTransferInstruction({
+                instruction: adaptRecoverClaimStakeFleetTransferInstruction(ctx.programs, {
                     authorization: options.authorization,
                     claimStakeInstance: stake.address,
                     fleet: fleet.address,