@aephia/atlas-kit 0.6.0-next.14 → 0.6.0-next.140

package/dist/internal/planning/runtime-guards.js

@@ -0,0 +1,658 @@
+import { validateCurrencyInstructions } from './currency-cache-guard.js';
+import { AccountRole, isAddress, } from '@solana/kit';
+import { InvalidActionInputError, SageSdkError } from '../../client/errors.js';
+import { deepFreeze } from '../immutable-tree.js';
+import { getPlaceClaimStakeBuildingsInstructionDataDecoder, getCancelClaimStakeBuildingDesignInstructionDataDecoder, getFinalizeBuildingChangesInstructionDataDecoder, getStartClaimStakesFleetTransferInstructionDataDecoder, getDeconstructClaimStakeInstanceInstructionDataDecoder, SAGE_PROGRAM_ADDRESS, getAttackStarbaseInstructionDataDecoder, getCancelLocalMarketOrdersInstructionDataDecoder, getCompleteCraftingProcessInstructionDataDecoder, getPlaceLocalMarketOrderInstructionDataDecoder, getStartCraftingProcessInstructionDataDecoder, } from '../c4/runtime-bindings.js';
+import { resolveDemocracyHistory, matchDemocracyHistoryIntent, } from './democracy-history.js';
+import { resolveXpRuntime, } from './xp-runtime.js';
+import { resolveGovernanceFees, matchGovernanceFeesIntent, } from './governance-fees.js';
+import { ATTACK_STARBASE_DISCRIMINATOR, CANCEL_CLAIM_STAKE_BUILDING_DESIGN_DISCRIMINATOR, CANCEL_LOCAL_MARKET_ORDERS_DISCRIMINATOR, COMPLETE_CRAFTING_PROCESS_DISCRIMINATOR, DECONSTRUCT_CLAIM_STAKE_INSTANCE_DISCRIMINATOR, FINALIZE_BUILDING_CHANGES_DISCRIMINATOR, PLACE_CLAIM_STAKE_BUILDINGS_DISCRIMINATOR, PLACE_LOCAL_MARKET_ORDER_DISCRIMINATOR, START_CLAIM_STAKES_FLEET_TRANSFER_DISCRIMINATOR, START_CRAFTING_PROCESS_DISCRIMINATOR, } from '../c4/discriminators.js';
+export function isRuntimeGuard(value) {
+    return (value.kind === 'democracy-history' ||
+        value.kind === 'xp-runtime' ||
+        value.kind === 'governance-fees');
+}
+function invalid(field, value) {
+    throw new InvalidActionInputError(field, value, 'the exact supported runtime safeguard fields and values', 'Recreate the Plan from fresh gameplay state with this SDK version.');
+}
+function record(value, field, required, optional = []) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        invalid(field, value);
+    const result = value;
+    if (required.some((key) => !Object.hasOwn(result, key)) ||
+        Object.keys(result).some((key) => !required.includes(key) && !optional.includes(key)))
+        invalid(field, value);
+    return result;
+}
+function address(value, field) {
+    if (typeof value !== 'string' || !isAddress(value))
+        invalid(field, value);
+    return value;
+}
+function integer(value, field, maximum) {
+    if (typeof value !== 'number' ||
+        !Number.isInteger(value) ||
+        value < 0 ||
+        value > maximum)
+        invalid(field, value);
+    return value;
+}
+function token(value, field, choices) {
+    if (typeof value !== 'string' || !choices.includes(value))
+        invalid(field, value);
+    return value;
+}
+function big(value, field, wire) {
+    if (wire) {
+        if (typeof value !== 'string' || !/^(0|[1-9][0-9]*)$/.test(value))
+            invalid(field, value);
+        value = BigInt(value);
+    }
+    if (typeof value !== 'bigint' || value < 0n || value > (1n << 64n) - 1n)
+        invalid(field, value);
+    return value;
+}
+function feeParams(value, field) {
+    const keys = [
+        'craftingFeeBps',
+        'localMarketFeeBps',
+        'localTreasuryShareBps',
+        'treasuryDistributionBps',
+    ];
+    const row = record(value, field, keys);
+    return Object.fromEntries(keys.map((key) => [key, integer(row[key], `${field}.${key}`, 65535)]));
+}
+function historyIntent(value, field, wire) {
+    const state = value?.state;
+    const row = record(value, field, [
+        'game',
+        'system',
+        'address',
+        'state',
+        ...(state === 'initialized'
+            ? [
+                'openDay',
+                'enabled',
+                'controller',
+                'generationNumber',
+                'governance',
+                'starbaseSeqId',
+                'policy',
+                'policyFlags',
+                'effectiveParams',
+            ]
+            : []),
+    ], state === 'initialized' ? ['generation'] : []);
+    const scope = {
+        game: address(row.game, field),
+        system: address(row.system, field),
+        address: address(row.address, field),
+    };
+    if (token(row.state, field, ['absent', 'initialized']) === 'absent')
+        return { ...scope, state: 'absent' };
+    const flagKeys = [
+        'noControllerRevenue',
+        'zeroPowerRevenue',
+        'successorBaseline',
+        'captureIncomingEligibility',
+    ];
+    const flags = record(row.policyFlags, `${field}.policyFlags`, flagKeys);
+    const policyFlags = Object.fromEntries(flagKeys.map((key) => {
+        const n = integer(flags[key], `${field}.policyFlags.${key}`, 2);
+        if (n === 0)
+            invalid(field, n);
+        return [key, n];
+    }));
+    return {
+        ...scope,
+        state: 'initialized',
+        openDay: big(row.openDay, field, wire),
+        enabled: integer(row.enabled, field, 1),
+        controller: integer(row.controller, field, 65535),
+        generationNumber: big(row.generationNumber, field, wire),
+        governance: address(row.governance, field),
+        starbaseSeqId: big(row.starbaseSeqId, field, wire),
+        policy: address(row.policy, field),
+        policyFlags,
+        effectiveParams: feeParams(row.effectiveParams, field),
+        ...(row.generation === undefined
+            ? {}
+            : { generation: address(row.generation, field) }),
+    };
+}
+function xpIntent(value, field) {
+    const row = record(value, field, ['game', 'gameVersion'], ['character', 'structure', 'profile']);
+    if (row.gameVersion !== 2)
+        invalid(field, row.gameVersion);
+    if (row.profile !== undefined && row.character === undefined)
+        invalid(field, row.profile);
+    return {
+        game: address(row.game, field),
+        gameVersion: row.gameVersion,
+        ...(row.profile === undefined
+            ? {}
+            : { profile: address(row.profile, field) }),
+        ...(row.character === undefined
+            ? {}
+            : { character: address(row.character, field) }),
+        ...(row.structure === undefined
+            ? {}
+            : { structure: address(row.structure, field) }),
+    };
+}
+function accountAddresses(value, field, required, optional) {
+    const row = record(value, field, required, optional);
+    return Object.fromEntries(Object.entries(row).map(([key, value]) => [
+        key,
+        address(value, `${field}.${key}`),
+    ]));
+}
+/** Strict nested runtime parsing applies both to factory values and persisted JSON. */
+export function normalizeRuntimeGuard(value, field, wire = false) {
+    const row = record(value, field, [
+        'kind',
+        'address',
+        'intent',
+        'accounts',
+        'describes',
+    ]);
+    const kind = token(row.kind, field, [
+        'democracy-history',
+        'xp-runtime',
+        'governance-fees',
+    ]);
+    const at = address(row.address, `${field}.address`);
+    if (typeof row.describes !== 'string')
+        invalid(field, row.describes);
+    const base = { address: at, describes: row.describes };
+    if (kind === 'democracy-history') {
+        const intent = historyIntent(row.intent, `${field}.intent`, wire);
+        const accounts = accountAddresses(row.accounts, field, ['democracyHistoryHistory'], ['democracyHistoryPolicy', 'democracyHistoryGeneration']);
+        if (at !== intent.address ||
+            accounts.democracyHistoryHistory !== at ||
+            accounts.democracyHistoryPolicy !==
+                (intent.state === 'initialized' ? intent.policy : undefined) ||
+            accounts.democracyHistoryGeneration !==
+                (intent.state === 'initialized' ? intent.generation : undefined))
+            invalid(field, value);
+        return guardOf(kind, base, intent, accounts);
+    }
+    if (kind === 'xp-runtime') {
+        const intent = xpIntent(row.intent, `${field}.intent`);
+        const accounts = accountAddresses(row.accounts, field, [], ['xpBudget', 'xpBudgetConfig', 'xpAccrual']);
+        if (at !== intent.game ||
+            Boolean(accounts.xpBudgetConfig) !== Boolean(intent.character) ||
+            Boolean(accounts.xpBudget) !== Boolean(intent.character) ||
+            Boolean(accounts.xpAccrual) !== Boolean(intent.structure))
+            invalid(field, value);
+        return guardOf(kind, base, intent, accounts);
+    }
+    return normalizeFeeGuard(row, base, field, wire);
+}
+/** Bigints use canonical decimal strings; schema validation excludes arbitrary object graphs. */
+function sameAccounts(a, b) {
+    const left = Object.entries(a);
+    return (left.length === Object.keys(b).length &&
+        left.every(([key, value]) => b[key] === value));
+}
+function changed(guard) {
+    const cause = guard
+        ? `The ${guard.kind} safeguard at ${guard.address} no longer matches current eligibility or account bindings: ${guard.describes}`
+        : 'This instruction has an unsupported layout or lacks matching XP, Democracy-history or fee safeguards, including account addresses and roles.';
+    throw new SageSdkError('ACTION_PRECONDITION_FAILED', `${cause} Refresh the affected gameplay state and recreate this Plan before signing.`);
+}
+/** Resolve canonical accounts again; shared balances and XP counters are not compared. */
+export async function revalidateRuntimeGuards(ctx, guards, freshGameVersions = new Map()) {
+    const histories = new Map();
+    const history = async (scope) => {
+        const key = `${scope.game}:${scope.system}`;
+        let resolved = histories.get(key);
+        if (!resolved) {
+            resolved = await resolveDemocracyHistory(ctx, scope);
+            histories.set(key, resolved);
+        }
+        return resolved;
+    };
+    for (const guard of guards) {
+        if (guard.kind === 'democracy-history') {
+            const current = await history(guard.intent);
+            if (!matchDemocracyHistoryIntent(guard.intent, current.intent) ||
+                !sameAccounts(guard.accounts, current.accounts))
+                changed(guard);
+        }
+        else if (guard.kind === 'xp-runtime') {
+            const current = await resolveXpRuntime(ctx, guard.intent, freshGameVersions);
+            if (!sameAccounts(guard.intent, current.intent) ||
+                !sameAccounts(guard.accounts, current.accounts))
+                changed(guard);
+        }
+        else {
+            const current = await resolveGovernanceFees(ctx, guard.intent.request, await history(guard.intent.request));
+            if (!matchGovernanceFeesIntent(guard.intent, current.intent) ||
+                !sameAccounts(guard.accounts, current.accounts))
+                changed(guard);
+        }
+    }
+}
+function feeQuoteParams(value, field) {
+    const row = record(value, field, ['craftingFeeBps', 'localMarketFeeBps', 'localTreasuryShareBps'], ['treasuryDistributionBps']);
+    return {
+        craftingFeeBps: integer(row.craftingFeeBps, field, 65535),
+        localMarketFeeBps: integer(row.localMarketFeeBps, field, 65535),
+        localTreasuryShareBps: integer(row.localTreasuryShareBps, field, 65535),
+        ...(row.treasuryDistributionBps === undefined
+            ? {}
+            : {
+                treasuryDistributionBps: integer(row.treasuryDistributionBps, field, 65535),
+            }),
+    };
+}
+function normalizeFeeGuard(row, base, field, wire) {
+    const source = record(row.intent, `${field}.intent`, ['request', 'quote'], ['governance', 'currencyCache', 'treasury', 'process']);
+    const request = record(source.request, field, ['game', 'system', 'starbaseSeqId', 'mode'], ['hasHab', 'process']);
+    const mode = token(request.mode, field, [
+        'market',
+        'crafting-start',
+        'crafting-complete',
+    ]);
+    if (request.hasHab !== undefined && typeof request.hasHab !== 'boolean')
+        invalid(field, request.hasHab);
+    const normalizedRequest = {
+        game: address(request.game, field),
+        system: address(request.system, field),
+        starbaseSeqId: big(request.starbaseSeqId, field, wire),
+        mode,
+        ...(request.hasHab === undefined
+            ? {}
+            : { hasHab: request.hasHab }),
+        ...(request.process === undefined
+            ? {}
+            : { process: address(request.process, field) }),
+    };
+    if (base.address !== normalizedRequest.game ||
+        (mode === 'crafting-complete') !== (request.process !== undefined) ||
+        (mode === 'market' && request.hasHab !== undefined))
+        invalid(field, request);
+    let governance;
+    if (source.governance !== undefined) {
+        const state = token(source.governance?.state, field, ['absent', 'initialized']);
+        const g = record(source.governance, field, [
+            'address',
+            'state',
+            ...(state === 'initialized'
+                ? ['version', 'enabled', 'controllerFaction', 'starbaseSeqId']
+                : []),
+        ], state === 'initialized' ? ['activeParams'] : []);
+        if (state === 'initialized' && g.version !== 2 && g.version !== 3)
+            invalid(field, g.version);
+        governance = {
+            address: address(g.address, field),
+            state,
+            ...(state === 'absent'
+                ? {}
+                : {
+                    version: integer(g.version, field, 255),
+                    enabled: integer(g.enabled, field, 1),
+                    controllerFaction: integer(g.controllerFaction, field, 65535),
+                    starbaseSeqId: big(g.starbaseSeqId, field, wire),
+                    ...(g.activeParams === undefined
+                        ? {}
+                        : { activeParams: feeQuoteParams(g.activeParams, field) }),
+                }),
+        };
+    }
+    let currencyCache;
+    if (source.currencyCache !== undefined) {
+        const c = record(source.currencyCache, field, ['address', 'version']);
+        currencyCache = {
+            address: address(c.address, field),
+            version: integer(c.version, field, 255),
+        };
+    }
+    let treasury;
+    if (source.treasury !== undefined) {
+        const state = token(source.treasury?.state, field, ['absent', 'initialized']);
+        const t = record(source.treasury, field, [
+            'address',
+            'state',
+            ...(state === 'initialized' ? ['version', 'governance'] : []),
+        ]);
+        treasury = {
+            address: address(t.address, field),
+            state,
+            ...(state === 'absent'
+                ? {}
+                : {
+                    version: integer(t.version, field, 255),
+                    governance: address(t.governance, field),
+                }),
+        };
+    }
+    let process;
+    if (source.process !== undefined) {
+        const p = record(source.process, field, ['address', 'version'], ['feeRecipient', 'feeGovernance', 'feeSnapshot']);
+        const version = integer(p.version, field, 1);
+        if (version === 0 &&
+            (p.feeRecipient !== undefined ||
+                p.feeGovernance !== undefined ||
+                p.feeSnapshot !== undefined))
+            invalid(field, p);
+        if (version === 1 &&
+            (p.feeRecipient === undefined || p.feeSnapshot === undefined))
+            invalid(field, p);
+        const s = p.feeSnapshot === undefined
+            ? undefined
+            : record(p.feeSnapshot, field, [
+                'craftingFeeBasisPoints',
+                'localMarketFeeBasisPoints',
+                'localTreasuryShareBasisPoints',
+            ]);
+        process = {
+            address: address(p.address, field),
+            version,
+            ...(p.feeRecipient === undefined
+                ? {}
+                : {
+                    feeRecipient: token(p.feeRecipient, field, ['atlas', 'dao-atlas']),
+                }),
+            ...(p.feeGovernance === undefined
+                ? {}
+                : { feeGovernance: address(p.feeGovernance, field) }),
+            ...(s
+                ? {
+                    feeSnapshot: {
+                        craftingFeeBasisPoints: integer(s.craftingFeeBasisPoints, field, 65535),
+                        localMarketFeeBasisPoints: integer(s.localMarketFeeBasisPoints, field, 65535),
+                        localTreasuryShareBasisPoints: integer(s.localTreasuryShareBasisPoints, field, 65535),
+                    },
+                }
+                : {}),
+        };
+    }
+    const q = record(source.quote, field, ['source'], ['params']);
+    const quoteSource = token(q.source, field, [
+        'default',
+        'governance',
+        'history-policy',
+        'history-generation',
+        'history-disabled',
+        'process-snapshot',
+        'legacy-process',
+    ]);
+    if ((quoteSource === 'legacy-process') !== (q.params === undefined))
+        invalid(field, q);
+    const intent = {
+        request: normalizedRequest,
+        ...(governance ? { governance } : {}),
+        ...(currencyCache ? { currencyCache } : {}),
+        ...(treasury ? { treasury } : {}),
+        ...(process ? { process } : {}),
+        quote: {
+            source: quoteSource,
+            ...(q.params === undefined
+                ? {}
+                : { params: feeQuoteParams(q.params, field) }),
+        },
+    };
+    const accounts = accountAddresses(row.accounts, field, [], ['starbaseGovernance', 'currencyCache', 'starbaseTreasury']);
+    if ((mode === 'crafting-complete'
+        ? governance !== undefined ||
+            process?.address !== normalizedRequest.process
+        : process !== undefined || !governance) ||
+        accounts.starbaseGovernance !== governance?.address ||
+        accounts.currencyCache !== currencyCache?.address ||
+        accounts.starbaseTreasury !==
+            (treasury?.state === 'initialized' ? treasury.address : undefined))
+        invalid(field, row);
+    return guardOf('governance-fees', base, intent, accounts);
+}
+/** Orders a runtime guard like every Plan guard: `kind` first, `describes` last. */
+function guardOf(kind, { address, describes }, intent, accounts) {
+    return deepFreeze({ kind, address, intent, accounts, describes });
+}
+function layouts() {
+    return [
+        {
+            kind: 'market',
+            discriminator: PLACE_LOCAL_MARKET_ORDER_DISCRIMINATOR,
+            decoder: getPlaceLocalMarketOrderInstructionDataDecoder,
+            count: 15,
+            game: 4,
+            system: 6,
+            history: 12,
+        },
+        {
+            kind: 'market',
+            discriminator: CANCEL_LOCAL_MARKET_ORDERS_DISCRIMINATOR,
+            decoder: getCancelLocalMarketOrdersInstructionDataDecoder,
+            count: 15,
+            game: 4,
+            system: 6,
+            history: 12,
+        },
+        {
+            kind: 'crafting-start',
+            discriminator: START_CRAFTING_PROCESS_DISCRIMINATOR,
+            decoder: getStartCraftingProcessInstructionDataDecoder,
+            count: 19,
+            game: 5,
+            system: 6,
+            history: 16,
+        },
+        {
+            kind: 'crafting-complete',
+            discriminator: COMPLETE_CRAFTING_PROCESS_DISCRIMINATOR,
+            decoder: getCompleteCraftingProcessInstructionDataDecoder,
+            count: 19,
+            game: 5,
+            system: 6,
+            history: 16,
+        },
+        {
+            kind: 'attack',
+            discriminator: ATTACK_STARBASE_DISCRIMINATOR,
+            decoder: getAttackStarbaseInstructionDataDecoder,
+            count: 32,
+            game: 9,
+            system: 6,
+            history: 29,
+        },
+    ];
+}
+function claimXpLayouts() {
+    return [
+        {
+            discriminator: PLACE_CLAIM_STAKE_BUILDINGS_DISCRIMINATOR,
+            decoder: getPlaceClaimStakeBuildingsInstructionDataDecoder,
+            count: 19,
+            game: 0,
+            structure: 6,
+            accrual: 13,
+        },
+        {
+            discriminator: CANCEL_CLAIM_STAKE_BUILDING_DESIGN_DISCRIMINATOR,
+            decoder: getCancelClaimStakeBuildingDesignInstructionDataDecoder,
+            count: 17,
+            game: 0,
+            structure: 5,
+            accrual: 11,
+        },
+        {
+            discriminator: FINALIZE_BUILDING_CHANGES_DISCRIMINATOR,
+            decoder: getFinalizeBuildingChangesInstructionDataDecoder,
+            count: 20,
+            game: 0,
+            structure: 6,
+            accrual: 14,
+            career: [5, 12, 13],
+        },
+        {
+            discriminator: START_CLAIM_STAKES_FLEET_TRANSFER_DISCRIMINATOR,
+            decoder: getStartClaimStakesFleetTransferInstructionDataDecoder,
+            count: 19,
+            game: 10,
+            structure: 5,
+            accrual: 13,
+        },
+        {
+            discriminator: DECONSTRUCT_CLAIM_STAKE_INSTANCE_DISCRIMINATOR,
+            decoder: getDeconstructClaimStakeInstanceInstructionDataDecoder,
+            count: 22,
+            game: 5,
+            structure: 6,
+            accrual: 19,
+            career: [4, 20, 21],
+            optionalLedger: [20, 21],
+        },
+    ];
+}
+function validateClaimXpInstruction(step, layout, guards, preconditions) {
+    const { accounts: metas, data } = step.instruction;
+    if (!metas || metas.length !== layout.count || !data)
+        changed();
+    try {
+        if (layout.decoder().read(data, 0)[1] !== data.length)
+            changed();
+    }
+    catch {
+        changed();
+    }
+    const game = metas[layout.game].address;
+    const structure = metas[layout.structure].address;
+    const character = layout.career === undefined ? undefined : metas[layout.career[0]].address;
+    const match = (index, address, writable) => {
+        if (address === undefined ||
+            metas[index].address !== address ||
+            metas[index].role !==
+                (writable ? AccountRole.WRITABLE : AccountRole.READONLY))
+            changed();
+    };
+    match(layout.game, game, false);
+    match(layout.structure, structure, true);
+    const xp = guards.find((g) => g.kind === 'xp-runtime' &&
+        g.intent.game === game &&
+        g.intent.structure === structure &&
+        g.intent.character === character);
+    if (!xp) {
+        // An absent ledger stays guarded absent and takes no Character XP budget.
+        const ledger = metas[layout.accrual].address;
+        if (!layout.optionalLedger ||
+            !preconditions.some((g) => g.kind === 'account-absent' && g.address === ledger))
+            changed();
+        match(layout.accrual, ledger, true);
+        for (const index of layout.optionalLedger)
+            match(index, SAGE_PROGRAM_ADDRESS, false);
+        return;
+    }
+    match(layout.accrual, xp.accounts.xpAccrual, true);
+    if (layout.career !== undefined) {
+        const [, budget, config] = layout.career;
+        match(layout.career[0], character, true);
+        match(budget, xp.accounts.xpBudget, true);
+        match(config, xp.accounts.xpBudgetConfig, false);
+    }
+}
+/** Old layouts and unguarded persisted instructions fail before assembly or signing. */
+export function validateRuntimeInstructions(steps, preconditions) {
+    validateCurrencyInstructions(steps, preconditions);
+    const guards = preconditions.filter(isRuntimeGuard);
+    for (const step of steps) {
+        const { instruction } = step;
+        if (instruction.programAddress !== SAGE_PROGRAM_ADDRESS)
+            continue;
+        const claimLayout = claimXpLayouts().find((value) => value.discriminator.every((byte, index) => instruction.data?.[index] === byte));
+        if (claimLayout) {
+            validateClaimXpInstruction(step, claimLayout, guards, preconditions);
+            continue;
+        }
+        const layout = layouts().find((value) => value.discriminator.every((byte, index) => instruction.data?.[index] === byte));
+        if (!layout)
+            continue;
+        const metas = instruction.accounts;
+        if (!metas || metas.length !== layout.count || !instruction.data)
+            changed();
+        try {
+            if (layout.decoder().read(instruction.data, 0)[1] !==
+                instruction.data.length)
+                changed();
+        }
+        catch {
+            changed();
+        }
+        const game = metas[layout.game].address;
+        const system = metas[layout.system].address;
+        const match = (index, expected, writable = false) => {
+            const actual = metas[index];
+            if (actual?.address !== (expected ?? SAGE_PROGRAM_ADDRESS) ||
+                actual.role !==
+                    (expected && writable ? AccountRole.WRITABLE : AccountRole.READONLY))
+                changed();
+        };
+        match(layout.game, game);
+        match(layout.system, system, layout.kind === 'attack');
+        const h = guards.find((g) => g.kind === 'democracy-history' &&
+            g.intent.game === game &&
+            g.intent.system === system &&
+            g.address === metas[layout.history].address);
+        if (!h)
+            changed();
+        match(layout.history, h.accounts.democracyHistoryHistory, layout.kind !== 'crafting-start');
+        match(layout.history + 1, h.accounts.democracyHistoryPolicy);
+        match(layout.history + 2, h.accounts.democracyHistoryGeneration, layout.kind !== 'crafting-start');
+        if (layout.kind !== 'market') {
+            const structureIndex = layout.kind === 'crafting-start'
+                ? 11
+                : layout.kind === 'crafting-complete'
+                    ? 9
+                    : undefined;
+            const structure = structureIndex === undefined ||
+                metas[structureIndex].address === SAGE_PROGRAM_ADDRESS
+                ? undefined
+                : metas[structureIndex].address;
+            const character = layout.kind === 'crafting-start' ? undefined : metas[4].address;
+            const xp = guards.find((g) => g.kind === 'xp-runtime' &&
+                g.intent.game === game &&
+                g.intent.character === character &&
+                g.intent.structure === structure);
+            if (!xp)
+                changed();
+            match(4, metas[4].address, true);
+            if (structureIndex !== undefined)
+                match(structureIndex, structure, true);
+            if (layout.kind !== 'crafting-start') {
+                match(layout.kind === 'attack' ? 23 : 13, xp.accounts.xpBudget, true);
+                match(layout.kind === 'attack' ? 24 : 14, xp.accounts.xpBudgetConfig);
+            }
+            if (layout.kind !== 'attack')
+                match(15, xp.accounts.xpAccrual, true);
+        }
+        if (layout.kind !== 'attack') {
+            const habIndex = layout.kind === 'crafting-start'
+                ? 11
+                : layout.kind === 'crafting-complete'
+                    ? 9
+                    : undefined;
+            const hasHab = habIndex !== undefined &&
+                metas[habIndex].address !== SAGE_PROGRAM_ADDRESS;
+            const fee = guards.find((g) => g.kind === 'governance-fees' &&
+                g.intent.request.game === game &&
+                g.intent.request.system === system &&
+                g.intent.request.mode === layout.kind &&
+                Boolean(g.intent.request.hasHab) === hasHab &&
+                (layout.kind !== 'crafting-complete' ||
+                    g.intent.request.process === metas[10].address));
+            if (!fee)
+                changed();
+            if (layout.kind !== 'crafting-complete')
+                match(layout.kind === 'market' ? 9 : 14, fee.accounts.starbaseGovernance);
+            match(layout.kind === 'market'
+                ? 10
+                : layout.kind === 'crafting-start'
+                    ? 12
+                    : 11, fee.accounts.currencyCache, true);
+            if (layout.kind !== 'crafting-start')
+                match(layout.kind === 'market' ? 11 : 12, fee.accounts.starbaseTreasury, true);
+        }
+    }
+}
+//# sourceMappingURL=runtime-guards.js.map