@aephia/atlas-kit 0.6.0-next.16 → 0.6.0-next.160

package/dist/markets/actions/index.js

@@ -1,14 +1,24 @@
-import { getAddressEncoder } from '@solana/kit';
+import { LOCAL_MARKET_MAXIMUM_GROWTH_BYTES } from '../../internal/c4/local-market-order.js';
+import { resolveMarketOrderAmounts } from '../../internal/planning/local-market-order-funding.js';
+import { validateLocalMarketOrderInstructions, } from '../../internal/planning/local-market-order.js';
+import { isPlanInstance } from '../../planning/plan-instances.js';
+import {} from '@solana/kit';
+import { resolveActionRuntime } from '../../internal/planning/action-runtime.js';
+import { requireProfileStarbasePlayer } from '../../internal/planning/starbase-player-owner.js';
 import { InvalidActionInputError, SageSdkError } from '../../client/errors.js';
 import { readContextRawAccounts } from '../../client/reconciliation.js';
-import { sage } from '../../internal/c4/bindings.js';
-import { characterAccountDefinition, findCharacterPda, } from '../../internal/c4/identity.js';
+import { OrderSide } from '../../internal/c4/runtime-bindings.js';
+import { characterAccountDefinition } from '../../internal/c4/character.js';
 import { deriveLocalMarketAddress, localMarketAccountDefinition, } from '../../internal/c4/market.js';
 import { deriveStarbasePlayerAddress, starbasePlayerAccountDefinition, } from '../../internal/c4/starbase.js';
 import { deriveStarSystemAddress, starSystemAccountDefinition, } from '../../internal/c4/world.js';
 import { requireGameAddress } from '../../internal/game-context.js';
-import { adaptCancelLocalMarketOrdersInstruction, adaptPlaceLocalMarketOrderInstruction, validatePlanAuthorization, } from '../../internal/planning/authorization-adapter.js';
-import { createPlan, } from '../../planning/index.js';
+import { adaptCancelLocalMarketOrdersInstruction, adaptPlaceLocalMarketOrderInstruction, readPlanAuthorization, } from '../../internal/planning/authorization-adapter.js';
+import { buildPlannerPlan } from '../../planning/plan-construction.js';
+import { accountStatePrecondition } from '../../internal/planning/account-state.js';
+import { readMarketStorageAction } from '../../internal/planning/market-storage-actions.js';
+import { RENT_ADDRESS } from '../../internal/planning/rent.js';
+import { planStorageFunding } from '../../internal/planning/storage-actions.js';
 const U64_MAX = (1n << 64n) - 1n;
 const LEVELS = Object.freeze({
     'level-0': 0,
@@ -44,10 +54,7 @@ function validateOptions(value) {
         'priceRaw',
         'quantity',
     ]);
-    const authorizationRecord = readRecord(options.authorization, 'authorization');
-    assertKeys(authorizationRecord, 'authorization', ['profile', 'authority', 'keyIndex'], ['certificate']);
-    const authorization = authorizationRecord;
-    validatePlanAuthorization(authorization);
+    const authorization = readPlanAuthorization(options.authorization);
     if (options.side !== 'bid' && options.side !== 'ask') {
         invalid('side', options.side, 'either bid or ask', 'Set side to bid to buy cargo or ask to sell cargo before retrying.');
     }
@@ -57,8 +64,11 @@ function validateOptions(value) {
             invalid(field, amount, `a positive raw bigint from 1 through ${String(U64_MAX)} (unsigned u64)`, `Set ${field} to the exact positive raw value within the instruction codec range.`);
         }
     }
+    if (options.side === 'bid' &&
+        options.priceRaw * options.quantity > U64_MAX)
+        invalid('priceRaw × quantity', options.priceRaw * options.quantity, 'a bid principal within unsigned u64', 'Reduce the raw price or cargo quantity so the complete bid principal fits unsigned u64.');
     return {
-        authorization,
+        authorization: { ...authorization },
         priceRaw: options.priceRaw,
         quantity: options.quantity,
         side: options.side,
@@ -67,12 +77,9 @@ function validateOptions(value) {
 function validateCancelOptions(value) {
     const options = readRecord(value, 'options');
     assertKeys(options, 'options', ['authorization', 'orderIds']);
-    const authorizationRecord = readRecord(options.authorization, 'authorization');
-    assertKeys(authorizationRecord, 'authorization', ['profile', 'authority', 'keyIndex'], ['certificate']);
-    const authorization = authorizationRecord;
-    validatePlanAuthorization(authorization);
+    const authorization = readPlanAuthorization(options.authorization);
     if (!Array.isArray(options.orderIds)) {
-        invalid('orderIds', options.orderIds, 'a dense array of unique non-negative safe integers', 'Provide orderIds as a plain array, or an empty array to withdraw filled escrow only.');
+        invalid('orderIds', options.orderIds, 'a dense array of unique unsigned-u64 bigint integers', 'Provide orderIds as a plain array, or an empty array to withdraw filled escrow only.');
     }
     const orderIds = options.orderIds;
     const seen = new Set();
@@ -81,8 +88,8 @@ function validateCancelOptions(value) {
             invalid('orderIds', orderIds, 'a dense array without missing elements', 'Remove sparse positions from orderIds before retrying.');
         }
         const orderId = orderIds[index];
-        if (!Number.isSafeInteger(orderId) || orderId < 0) {
-            invalid(`orderIds[${String(index)}]`, orderId, 'a non-negative safe integer', 'Use the exact finite order id exposed by the Local Market snapshot.');
+        if (typeof orderId !== 'bigint' || orderId < 0n || orderId > U64_MAX) {
+            invalid(`orderIds[${String(index)}]`, orderId, 'an unsigned-u64 bigint integer', 'Use the exact finite order id exposed by the Local Market snapshot.');
         }
         if (seen.has(orderId)) {
             invalid(`orderIds[${String(index)}]`, orderId, 'a unique order id that appears once', 'Remove duplicate order ids before retrying.');
@@ -113,21 +120,77 @@ function sameBalances(snapshot, account) {
         return account.some((amount) => amount.cargoId === item.id && amount.amount === item.quantityRaw);
     });
 }
-async function hashAccountState(account) {
-    const owner = getAddressEncoder().encode(account.owner);
-    const canonical = new Uint8Array(owner.length + account.data.length);
-    canonical.set(owner);
-    canonical.set(account.data, owner.length);
-    const digest = new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', canonical));
-    return [...digest].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+/** Snapshot facts both Local Market planners check before reads: one System,
+ * the authorization Profile's canonical Starbase Player and the canonical
+ * Market address. Returns the canonical Character. */
+async function requireMarketSnapshots(market, player, profile, game) {
+    if (market.system.address !== player.system.address) {
+        fail(`Local Market ${market.address} is in System ${market.system.address}, not Starbase Player System ${player.system.address}. Choose a Market at the player's Starbase and retry.`, market.address);
+    }
+    const character = await requireProfileStarbasePlayer(player, profile, game);
+    if ((await deriveLocalMarketAddress(market.system.address, market.cargo.id, market.starbaseSequenceId)) !== market.address) {
+        fail(`Local Market ${market.address} does not match cargo ${String(market.cargo.id)} and Starbase sequence ${String(market.starbaseSequenceId)}. Refresh the Local Market and retry.`, market.address);
+    }
+    return character;
 }
-async function precondition(account, describes) {
-    return Object.freeze({
-        address: account.address,
-        dataHash: await hashAccountState(account),
-        describes,
-        kind: 'account-state',
-    });
+/** Reads the canonical Character, the System, the Starbase Player and the
+ * Local Market, and requires their shared identity: the Character of the
+ * Profile in the configured Game, the canonical System, the canonical Starbase
+ * Player of the Profile, Character and System, and the canonical Market of the
+ * loaded System, Starbase sequence, cargo and initializer. `action` completes
+ * the Starbase Player remedy. */
+async function readMarketFacts(ctx, market, player, character, profile, game, action) {
+    const [characterCandidate, systemCandidate, playerCandidate, marketCandidate,] = await readContextRawAccounts(ctx, [
+        character,
+        player.system.address,
+        player.address,
+        market.address,
+    ]);
+    const characterAccount = requireAccount(characterCandidate, character, `Canonical Character ${character} is missing for Profile ${profile}. Create or repair the Character in the configured Game, refresh the Starbase Player, and retry.`);
+    const systemAccount = requireAccount(systemCandidate, player.system.address, `Star System ${player.system.address} is missing. Refresh the Starbase Player and Local Market, then retry.`);
+    const playerAccount = requireAccount(playerCandidate, player.address, `Starbase Player ${player.address} is missing. Refresh the Starbase Player and retry ${action}.`);
+    const marketAccount = requireAccount(marketCandidate, market.address, `Local Market ${market.address} is missing. Refresh the Local Market and retry.`);
+    const characterData = characterAccountDefinition.decode(characterAccount);
+    if (characterAccount.address !== character ||
+        characterData.playerProfile !== profile ||
+        characterData.game !== game) {
+        fail(`The canonical Character does not match Profile ${profile} and the configured Game ${game}. Refresh or repair the Character relationship before retrying.`, characterAccount.address);
+    }
+    const systemData = starSystemAccountDefinition.decode(systemAccount);
+    if (systemAccount.address !== player.system.address ||
+        (await deriveStarSystemAddress(game, systemData.systemId)) !==
+            player.system.address ||
+        systemData.game !== game) {
+        fail(`Star System ${player.system.address} does not match its canonical System id and configured Game ${game}. Refresh the Starbase Player and Local Market, then retry.`, player.system.address);
+    }
+    const playerData = starbasePlayerAccountDefinition.decode(playerAccount);
+    if (playerAccount.address !== player.address ||
+        playerData.playerProfile !== profile ||
+        playerData.character !== character ||
+        playerData.system !== player.system.address ||
+        (await deriveStarbasePlayerAddress(playerData.system, playerData.character)) !== player.address) {
+        fail(`Starbase Player ${player.address} changed or does not match its canonical Profile, Character, or System. Refresh the Starbase Player through this context and retry.`, player.address);
+    }
+    const marketData = localMarketAccountDefinition.decode(marketAccount);
+    if (marketAccount.address !== market.address ||
+        marketData.system !== market.system.address ||
+        marketData.starbaseSequenceId !== market.starbaseSequenceId ||
+        marketData.version !== market.version ||
+        marketData.bump !== market.bump ||
+        marketData.initializerProfile !== market.initializerProfile.address ||
+        marketData.cargo.cargoId !== market.cargo.id ||
+        (await deriveLocalMarketAddress(marketData.system, marketData.cargo.cargoId, marketData.starbaseSequenceId)) !== market.address) {
+        fail(`Local Market ${market.address} changed or does not match its canonical System, Starbase sequence, cargo, or initializer. Refresh the Local Market through this context and retry.`, market.address);
+    }
+    return {
+        characterAccount,
+        characterData,
+        marketAccount,
+        marketData,
+        playerAccount,
+        playerData,
+        systemData,
+    };
 }
 /** Plans one Local Market bid or ask without signing, simulation, or writes.
  *
@@ -135,6 +198,8 @@ async function precondition(account, describes) {
  * canonical Character/System/Game graph, the current market-enabled Starbase
  * incarnation, and the known bid ATLAS or ask cargo balance. Matching, rent,
  * final capacity, permissions, and state races remain chain-authoritative.
+ * A valid Profile below the conservative storage ceiling still produces a Plan;
+ * its debit bounds are unavailable with reason `profile-below-storage-ceiling`.
  *
  * @example
  * ```ts
@@ -149,60 +214,21 @@ async function precondition(account, describes) {
 export async function planPlaceLocalMarketOrder(ctx, market, player, input) {
     const options = validateOptions(input);
     const game = requireGameAddress(ctx);
-    if (market.system.address !== player.system.address) {
-        fail(`Local Market ${market.address} is in System ${market.system.address}, not Starbase Player System ${player.system.address}. Choose a Market at the player's Starbase and retry.`, market.address);
-    }
-    if (player.playerProfile.address !== options.authorization.profile) {
-        fail(`Starbase Player ${player.address} does not belong to authorization Profile ${options.authorization.profile}. Refresh the Starbase Player for that Profile and retry.`, player.address);
-    }
-    const character = await findCharacterPda(options.authorization.profile, game);
-    if (player.character.address !== character) {
-        fail(`Starbase Player ${player.address} does not reference the canonical Character ${character} for authorization Profile ${options.authorization.profile}. Refresh the Starbase Player and retry.`, player.address);
-    }
-    const canonicalPlayer = await deriveStarbasePlayerAddress(player.system.address, character);
-    if (canonicalPlayer !== player.address) {
-        fail(`Starbase Player ${player.address} is not canonical for its Character and System. Refresh the Starbase Player through this context and retry.`, player.address);
-    }
-    const canonicalMarket = await deriveLocalMarketAddress(market.system.address, market.cargo.id, market.starbaseSequenceId);
-    if (canonicalMarket !== market.address) {
-        fail(`Local Market ${market.address} does not match cargo ${String(market.cargo.id)} and Starbase sequence ${String(market.starbaseSequenceId)}. Refresh the active Local Market and retry.`, market.address);
-    }
+    const { profile } = options.authorization;
+    const character = await requireMarketSnapshots(market, player, profile, game);
     if (options.side === 'ask') {
         const available = balance(player.cargo.items, market.cargo.id);
         if (available < options.quantity) {
             fail(`Starbase Player ${player.address} has ${String(available)} raw ${market.cargo.name}, but this ask requires ${String(options.quantity)}. Add the missing cargo, refresh the Starbase Player, and retry.`, player.address);
         }
     }
-    const addresses = [
-        character,
-        player.system.address,
-        player.address,
-        market.address,
-    ];
-    const reads = await readContextRawAccounts(ctx, addresses);
-    const characterAccount = requireAccount(reads[0], character, `Canonical Character ${character} is missing for Profile ${options.authorization.profile}. Create or repair the Character in the configured Game, refresh the Starbase Player, and retry.`);
-    const systemAccount = requireAccount(reads[1], player.system.address, `Star System ${player.system.address} is missing. Refresh the Starbase Player and Local Market, then retry.`);
-    const playerAccount = requireAccount(reads[2], player.address, `Starbase Player ${player.address} is missing. Refresh the Starbase Player and retry placing the order.`);
-    const marketAccount = requireAccount(reads[3], market.address, `Local Market ${market.address} is missing. Refresh the active Local Market and retry.`);
-    const characterData = characterAccountDefinition.decode(characterAccount);
-    if (characterAccount.address !== character ||
-        characterData.playerProfile !== options.authorization.profile ||
-        characterData.game !== game) {
-        fail(`The canonical Character does not match Profile ${options.authorization.profile} and the configured Game ${game}. Refresh or repair the Character relationship before retrying.`, characterAccount.address);
-    }
+    const { characterAccount, characterData, marketAccount, marketData, playerAccount, playerData, systemData, } = await readMarketFacts(ctx, market, player, character, profile, game, 'placing the order');
     if (options.side === 'bid') {
         const required = options.priceRaw * options.quantity;
         if (characterData.atlasRaw < required) {
             fail(`Character ${character} has ${String(characterData.atlasRaw)} raw ATLAS, but this bid requires ${String(required)}. Add the missing ATLAS, refresh the Character, and retry.`, character);
         }
     }
-    const systemData = starSystemAccountDefinition.decode(systemAccount);
-    const canonicalSystem = await deriveStarSystemAddress(game, systemData.systemId);
-    if (systemAccount.address !== player.system.address ||
-        canonicalSystem !== player.system.address ||
-        systemData.game !== game) {
-        fail(`Star System ${player.system.address} does not match its canonical System id and configured Game ${game}. Refresh the Starbase Player and Local Market, then retry.`, player.system.address);
-    }
     if (systemData.sequenceId !== market.starbaseSequenceId) {
         fail(`Local Market ${market.address} has Starbase sequence ${String(market.starbaseSequenceId)}, but System ${player.system.address} is now sequence ${String(systemData.sequenceId)}. Refresh the active Local Market and retry.`, market.address);
     }
@@ -213,43 +239,67 @@ export async function planPlaceLocalMarketOrder(ctx, market, player, input) {
         LEVELS[systemData.starbase.localMarketEnableLevel]) {
         fail(`Starbase ${player.system.address} is ${systemData.starbase.level}, but its Local Market requires ${systemData.starbase.localMarketEnableLevel}. Choose an active market-enabled Starbase, refresh it, and retry.`, player.system.address);
     }
-    const playerData = starbasePlayerAccountDefinition.decode(playerAccount);
-    if (playerAccount.address !== player.address ||
-        playerData.playerProfile !== options.authorization.profile ||
-        playerData.character !== character ||
-        playerData.system !== player.system.address ||
-        (await deriveStarbasePlayerAddress(playerData.system, playerData.character)) !== player.address ||
-        playerData.sequenceId !== player.sequenceId ||
+    if (playerData.sequenceId !== player.sequenceId ||
         !sameBalances(player.cargo.items, playerData.cargo.amounts)) {
-        fail(`Starbase Player ${player.address} changed or does not match its canonical Profile, Character, System, sequence, or cargo state. Refresh the Starbase Player through this context and retry.`, player.address);
+        fail(`Starbase Player ${player.address} changed its sequence or cargo state. Refresh the Starbase Player through this context and retry.`, player.address);
     }
-    const marketData = localMarketAccountDefinition.decode(marketAccount);
-    if (marketAccount.address !== market.address ||
-        marketData.system !== market.system.address ||
-        marketData.starbaseSequenceId !== market.starbaseSequenceId ||
-        marketData.version !== market.version ||
-        marketData.bump !== market.bump ||
-        marketData.initializerProfile !== market.initializerProfile.address ||
-        marketData.cargo.cargoId !== market.cargo.id ||
-        marketData.cargo.amountRaw !== market.cargo.amountRaw ||
-        marketData.vaultRaw !== market.vaultRaw ||
-        (await deriveLocalMarketAddress(marketData.system, marketData.cargo.cargoId, marketData.starbaseSequenceId)) !== market.address) {
-        fail(`Local Market ${market.address} changed or does not match its canonical System, Starbase sequence, cargo, initializer, or vault state. Refresh the Local Market through this context and retry.`, market.address);
+    if (marketData.cargo.amountRaw !== market.cargo.amountRaw ||
+        marketData.vaultRaw !== market.vaultRaw) {
+        fail(`Local Market ${market.address} changed its cargo or vault state. Refresh the Local Market through this context and retry.`, market.address);
     }
-    const encodedSide = options.side === 'bid' ? sage.OrderSide.Bid : sage.OrderSide.Ask;
+    const runtime = await resolveActionRuntime(ctx, {
+        mode: 'market',
+        game,
+        system: player.system.address,
+        starbaseSeqId: market.starbaseSequenceId,
+    });
+    const intent = {
+        address: market.address,
+        game,
+        system: player.system.address,
+        profile,
+        authority: options.authorization.authority,
+        ...(options.authorization.certificate
+            ? { certificate: options.authorization.certificate }
+            : {}),
+        keyIndex: options.authorization.keyIndex,
+        character,
+        starbasePlayer: player.address,
+        starbaseSequenceId: market.starbaseSequenceId,
+        cargoId: market.cargo.id,
+        side: options.side,
+        priceRaw: options.priceRaw,
+        quantity: options.quantity,
+    };
+    const amounts = await resolveMarketOrderAmounts(ctx, intent, marketAccount, playerAccount, characterAccount, runtime.guards);
+    const debitGuard = {
+        kind: 'local-market-order',
+        ...intent,
+        ...amounts,
+        describes: amounts.status === 'available'
+            ? `Maximum order debits: ${String(amounts.maximumCargoDebitRaw)} raw cargo, ${String(amounts.maximumAtlasDebitRaw)} ATLAS Floyds including zero governance fee, and ${String(amounts.maximumProfileDebit)} Profile lamports for conservative storage growth. No fill or proceeds are promised; transaction fees are separate. Ceilings are rechecked before signing, not enforced atomically on chain.`
+            : `Local Market debit bounds are unavailable (${amounts.reason}). No fee, rent or spending ceiling is claimed; inspect the route separately before authorizing it.`,
+    };
+    const encodedSide = options.side === 'bid' ? OrderSide.Bid : OrderSide.Ask;
     const description = `Place ${options.side} for ${String(options.quantity)} raw units of ${market.cargo.name} at raw price ${String(options.priceRaw)} ATLAS Floyds each on Local Market ${market.address}.`;
-    return createPlan({
+    return buildPlannerPlan({
         kind: 'markets.place-local-order',
-        preconditions: await Promise.all([
-            precondition(characterAccount, `The canonical Character retains Profile ${options.authorization.profile}, the configured Game, and the validated raw ATLAS balance.`),
-            precondition(systemAccount, `Star System ${player.system.address} retains the validated Starbase sequence and Local Market enablement.`),
-            precondition(playerAccount, `Starbase Player ${player.address} retains its Profile, Character, System, sequence, and cargo inventory.`),
-            precondition(marketAccount, `Local Market ${market.address} retains its System, Starbase sequence, cargo, initializer, and vault state.`),
-        ]),
+        preconditions: [
+            debitGuard,
+            ...runtime.guards,
+            ...(await Promise.all([
+                accountStatePrecondition(characterAccount, `The canonical Character retains Profile ${profile}, the configured Game, and the validated raw ATLAS balance.`),
+                accountStatePrecondition(playerAccount, `Starbase Player ${player.address} retains its Profile, Character, System, sequence, and cargo inventory.`),
+                accountStatePrecondition(marketAccount, `Local Market ${market.address} retains its System, Starbase sequence, cargo, initializer, and vault state.`),
+            ])),
+        ],
         steps: [
             {
-                describes: description,
+                describes: `${description} ${runtime.description} ${debitGuard.describes}`,
                 instruction: adaptPlaceLocalMarketOrderInstruction({
+                    ...runtime.accounts,
+                    starbaseGovernance: runtime.accounts.starbaseGovernance,
+                    currencyCache: runtime.accounts.currencyCache,
                     authorization: options.authorization,
                     character,
                     game,
@@ -263,7 +313,7 @@ export async function planPlaceLocalMarketOrder(ctx, market, player, input) {
                 signers: [options.authorization.authority],
             },
         ],
-        summary: description,
+        summary: `${description} ${runtime.description} ${debitGuard.describes}`,
     });
 }
 /** Plans cancellation of owned Local Market orders and filled-escrow withdrawal.
@@ -286,32 +336,16 @@ export async function planPlaceLocalMarketOrder(ctx, market, player, input) {
 export async function planCancelLocalMarketOrders(ctx, market, player, input) {
     const options = validateCancelOptions(input);
     const game = requireGameAddress(ctx);
-    if (market.system.address !== player.system.address) {
-        fail(`Local Market ${market.address} is in System ${market.system.address}, not Starbase Player System ${player.system.address}. Choose the player's Market and retry.`, market.address);
-    }
-    if (player.playerProfile.address !== options.authorization.profile) {
-        fail(`Starbase Player ${player.address} does not belong to authorization Profile ${options.authorization.profile}. Refresh the Starbase Player for that Profile and retry.`, player.address);
-    }
-    const character = await findCharacterPda(options.authorization.profile, game);
-    if (player.character.address !== character) {
-        fail(`Starbase Player ${player.address} does not reference the canonical Character ${character} for authorization Profile ${options.authorization.profile}. Refresh the Starbase Player and retry.`, player.address);
-    }
-    const canonicalPlayer = await deriveStarbasePlayerAddress(player.system.address, character);
-    if (canonicalPlayer !== player.address) {
-        fail(`Starbase Player ${player.address} is not canonical for its Character and System. Refresh the Starbase Player through this context and retry.`, player.address);
-    }
-    const canonicalMarket = await deriveLocalMarketAddress(market.system.address, market.cargo.id, market.starbaseSequenceId);
-    if (canonicalMarket !== market.address) {
-        fail(`Local Market ${market.address} does not match cargo ${String(market.cargo.id)} and Starbase sequence ${String(market.starbaseSequenceId)}. Refresh the Local Market and retry.`, market.address);
-    }
+    const { profile } = options.authorization;
+    const character = await requireMarketSnapshots(market, player, profile, game);
     const snapshotOrders = [...market.bids.orders, ...market.asks.orders];
     const selected = options.orderIds.map((orderId) => {
-        const matches = snapshotOrders.filter((candidate) => candidate.orderId === BigInt(orderId));
+        const matches = snapshotOrders.filter((candidate) => candidate.orderId === orderId);
         if (matches.length === 0) {
             return fail(`Local Market order ${String(orderId)} is not present in snapshot ${market.address}. Refresh the Local Market and select an existing owned order before retrying.`, market.address);
         }
-        if (matches.some((candidate) => candidate.maker !== character)) {
-            return fail(`Local Market order ${String(orderId)} belongs to another Character, not ${character}. Select only orders owned by the authorization Profile's Character.`, market.address);
+        if (matches.some((candidate) => candidate.maker !== profile)) {
+            return fail(`Local Market order ${String(orderId)} belongs to another Profile, not ${profile}. Select only orders owned by the authorization Profile.`, market.address);
         }
         if (matches.length !== 1) {
             return fail(`Local Market order id ${String(orderId)} is ambiguous across the order books. Refresh the Market and wait for an unambiguous owned selection before retrying.`, market.address);
@@ -323,49 +357,7 @@ export async function planCancelLocalMarketOrders(ctx, market, player, input) {
             side: match.side,
         };
     });
-    const addresses = [
-        character,
-        player.system.address,
-        player.address,
-        market.address,
-    ];
-    const reads = await readContextRawAccounts(ctx, addresses);
-    const characterAccount = requireAccount(reads[0], character, `Canonical Character ${character} is missing for Profile ${options.authorization.profile}. Create or repair the Character, refresh the Starbase Player, and retry.`);
-    const systemAccount = requireAccount(reads[1], player.system.address, `Star System ${player.system.address} is missing. Refresh the Starbase Player and Local Market, then retry.`);
-    const playerAccount = requireAccount(reads[2], player.address, `Starbase Player ${player.address} is missing. Refresh the Starbase Player and retry cancelling the orders.`);
-    const marketAccount = requireAccount(reads[3], market.address, `Local Market ${market.address} is missing. Refresh the Local Market and retry.`);
-    const characterData = characterAccountDefinition.decode(characterAccount);
-    if (characterAccount.address !== character ||
-        characterData.playerProfile !== options.authorization.profile ||
-        characterData.game !== game) {
-        fail(`The canonical Character does not match Profile ${options.authorization.profile} and the configured Game ${game}. Refresh or repair the Character relationship before retrying.`, characterAccount.address);
-    }
-    const systemData = starSystemAccountDefinition.decode(systemAccount);
-    const canonicalSystem = await deriveStarSystemAddress(game, systemData.systemId);
-    if (systemAccount.address !== player.system.address ||
-        canonicalSystem !== player.system.address ||
-        systemData.game !== game) {
-        fail(`Star System ${player.system.address} does not match its canonical System id and configured Game ${game}. Refresh the Starbase Player and Local Market, then retry.`, player.system.address);
-    }
-    const playerData = starbasePlayerAccountDefinition.decode(playerAccount);
-    if (playerAccount.address !== player.address ||
-        playerData.playerProfile !== options.authorization.profile ||
-        playerData.character !== character ||
-        playerData.system !== player.system.address ||
-        (await deriveStarbasePlayerAddress(playerData.system, playerData.character)) !== player.address) {
-        fail(`Starbase Player ${player.address} changed or does not match its canonical Profile, Character, or System. Refresh the Starbase Player through this context and retry.`, player.address);
-    }
-    const marketData = localMarketAccountDefinition.decode(marketAccount);
-    if (marketAccount.address !== market.address ||
-        marketData.system !== market.system.address ||
-        marketData.starbaseSequenceId !== market.starbaseSequenceId ||
-        marketData.version !== market.version ||
-        marketData.bump !== market.bump ||
-        marketData.initializerProfile !== market.initializerProfile.address ||
-        marketData.cargo.cargoId !== market.cargo.id ||
-        (await deriveLocalMarketAddress(marketData.system, marketData.cargo.cargoId, marketData.starbaseSequenceId)) !== market.address) {
-        fail(`Local Market ${market.address} changed or does not match its canonical System, Starbase sequence, cargo, or initializer. Refresh the Local Market through this context and retry.`, market.address);
-    }
+    const { characterAccount, marketAccount, marketData, playerAccount } = await readMarketFacts(ctx, market, player, character, profile, game, 'cancelling the orders');
     const rawOrders = [
         ...marketData.bids.orders.map((candidate) => ({
             candidate,
@@ -381,37 +373,119 @@ export async function planCancelLocalMarketOrders(ctx, market, player, input) {
         return (matches.length !== 1 ||
             matches[0].side !== side ||
             matches[0].candidate.priceRaw !== price ||
-            matches[0].candidate.maker !== character);
+            matches[0].candidate.maker !== profile);
     })) {
-        fail(`Local Market ${market.address} selected order data changed in book side, price, or ownership, or became ambiguous across the fresh books. Refresh the Local Market and choose the Character's current unambiguous orders before retrying.`, market.address);
+        fail(`Local Market ${market.address} selected order data changed in book side, price, or ownership, or became ambiguous across the fresh books. Refresh the Local Market and choose the Profile's current unambiguous orders before retrying.`, market.address);
     }
+    const runtime = await resolveActionRuntime(ctx, {
+        mode: 'market',
+        game,
+        system: player.system.address,
+        starbaseSeqId: market.starbaseSequenceId,
+    });
     const description = selected.length === 0
         ? `Withdraw filled escrow currently available to Character ${character} for ${market.cargo.name} on Local Market ${market.address}; final escrow availability and order races remain chain-authoritative.`
         : `Cancel Local Market orders ${options.orderIds.join(', ')} for ${market.cargo.name} and withdraw all filled escrow currently available to Character ${character}; final escrow availability and order races remain chain-authoritative.`;
-    return createPlan({
+    const instruction = adaptCancelLocalMarketOrdersInstruction({
+        ...runtime.accounts,
+        starbaseGovernance: runtime.accounts.starbaseGovernance,
+        currencyCache: runtime.accounts.currencyCache,
+        args: selected,
+        authorization: options.authorization,
+        character,
+        game,
+        localMarket: market.address,
+        starbasePlayer: player.address,
+        system: player.system.address,
+    });
+    // Returned cargo can open a Starbase Player line, which the program funds
+    // from the Profile vault net of the storage the Market releases.
+    const [profileAccount, rentAccount] = await readContextRawAccounts(ctx, [
+        profile,
+        RENT_ADDRESS,
+    ]);
+    const storageAccounts = new Map([
+        [marketAccount.address, marketAccount],
+        [playerAccount.address, playerAccount],
+        [profile, profileAccount],
+        [RENT_ADDRESS, rentAccount],
+    ]);
+    const storage = planStorageFunding({
+        action: readMarketStorageAction(instruction, storageAccounts),
+        accounts: storageAccounts,
+        label: 'Local Market cancellation',
+    });
+    return buildPlannerPlan({
         kind: 'markets.cancel-local-orders',
-        preconditions: await Promise.all([
-            precondition(characterAccount, `The canonical Character retains Profile ${options.authorization.profile} and the configured Game.`),
-            precondition(systemAccount, `Star System ${player.system.address} retains its canonical configured-Game relationship.`),
-            precondition(playerAccount, `Starbase Player ${player.address} retains its Profile, Character, and System relationships.`),
-            precondition(marketAccount, `Local Market ${market.address} retains its canonical identity and the selected owned order book sides, prices, and ownership.`),
-        ]),
+        preconditions: [
+            ...runtime.guards,
+            ...(await Promise.all([
+                accountStatePrecondition(characterAccount, `The canonical Character retains Profile ${profile} and the configured Game.`),
+                accountStatePrecondition(playerAccount, `Starbase Player ${player.address} retains its Profile, Character, and System relationships.`),
+                accountStatePrecondition(marketAccount, `Local Market ${market.address} retains its canonical identity and the selected owned order book sides, prices, and ownership.`),
+            ])),
+            storage.guard,
+        ],
         steps: [
             {
-                describes: description,
-                instruction: adaptCancelLocalMarketOrdersInstruction({
-                    args: selected,
-                    authorization: options.authorization,
-                    character,
-                    game,
-                    localMarket: market.address,
-                    starbasePlayer: player.address,
-                    system: player.system.address,
-                }),
+                describes: `${description} ${runtime.description} ${storage.disclosure}`,
+                instruction,
                 signers: [options.authorization.authority],
             },
         ],
-        summary: description,
+        summary: `${description} ${runtime.description} ${storage.disclosure}`,
+    });
+}
+export { planTradeFactionMarket, } from './trade-faction-market.js';
+/** Reads the persisted debit qualification without network I/O.
+ *
+ * Unsupported routes retain their existing execution behavior and return an
+ * explicit unavailable result, including a valid Profile below the conservative
+ * storage ceiling. Available bounds survive Plan persistence and
+ * fail closed before signing when their assumptions no longer hold.
+ *
+ * @example
+ * ```ts
+ * declare const plan: Plan;
+ * const bounds = getLocalMarketOrderDebitBounds(plan);
+ * if (bounds.status === 'available') console.log(bounds.maximumAtlasDebitRaw);
+ * ```
+ */
+export function getLocalMarketOrderDebitBounds(plan) {
+    if (!isPlanInstance(plan))
+        throw new InvalidActionInputError('plan', plan, 'a genuine Plan from a planning factory', 'Create or hydrate the Plan through this SDK before reading its debit bounds.');
+    validateLocalMarketOrderInstructions(plan.steps, plan.preconditions);
+    const guard = plan.preconditions.find((g) => g.kind === 'local-market-order');
+    if (!guard)
+        return Object.freeze({
+            status: 'unavailable',
+            reason: 'not-local-market-order',
+        });
+    if (guard.status === 'unavailable')
+        return Object.freeze({ status: 'unavailable', reason: guard.reason });
+    return Object.freeze({
+        status: 'available',
+        maximumCargoDebitRaw: guard.maximumCargoDebitRaw,
+        maximumAtlasDebitRaw: guard.maximumAtlasDebitRaw,
+        maximumGovernanceFeeRaw: guard.maximumGovernanceFeeRaw,
+        maximumProfileDebit: guard.maximumProfileDebit,
+        profile: guard.profile,
+        character: guard.character,
+        starbasePlayer: guard.starbasePlayer,
+        localMarket: guard.address,
+        cargoId: guard.cargoId,
+        side: guard.side,
+        priceRaw: guard.priceRaw,
+        quantity: guard.quantity,
+        cargoUnit: 'raw',
+        atlasUnit: 'floyds',
+        profileUnit: 'lamports',
+        feePolicy: 'default-zero',
+        marketVersion: 0,
+        characterVersion: 0,
+        starbasePlayerVersion: 0,
+        maximumMarketGrowthBytes: LOCAL_MARKET_MAXIMUM_GROWTH_BYTES,
+        transactionFees: 'excluded',
     });
 }
 //# sourceMappingURL=index.js.map