npm - @fased/fased - Versions diffs - 0.1.64 → 0.1.65 - Mend

@fased/fased 0.1.64 → 0.1.65

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (91) hide show

package/dist/control-ui/index.html CHANGED Viewed

@@ -14,7 +14,7 @@
     <link rel="icon" type="image/png" sizes="32x32" href="./favicon-32.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="./apple-touch-icon.png" />
     <script data-fased-boot-watchdog src="./boot-watchdog.js" defer></script>
-    <script type="module" crossorigin src="./assets/index-ckCxHwjy.js"></script>
+    <script type="module" crossorigin src="./assets/index-D4YMr1fA.js"></script>
     <link rel="stylesheet" crossorigin href="./assets/index-RwVraC3c.css">
   </head>
   <body>

package/dist/control-ui/version.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":"0.1.64"}
1	+ {"version":"0.1.65"}

package/dist/extensions/sat-mining/src/rpc-read.js CHANGED Viewed

@@ -25,6 +25,7 @@ const SAT_DISPUTE_SEED = "sat_dispute";
 const MINING_STAKE_SEED = "mining_stake";
 const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const ADDRESS_LOOKUP_TABLE_PROGRAM_ID = "AddressLookupTab1e1111111111111111111111111";
 function assertDedicatedBondProgramConfigured(env = process.env) {
 	const resolved = resolveSatBondProgramIdFromEnv(env);
 	if (!resolved.trim()) {
@@ -578,7 +579,8 @@ function decodeSatCycleSettlementProgressV2(data, address) {
 		finalizeExclusiveUntilSlot: readU64Number(body, 984),
 		scoreExclusiveUntilSlot: readU64Number(body, 992),
 		distributeExclusiveUntilSlot: readU64Number(body, 1e3),
-		keeperBountyPaidLamports: readU64String(body, 1008)
+		keeperBountyPaidLamports: readU64String(body, 1008),
+		keeperBountyUnpaidLamports: readU64String(body, 1016)
 	};
 }
 function decodeSatTreasuryState(data, address) {
@@ -1269,7 +1271,7 @@ function createReadConnection(solana, rpc) {
 				try {
 					return await callEndpoint(secondary, "fallback", rpc.secondaryUrl);
 				} catch (secondaryError) {
-					throw new Error(`rpc ${method} failed on primary (${String(primaryError instanceof Error ? primaryError.message : primaryError)}) and fallback (${String(secondaryError instanceof Error ? secondaryError.message : secondaryError)})`);
+					throw new Error(`rpc ${method} failed on primary (${String(redactSensitiveUrlLikeString(primaryError instanceof Error ? primaryError.message : String(primaryError)))}) and fallback (${String(redactSensitiveUrlLikeString(secondaryError instanceof Error ? secondaryError.message : String(secondaryError)))})`);
 				}
 			}
 		});
@@ -1312,12 +1314,18 @@ async function resolveBondProgramContext(env) {
 		programId: new solana.PublicKey(SAT_BOND_PROGRAM_ID())
 	};
 }
-const SAT_PROTOCOL_VAULT_ACCOUNT_SPACE = 0;
-const SAT_CYCLE_STATE_ACCOUNT_SPACE = 336;
-const SAT_CYCLE_REGISTRY_META_ACCOUNT_SPACE = 88;
-const SAT_CYCLE_REGISTRY_PAGE_ACCOUNT_SPACE = 2072;
-const SAT_CYCLE_SETTLEMENT_PROGRESS_V2_ACCOUNT_SPACE = 1048;
-const SAT_MINER_CYCLE_ACCOUNT_SPACE = 296;
+const SAT_RENT_ACCOUNT_SPACES = {
+	protocolVault: 0,
+	cycleState: 376,
+	cycleRegistryMeta: 88,
+	cycleRegistryPage: 2072,
+	cycleSettlementProgressV2: 1048,
+	minerCycle: 352,
+	unlockInterval: 80
+};
+function calculateSatRevealSharedRentLamports(params) {
+	return params.cycleSettlementProgressLamports + params.cycleRegistryPageLamports + params.unlockIntervalLamports;
+}
 function normalizeReadRpcConfig(rpc) {
 	return typeof rpc === "string" ? {
 		primaryUrl: rpc,
@@ -1376,7 +1384,7 @@ async function rpcRequestOnce(rpcUrl, method, params) {
 				});
 			});
 			req.setTimeout(satRpcRequestTimeoutMs(), () => {
-				req.destroy(new Error(`rpc ${method} timed out after ${satRpcRequestTimeoutMs()}ms (${rpcUrl})`));
+				req.destroy(new Error(`rpc ${method} timed out after ${satRpcRequestTimeoutMs()}ms (${redactSensitiveUrlLikeString(rpcUrl)})`));
 			});
 			req.on("error", (error) => finishReject(error));
 			req.write(body);
@@ -1422,8 +1430,8 @@ async function rpcRequest(rpc, method, params) {
 			return result;
 		} catch (secondaryError) {
 			markReadRpcFailure(secondaryError, normalized.secondaryUrl);
-			const primaryMessage = primaryError instanceof Error ? primaryError.message : String(primaryError);
-			const secondaryMessage = secondaryError instanceof Error ? secondaryError.message : String(secondaryError);
+			const primaryMessage = redactSensitiveUrlLikeString(primaryError instanceof Error ? primaryError.message : String(primaryError));
+			const secondaryMessage = redactSensitiveUrlLikeString(secondaryError instanceof Error ? secondaryError.message : String(secondaryError));
 			throw new Error(`rpc ${method} failed on primary (${primaryMessage}) and fallback (${secondaryMessage})`);
 		}
 	}
@@ -1569,6 +1577,25 @@ async function inspectSatChainSlot(_config) {
 	const rpc = resolveEffectiveReadRpcConfig();
 	return await rpcRequest(rpc, "getSlot", []);
 }
+async function inspectSatAddressLookupTable(_config, params) {
+	const { solana, connection } = await resolveConnection(process.env);
+	const address = new solana.PublicKey(params.address);
+	const account = await connection.getAccountInfo(address, "confirmed");
+	if (!account) {
+		return null;
+	}
+	if (!account.owner.equals(new solana.PublicKey(ADDRESS_LOOKUP_TABLE_PROGRAM_ID))) {
+		throw new Error("SAT distribution lookup table has the wrong program owner");
+	}
+	const state = solana.AddressLookupTableAccount.deserialize(account.data);
+	return {
+		address: address.toBase58(),
+		authority: state.authority?.toBase58() ?? null,
+		addresses: state.addresses.map((entry) => entry.toBase58()),
+		active: state.deactivationSlot === 18446744073709551615n,
+		lastExtendedSlot: state.lastExtendedSlot
+	};
+}
 async function inspectSatLamportBalance(_config, params) {
 	const rpc = resolveEffectiveReadRpcConfig();
 	return await fetchLamportBalanceRaw(rpc, params.address);
@@ -1728,6 +1755,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	const mint = new solana.PublicKey(SAT_MINT_ADDRESS());
 	const [globalAddress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_global_state")], programId);
 	const [currentCycleAddress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_cycle_state"), encodeU64(currentCycleId)], programId);
+	const [currentSettlementProgressAddress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_cycle_settlement_progress_v2"), encodeU64(currentCycleId)], programId);
 	const [treasuryStateAddress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_treasury_state")], programId);
 	const [treasury] = solana.PublicKey.findProgramAddressSync([Buffer.from("treasury")], programId);
 	const currentMinerCycleAddress = owner ? solana.PublicKey.findProgramAddressSync([
@@ -1745,6 +1773,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	const treasuryAta = deriveAssociatedTokenAddress(solana, treasury, mint);
 	const coreEntries = [
 		["currentCycle", currentCycleAddress],
+		["currentSettlementProgress", currentSettlementProgressAddress],
 		["currentMinerCycle", currentMinerCycleAddress],
 		["claimMinerCycle", claimMinerCycleAddress],
 		["minerCapital", minerCapitalAddress],
@@ -1768,6 +1797,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	const recordFor = (address) => address ? byAddress.get(address.toBase58()) ?? null : null;
 	const globalRecord = recordFor(globalAddress);
 	const currentCycleRecord = recordFor(currentCycleAddress);
+	const currentSettlementProgressRecord = recordFor(currentSettlementProgressAddress);
 	const currentMinerCycleRecord = recordFor(currentMinerCycleAddress);
 	const claimMinerCycleRecord = recordFor(claimMinerCycleAddress);
 	const minerCapitalRecord = recordFor(minerCapitalAddress);
@@ -1776,6 +1806,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	const treasuryAtaRecord = recordFor(treasuryAta);
 	const globalState = globalRecord?.data ? decodeSatGlobalState(globalRecord.data, globalAddress.toBase58()) : null;
 	const currentCycle = currentCycleRecord?.data ? decodeSatCycle(currentCycleRecord.data, currentCycleAddress.toBase58()) : null;
+	const currentSettlementProgress = currentSettlementProgressRecord?.data ? decodeSatCycleSettlementProgressV2(currentSettlementProgressRecord.data, currentSettlementProgressAddress.toBase58()) : null;
 	const currentMinerCycle = currentMinerCycleRecord?.data ? decodeSatMinerCycle(currentMinerCycleRecord.data, currentMinerCycleAddress?.toBase58() ?? "") : null;
 	const claimMinerCycle = claimMinerCycleRecord?.data ? decodeSatMinerCycle(claimMinerCycleRecord.data, claimMinerCycleAddress?.toBase58() ?? "") : null;
 	const minerCapital = minerCapitalRecord?.data ? decodeSatMinerCapital(minerCapitalRecord.data, minerCapitalAddress?.toBase58() ?? "") : null;
@@ -1791,6 +1822,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	} : null;
 	writeRpcCacheValue(`view:global-state:${rpcCacheScope(rpc)}:${globalAddress.toBase58()}`, SAT_RPC_STABLE_VIEW_CACHE_TTL_MS, globalState);
 	writeRpcCacheValue(`view:cycle:${rpcCacheScope(rpc)}:${currentCycleId}`, SAT_RPC_LIVE_VIEW_CACHE_TTL_MS, currentCycle);
+	writeRpcCacheValue(`view:settlement-progress:${rpcCacheScope(rpc)}:${currentCycleId}`, SAT_RPC_LIVE_VIEW_CACHE_TTL_MS, currentSettlementProgress);
 	if (owner && currentMinerCycleAddress) {
 		writeRpcCacheValue(`view:miner-cycle:${rpcCacheScope(rpc)}:${authority}:${currentCycleId}`, SAT_RPC_LIVE_VIEW_CACHE_TTL_MS, currentMinerCycle);
 	}
@@ -1807,6 +1839,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	return {
 		globalState,
 		currentCycle,
+		currentSettlementProgress,
 		currentMinerCycle,
 		claimMinerCycle,
 		minerCapital,
@@ -2172,16 +2205,21 @@ async function inspectSatRentExemptionLamports(config) {
 	const rpc = resolveEffectiveReadRpcConfig();
 	const registryReserveTargetLamports = resolveSatGenesisProfileContract(config.network).registryReserveTargetLamports;
 	return await getOrLoadRpcCacheValue(`view:rent-exemption:${rpcCacheScope(rpc)}:${registryReserveTargetLamports}`, SAT_RPC_RENT_EXEMPTION_CACHE_TTL_MS, async () => {
-		const [protocolVaultLamports, cycleStateLamports, cycleRegistryMetaLamports, cycleRegistryPageLamports, cycleSettlementProgressLamports, minerCycleLamports] = await Promise.all([
-			connection.getMinimumBalanceForRentExemption(SAT_PROTOCOL_VAULT_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_CYCLE_STATE_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_CYCLE_REGISTRY_META_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_CYCLE_REGISTRY_PAGE_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_CYCLE_SETTLEMENT_PROGRESS_V2_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_MINER_CYCLE_ACCOUNT_SPACE)
+		const [protocolVaultLamports, cycleStateLamports, cycleRegistryMetaLamports, cycleRegistryPageLamports, cycleSettlementProgressLamports, minerCycleLamports, unlockIntervalLamports] = await Promise.all([
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.protocolVault),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.cycleState),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.cycleRegistryMeta),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.cycleRegistryPage),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.cycleSettlementProgressV2),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.minerCycle),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.unlockInterval)
 		]);
 		const openCycleLamports = cycleStateLamports + cycleRegistryMetaLamports;
-		const submitCycleSharedLamports = cycleSettlementProgressLamports + cycleRegistryPageLamports;
+		const submitCycleSharedLamports = calculateSatRevealSharedRentLamports({
+			cycleSettlementProgressLamports,
+			cycleRegistryPageLamports,
+			unlockIntervalLamports
+		});
 		return {
 			registryReserveTargetLamports: String(registryReserveTargetLamports),
 			protocolVaultLamports: String(protocolVaultLamports),
@@ -2190,6 +2228,7 @@ async function inspectSatRentExemptionLamports(config) {
 			cycleRegistryPageLamports: String(cycleRegistryPageLamports),
 			cycleSettlementProgressLamports: String(cycleSettlementProgressLamports),
 			minerCycleLamports: String(minerCycleLamports),
+			unlockIntervalLamports: String(unlockIntervalLamports),
 			openCycleLamports: String(openCycleLamports),
 			submitCycleSharedLamports: String(submitCycleSharedLamports),
 			submitCycleSignerLamports: String(minerCycleLamports)
@@ -2454,4 +2493,4 @@ function sortableValue(row, sortBy) {
 }
 //#endregion
-export { inspectSatBondPosition, inspectSatBondStakingDistributor, inspectSatBondStakingPosition, inspectSatChainSlot, inspectSatCycle, inspectSatCycleRegistryMeta, inspectSatMinerCyclesByAddress, invalidateSatReadCaches };
+export { inspectSatAddressLookupTable, inspectSatBondPosition, inspectSatBondStakingDistributor, inspectSatBondStakingPosition, inspectSatChainSlot, inspectSatCycle, inspectSatCycleRegistryMeta, inspectSatMinerCyclesByAddress, invalidateSatReadCaches };

package/dist/extensions/sat-mining/src/solana-submit.js CHANGED Viewed

@@ -7,7 +7,7 @@ import { resolveWalletProviderId } from "../../../wallet/wallet-provider-resolve
 import { createSignerReviewApprovalRequest } from "../../../wallet/wallet-send-approvals.js";
 import "../../../plugin-sdk/sat-runtime.js";
 import { SAT_BOND_INSTRUCTION_DISCRIMINATORS, SAT_INSTRUCTION_DISCRIMINATORS, SAT_PROTOCOL_CONSTANTS, resolveSatGenesisProfileContract } from "./protocol-contract.js";
-import { inspectSatCycle, inspectSatCycleRegistryMeta, inspectSatMinerCyclesByAddress } from "./rpc-read.js";
+import { inspectSatAddressLookupTable, inspectSatChainSlot, inspectSatCycle, inspectSatCycleRegistryMeta, inspectSatMinerCyclesByAddress } from "./rpc-read.js";
 import { decodeHash32 } from "./hash-spec.js";
 import { resolveSatSignerCodec } from "./signer-codec-manifest.js";
 import { buildSatSubmissionOperationKey, claimSatSubmission, digestSatSubmissionIntent, updateSatSubmission, waitForSatSubmissionLease } from "./submission-ledger.js";
@@ -49,6 +49,8 @@ const MINING_STAKE_SEED = "mining_stake";
 const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
 const SLOT_HASHES_SYSVAR_ID = "SysvarS1otHashes111111111111111111111111111";
+const SAT_DISTRIBUTION_LOOKUP_MIN_MINERS = 16;
+const SAT_LOOKUP_TABLE_EXTEND_CHUNK_SIZE = 20;
 const IX = SAT_INSTRUCTION_DISCRIMINATORS;
 const BOND_IX = SAT_BOND_INSTRUCTION_DISCRIMINATORS;
 const VAULT_BOND_ACTIONS = new Set([
@@ -256,6 +258,7 @@ async function buildLocalSignerInstructionRequest(params) {
 			isSigner: key.isSigner,
 			isWritable: key.isWritable
 		})),
+		...params.spec.addressLookupTables?.length ? { addressLookupTables: params.spec.addressLookupTables } : {},
 		...context ? { context } : {}
 	};
 }
@@ -290,8 +293,9 @@ async function requireTypedSatSignerCapabilities(socketPath, intentType) {
 		"signerOwnedStateRecheck",
 		"durableReviewAuthorization"
 	].filter((feature) => !features.has(feature)) : [];
-	if (result.ready !== true || protocol?.current !== 2 || typeof protocol.min !== "number" || protocol.min > 2 || typeof protocol.max !== "number" || protocol.max < 2 || !capabilities?.intentTypes?.includes(intentType) || missingFeatures.length > 0 || intentType === "solana.vaultBondAction" && !features.has("typedVaultBondActions") || missingVaultReviewFeatures.length > 0 || missingStates.length > 0) {
-		throw new Error(`local-socket-signer does not support the required typed SAT protocol-v2 contract${missingFeatures.length > 0 ? `; missing features: ${missingFeatures.join(", ")}` : ""}${missingVaultReviewFeatures.length > 0 ? `; missing reviewed Vault features: ${missingVaultReviewFeatures.join(", ")}` : ""}${missingStates.length > 0 ? `; missing states: ${missingStates.join(", ")}` : ""}`);
+	const missingLookupFeatures = intentType === "solana.satLookupTable" && !features.has("typedSATAddressLookupTables") ? ["typedSATAddressLookupTables"] : [];
+	if (result.ready !== true || protocol?.current !== 2 || typeof protocol.min !== "number" || protocol.min > 2 || typeof protocol.max !== "number" || protocol.max < 2 || !capabilities?.intentTypes?.includes(intentType) || missingFeatures.length > 0 || missingLookupFeatures.length > 0 || intentType === "solana.vaultBondAction" && !features.has("typedVaultBondActions") || missingVaultReviewFeatures.length > 0 || missingStates.length > 0) {
+		throw new Error(`local-socket-signer does not support the required typed SAT protocol-v2 contract${missingFeatures.length > 0 ? `; missing features: ${missingFeatures.join(", ")}` : ""}${missingVaultReviewFeatures.length > 0 ? `; missing reviewed Vault features: ${missingVaultReviewFeatures.join(", ")}` : ""}${missingLookupFeatures.length > 0 ? `; missing SAT lookup features: ${missingLookupFeatures.join(", ")}` : ""}${missingStates.length > 0 ? `; missing states: ${missingStates.join(", ")}` : ""}`);
 	}
 }
 async function reconcileTypedSatOperation(params) {
@@ -320,6 +324,11 @@ function assertSatSignerOperationIdentity(operation, requestId) {
 function signerStateForLedger(state) {
 	return state;
 }
+function assertSatLookupTableAction(value) {
+	if (value !== "create" && value !== "extend" && value !== "deactivate" && value !== "close") {
+		throw new Error(`unsupported SAT lookup-table action ${value}`);
+	}
+}
 var SatSubmissionUnresolvedError = class extends Error {
 	constructor(params) {
 		super(`SAT signer operation ${params.requestId} remains ${params.state}${params.signature ? ` with signature ${params.signature}` : ""}; it is unresolved and must be reconciled with the same idempotency key before any new submission${params.detail ? ` (${params.detail})` : ""}`);
@@ -329,10 +338,22 @@ var SatSubmissionUnresolvedError = class extends Error {
 	}
 };
 async function executeTypedSatIntent(params) {
-	const isVaultBond = params.action !== "cleanupBatch" && VAULT_BOND_ACTIONS.has(params.action);
-	const intentType = isVaultBond ? "solana.vaultBondAction" : "solana.satAction";
+	const isLookupTable = params.lookupTable != null;
+	const isVaultBond = !isLookupTable && params.action !== "cleanupBatch" && VAULT_BOND_ACTIONS.has(params.action);
+	const intentType = isLookupTable ? "solana.satLookupTable" : isVaultBond ? "solana.vaultBondAction" : "solana.satAction";
 	await requireTypedSatSignerCapabilities(params.socketPath, intentType);
-	const intent = isVaultBond ? (() => {
+	const intent = isLookupTable ? (() => {
+		if (params.instruction || params.instructions || !params.lookupTable) {
+			throw new Error("typed SAT lookup-table execution accepts only semantic lookup details");
+		}
+		const action = params.action;
+		assertSatLookupTableAction(action);
+		return {
+			type: "solana.satLookupTable",
+			action,
+			lookupTable: params.lookupTable
+		};
+	})() : isVaultBond ? (() => {
 		if (!params.instruction || params.instructions) {
 			throw new Error("typed Vault bond execution requires exactly one semantic instruction");
 		}
@@ -637,9 +658,171 @@ async function executeTypedSatIntent(params) {
 		signature: operation.signature
 	};
 }
+function assertSatLookupTableEnabled(env) {
+	if (String(env.FASED_SAT_ENABLE_ALT_V0 ?? "").trim() !== "1") {
+		throw new Error("SAT ALT/v0 support is disabled; set FASED_SAT_ENABLE_ALT_V0=1");
+	}
+}
+async function executeTypedSatLookupOperation(params) {
+	return await executeTypedSatIntent({
+		socketPath: params.context.socketPath,
+		walletId: params.context.walletId,
+		action: params.action,
+		lookupTable: {
+			address: params.address,
+			...params.recentSlot == null ? {} : { recentSlot: String(params.recentSlot) },
+			...params.addresses?.length ? { addresses: params.addresses } : {}
+		},
+		cluster: resolveSatCluster(params.cfg),
+		env: params.context.effectiveEnv
+	});
+}
+async function readValidatedSatLookupTable(params) {
+	const state = await inspectSatAddressLookupTable(params.config, { address: params.address });
+	if (!state) {
+		return null;
+	}
+	if (state.authority !== params.authority) {
+		throw new Error("SAT distribution lookup table is not controlled by the Mining signer");
+	}
+	if (!state.active) {
+		throw new Error("SAT distribution lookup table is not active");
+	}
+	return state;
+}
+async function waitForSatLookupTable(params) {
+	let lastError;
+	for (let attempt = 0; attempt < 24; attempt += 1) {
+		try {
+			const state = await readValidatedSatLookupTable(params);
+			if (state) {
+				const currentSlot = await inspectSatChainSlot(params.config);
+				if (!params.requireNextSlot || currentSlot > state.lastExtendedSlot) {
+					return state;
+				}
+			}
+		} catch (error) {
+			lastError = error;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+	throw new Error(`SAT distribution lookup table did not become active for use within 6s${lastError instanceof Error ? `: ${lastError.message}` : ""}`);
+}
+async function ensureSatDistributionLookupTable(params) {
+	assertSatLookupTableEnabled(params.context.effectiveEnv);
+	const desiredAddresses = [...new Set(params.addresses.map((entry) => entry.trim()))].filter(Boolean);
+	if (desiredAddresses.length === 0 || desiredAddresses.length > 256) {
+		throw new Error("SAT distribution lookup table requires 1-256 exact account addresses");
+	}
+	let lookupTable = params.lookupTableAddress?.trim() ?? "";
+	let state = lookupTable ? await readValidatedSatLookupTable({
+		config: params.config,
+		address: lookupTable,
+		authority: params.context.signerAddress
+	}) : null;
+	let created = false;
+	const transactionHashes = [];
+	if (!lookupTable) {
+		const currentSlot = await inspectSatChainSlot(params.config);
+		const recentSlot = Math.max(0, currentSlot - 1);
+		const [, derivedAddress] = params.context.solana.AddressLookupTableProgram.createLookupTable({
+			authority: params.context.signer,
+			payer: params.context.signer,
+			recentSlot
+		});
+		lookupTable = derivedAddress.toBase58();
+		state = await readValidatedSatLookupTable({
+			config: params.config,
+			address: lookupTable,
+			authority: params.context.signerAddress
+		});
+		if (!state) {
+			try {
+				const submitted = await executeTypedSatLookupOperation({
+					context: params.context,
+					cfg: params.cfg,
+					action: "create",
+					address: lookupTable,
+					recentSlot
+				});
+				transactionHashes.push(submitted.signature);
+				created = true;
+			} catch (error) {
+				if (error instanceof SatSubmissionUnresolvedError) {
+					throw error;
+				}
+				try {
+					state = await waitForSatLookupTable({
+						config: params.config,
+						address: lookupTable,
+						authority: params.context.signerAddress,
+						requireNextSlot: false
+					});
+				} catch {
+					throw error;
+				}
+			}
+			state ??= await waitForSatLookupTable({
+				config: params.config,
+				address: lookupTable,
+				authority: params.context.signerAddress,
+				requireNextSlot: false
+			});
+		}
+	}
+	if (!state) {
+		throw new Error("SAT distribution lookup table was not found at the confirmed commitment");
+	}
+	const existing = new Set(state.addresses);
+	const missing = desiredAddresses.filter((entry) => !existing.has(entry));
+	for (let offset = 0; offset < missing.length; offset += SAT_LOOKUP_TABLE_EXTEND_CHUNK_SIZE) {
+		const addresses = missing.slice(offset, offset + SAT_LOOKUP_TABLE_EXTEND_CHUNK_SIZE);
+		try {
+			const submitted = await executeTypedSatLookupOperation({
+				context: params.context,
+				cfg: params.cfg,
+				action: "extend",
+				address: lookupTable,
+				addresses
+			});
+			transactionHashes.push(submitted.signature);
+		} catch (error) {
+			if (error instanceof SatSubmissionUnresolvedError) {
+				throw error;
+			}
+			const concurrentState = await waitForSatLookupTable({
+				config: params.config,
+				address: lookupTable,
+				authority: params.context.signerAddress,
+				requireNextSlot: false
+			}).catch(() => null);
+			if (!concurrentState || addresses.some((address) => !concurrentState.addresses.includes(address))) {
+				throw error;
+			}
+		}
+	}
+	const ready = await waitForSatLookupTable({
+		config: params.config,
+		address: lookupTable,
+		authority: params.context.signerAddress,
+		requireNextSlot: true
+	});
+	for (const address of desiredAddresses) {
+		if (!ready.addresses.includes(address)) {
+			throw new Error(`SAT distribution lookup table did not persist required account ${address}`);
+		}
+	}
+	return {
+		lookupTable,
+		created,
+		extended: missing.length > 0,
+		addressCount: ready.addresses.length,
+		transactionHashes
+	};
+}
 async function submitInstructionViaLocalSigner(params) {
 	const context = await prepareLocalSignerSubmitContext(params.cfg, params.env);
-	const request = await buildLocalSignerInstructionRequest({
+	const baseRequest = await buildLocalSignerInstructionRequest({
 		solana: context.solana,
 		signer: context.signer,
 		env: context.effectiveEnv,
@@ -648,6 +831,23 @@ async function submitInstructionViaLocalSigner(params) {
 	if (!context.walletId) {
 		throw new Error("typed SAT signing requires an explicit mining walletId");
 	}
+	let managedLookupTable;
+	if (params.manageAddressLookupTable) {
+		managedLookupTable = await ensureSatDistributionLookupTable({
+			context: {
+				...context,
+				walletId: context.walletId
+			},
+			cfg: params.cfg,
+			config: params.cfg,
+			lookupTableAddress: params.manageAddressLookupTable.lookupTableAddress,
+			addresses: baseRequest.keys.filter((key) => !key.isSigner).map((key) => key.pubkey)
+		});
+	}
+	const request = managedLookupTable ? {
+		...baseRequest,
+		addressLookupTables: [managedLookupTable.lookupTable]
+	} : baseRequest;
 	const submitted = await executeTypedSatIntent({
 		socketPath: context.socketPath,
 		walletId: context.walletId,
@@ -660,7 +860,17 @@ async function submitInstructionViaLocalSigner(params) {
 		txHash: submitted.signature,
 		signer: context.signerAddress,
 		signerState: submitted.state,
-		requestId: submitted.requestId
+		requestId: submitted.requestId,
+		...request.addressLookupTables?.length ? {
+			transactionVersion: "v0",
+			lookupTableAddress: request.addressLookupTables[0]
+		} : { transactionVersion: "legacy" },
+		...managedLookupTable ? {
+			lookupTableCreated: managedLookupTable.created,
+			lookupTableExtended: managedLookupTable.extended,
+			lookupTableAddressCount: managedLookupTable.addressCount,
+			lookupTableTransactionHashes: managedLookupTable.transactionHashes
+		} : {}
 	};
 }
 async function submitInstruction(params) {
@@ -673,6 +883,8 @@ async function submitInstruction(params) {
 		env: effectiveEnv,
 		data: params.data,
 		programId: params.programId,
+		addressLookupTables: params.addressLookupTables,
+		manageAddressLookupTable: params.manageAddressLookupTable,
 		accountResolver: params.accountResolver
 	});
 }
@@ -2530,10 +2742,13 @@ async function submitSatScoreCyclePage(_config, params) {
 }
 async function submitSatDistributeCyclePage(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
+	const lookupTableAddress = params.lookupTableAddress?.trim() ?? "";
+	const requiresLookupTable = (params.minerCycleAccounts?.length ?? 0) >= SAT_DISTRIBUTION_LOOKUP_MIN_MINERS;
 	return submitInstruction({
 		cfg,
 		env: process.env,
 		data: buildDistributeCyclePageData(params),
+		...lookupTableAddress || requiresLookupTable ? { manageAddressLookupTable: { ...lookupTableAddress ? { lookupTableAddress } : {} } } : {},
 		accountResolver: async (solana, signer) => {
 			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
 			const [satCycleState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_STATE_SEED), encodeU64(params.cycleId)], programId);
@@ -2635,6 +2850,34 @@ async function submitSatDistributeCyclePage(_config, params) {
 		}
 	});
 }
+async function submitSatCleanupDistributionLookupTable(_config, params) {
+	const cfg = loadConfigForSatRuntime(_config);
+	const context = await prepareLocalSignerSubmitContext(cfg, process.env);
+	assertSatLookupTableEnabled(context.effectiveEnv);
+	if (!context.walletId) {
+		throw new Error("typed SAT lookup-table cleanup requires an explicit mining walletId");
+	}
+	const lookupTable = params.lookupTableAddress.trim();
+	if (!lookupTable) {
+		throw new Error("SAT distribution lookup table address is required");
+	}
+	const submitted = await executeTypedSatLookupOperation({
+		context: {
+			...context,
+			walletId: context.walletId
+		},
+		cfg,
+		action: params.action,
+		address: lookupTable
+	});
+	return {
+		lookupTable,
+		action: params.action,
+		transactionHashes: [submitted.signature],
+		signerState: submitted.state,
+		requestId: submitted.requestId
+	};
+}
 async function submitSatClaimCycleRewards(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
 	return submitInstruction({

package/dist/extensions/sat-mining/src/submission-ledger.js CHANGED Viewed

@@ -63,7 +63,7 @@ function buildSatSubmissionOperationKey(intent) {
 			action: candidate.action,
 			keys: candidate.keys
 		};
-	}) : intent.keys;
+	}) : intent.keys ?? intent.lookupTable;
 	return `${action}:${sha256(JSON.stringify(canonicalize(accountShape))).slice(0, 24)}`;
 }
 function normalizeStateKey(value) {

package/dist/plugin-sdk/{audio-preflight-BYxAt775.js → audio-preflight-I4IngVlJ.js} RENAMED Viewed

@@ -1,4 +1,4 @@
-import { Et as isAudioAttachment, St as normalizeMediaAttachments, Tt as runCapability, bt as buildProviderRegistry, wt as resolveMediaAttachmentLocalRoots, xt as createMediaAttachmentCache } from "./config-schema-BOT7kHb6.js";
+import { Et as isAudioAttachment, St as normalizeMediaAttachments, Tt as runCapability, bt as buildProviderRegistry, wt as resolveMediaAttachmentLocalRoots, xt as createMediaAttachmentCache } from "./config-schema-D_8FVI1C.js";
 import "./runtime-2B9_WKoI.js";
 import "./subsystem-DBPNbQDQ.js";
 import { i as logVerbose, s as shouldLogVerbose } from "./globals-B_jjtAje.js";

package/dist/plugin-sdk/channel-plugin-common.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { n as DEFAULT_ACCOUNT_ID, r as normalizeAccountId } from "./session-key--_1zVBRB.js";
 import { Y as ChannelMessageActionContext, n as ChannelPlugin, ut as getChatChannelMeta } from "./types.plugin-BcSBq42x.js";
-import { _ as FasedAgentPluginApi, t as PluginRuntime } from "./types-DWfbSAaM.js";
-import { a as buildChannelConfigSchema, c as emptyPluginConfigSchema, i as setAccountEnabledInConfigSection, n as formatPairingApproveHint, o as applyAccountNameToChannelSection, r as deleteAccountFromConfigSection, s as migrateBaseNameToDefaultAccount, t as PAIRING_APPROVED_MESSAGE } from "./pairing-message-CS-9BHug.js";
+import { _ as FasedAgentPluginApi, t as PluginRuntime } from "./types-BrCpYMxn.js";
+import { a as buildChannelConfigSchema, c as emptyPluginConfigSchema, i as setAccountEnabledInConfigSection, n as formatPairingApproveHint, o as applyAccountNameToChannelSection, r as deleteAccountFromConfigSection, s as migrateBaseNameToDefaultAccount, t as PAIRING_APPROVED_MESSAGE } from "./pairing-message-DHPDFZbC.js";
 export { type ChannelMessageActionContext, type ChannelPlugin, DEFAULT_ACCOUNT_ID, type FasedAgentPluginApi, PAIRING_APPROVED_MESSAGE, type PluginRuntime, applyAccountNameToChannelSection, buildChannelConfigSchema, deleteAccountFromConfigSection, emptyPluginConfigSchema, formatPairingApproveHint, getChatChannelMeta, migrateBaseNameToDefaultAccount, normalizeAccountId, setAccountEnabledInConfigSection };

package/dist/plugin-sdk/{chunk-items-DIRHG2gJ.js → chunk-items-DLQ6_lLK.js} RENAMED Viewed

@@ -1,4 +1,4 @@
-import { an as wrapExternalContent } from "./config-schema-BOT7kHb6.js";
+import { an as wrapExternalContent } from "./config-schema-D_8FVI1C.js";
 //#region src/security/channel-metadata.ts
 const DEFAULT_MAX_CHARS = 800;

package/dist/plugin-sdk/command-status.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { Ht as buildCommandsMessage, Ut as buildCommandsMessagePaginated, Wt as buildHelpMessage } from "./config-schema-BOT7kHb6.js";
+import { Ht as buildCommandsMessage, Ut as buildCommandsMessagePaginated, Wt as buildHelpMessage } from "./config-schema-D_8FVI1C.js";
 import "./runtime-2B9_WKoI.js";
 import "./subsystem-DBPNbQDQ.js";
 import "./globals-B_jjtAje.js";