@invisible-labs/sdk 0.6.0-devnet.2 → 0.6.0-devnet.4

package/dist/lp.js

@@ -1,8 +1,8 @@
-import { isValidLpPositionId, LP_DEFAULT_REFILL_BATCH_SIZE, LP_DEFAULT_TARGET_SHARDS, LP_MAX_TARGET_SHARDS, LP_MAX_REFILL_BATCH_SIZE } from './chunk-TQNNTV5F.js';
-import { publicKey, assertAttested, lamports } from './chunk-SZAYO2L5.js';
-import { requestEnvelope } from './chunk-XUWBGET5.js';
-import { getSessionState } from './chunk-JRMKCE3S.js';
-import { CommandError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-OHIM2YWU.js';
+import { isValidLpPositionId, LP_DEFAULT_REFILL_BATCH_SIZE, LP_DEFAULT_TARGET_SHARDS, LP_MAX_TARGET_SHARDS, LP_MAX_REFILL_BATCH_SIZE } from './chunk-4X5OCCQW.js';
+import { publicKey, assertAttested, lamports } from './chunk-NHEHCUS5.js';
+import { requestEnvelope } from './chunk-UADJCUPK.js';
+import { getSessionState } from './chunk-V5HXJRBW.js';
+import { CommandError, PolicyValidationError, TransportError, RoutingError, LpLifecycleError } from './chunk-GHBQF3A7.js';
 import './chunk-VR6T6OJS.js';
 
 // src/lp/positionCode.ts
@@ -172,14 +172,8 @@ function getCrypto() {
 var SINGLE_DESTINATION_WITHDRAWAL_MESSAGE = "single-destination withdrawal is privacy-degrading; pass allowManyToOne: true to acknowledge";
 var DESTINATION_SOURCE_COUNT_MESSAGE = "LP withdrawal requires one destination per withdrawable source unless allowManyToOne is true";
 var SOURCE_COUNT_MESSAGE = "LP withdrawal source count must be a positive integer";
-function validateLpWithdrawalPlan(input) {
-  const {
-    depositPrincipalLamports,
-    earnedFeeLamports,
-    destinationAddresses,
-    allowManyToOne,
-    sourceCount
-  } = input;
+function validateLpWithdrawalClaim(input) {
+  const { depositPrincipalLamports, earnedFeeLamports } = input;
   lamports(depositPrincipalLamports);
   lamports(earnedFeeLamports);
   if (depositPrincipalLamports === 0 && earnedFeeLamports === 0) {
@@ -188,6 +182,16 @@ function validateLpWithdrawalPlan(input) {
       "LP withdrawal requires a non-zero principal or earned-fee claim"
     );
   }
+}
+function validateLpWithdrawalPlan(input) {
+  const {
+    depositPrincipalLamports,
+    earnedFeeLamports,
+    destinationAddresses,
+    allowManyToOne,
+    sourceCount
+  } = input;
+  validateLpWithdrawalClaim({ depositPrincipalLamports, earnedFeeLamports });
   validateDestinationAddresses(destinationAddresses);
   if (sourceCount !== void 0 && (!Number.isInteger(sourceCount) || sourceCount < 1)) {
     throw new PolicyValidationError("INVALID_WITHDRAWAL_PLAN", SOURCE_COUNT_MESSAGE);
@@ -225,6 +229,7 @@ function validateDestinationAddresses(destinationAddresses) {
 // src/lp/coordinatorClient.ts
 var COMMAND_TTL_MS = 3e4;
 var LP_COMMAND_REQUEST_TIMEOUT_MS = 12e4;
+var LP_DKG_ABORT_REQUEST_TIMEOUT_MS = 1e4;
 var encoder2 = new TextEncoder();
 var protocolPromise = null;
 function createLpCoordinatorClient(session) {
@@ -232,6 +237,9 @@ function createLpCoordinatorClient(session) {
     initDkg(input, auth) {
       return initDkg(session, input, auth);
     },
+    abortDkgSessions(lpPositionId, auth) {
+      return abortDkgSessions(session, lpPositionId, auth);
+    },
     dkgRound1(input, auth) {
       return dkgRound1(session, input, auth);
     },
@@ -241,8 +249,8 @@ function createLpCoordinatorClient(session) {
     openPosition(input, auth) {
       return openPosition(session, input, auth);
     },
-    getPosition(lpPositionId, auth) {
-      return getPosition(session, lpPositionId, auth);
+    getPosition(lpPositionId, auth, options) {
+      return getPosition(session, lpPositionId, auth, options);
     },
     finalizeDkgBatch(input, auth) {
       return finalizeDkgBatch(session, input, auth);
@@ -281,6 +289,21 @@ async function initDkg(session, input, auth) {
   if (response.case !== "dkgInit") throw new Error("Unexpected LP DKG init response");
   return { sessionId: response.value.session_id };
 }
+async function abortDkgSessions(session, lpPositionId, auth) {
+  const response = await requestForPosition(
+    session,
+    lpPositionId,
+    auth,
+    "dkg_abort",
+    {
+      case: "dkgAbort",
+      value: {}
+    },
+    { timeoutMs: LP_DKG_ABORT_REQUEST_TIMEOUT_MS }
+  );
+  if (response.case !== "dkgAbort") throw new Error("Unexpected LP DKG abort response");
+  return { abortedSessionCount: response.value.aborted_session_count };
+}
 async function dkgRound1(session, input, auth) {
   const response = await request(session, auth, "dkg_round1", {
     case: "dkgRound1",
@@ -329,15 +352,23 @@ async function openPosition(session, input, auth) {
   });
   return expectPosition(response);
 }
-async function getPosition(session, lpPositionId, auth) {
+async function getPosition(session, lpPositionId, auth, options = {}) {
   let cursor;
   let position;
   const seenCursors = /* @__PURE__ */ new Set();
   for (; ; ) {
-    const response = await requestForPosition(session, lpPositionId, auth, "position_get", {
-      case: "positionGet",
-      value: cursor === void 0 ? {} : { redemption_history_cursor: cursor }
-    });
+    const pageOptions = lpPositionPageRequestOptions(options);
+    const response = await requestForPosition(
+      session,
+      lpPositionId,
+      auth,
+      "position_get",
+      {
+        case: "positionGet",
+        value: cursor === void 0 ? {} : { redemption_history_cursor: cursor }
+      },
+      pageOptions
+    );
     const page = expectPosition(response);
     const mergedPosition = position === void 0 ? page : mergePositionHistoryPages(position, page);
     position = mergedPosition;
@@ -354,6 +385,18 @@ async function getPosition(session, lpPositionId, auth) {
     cursor = nextCursor;
   }
 }
+function lpPositionPageRequestOptions(options) {
+  if (options.deadlineMs === void 0) return options;
+  const remainingMs = options.deadlineMs - Date.now();
+  if (remainingMs <= 0) {
+    throw new CommandError("REJECTED_STALE_JOB", "LP position observation deadline elapsed");
+  }
+  return {
+    deadlineMs: options.deadlineMs,
+    signal: options.signal,
+    timeoutMs: Math.min(options.timeoutMs ?? LP_COMMAND_REQUEST_TIMEOUT_MS, remainingMs)
+  };
+}
 async function finalizeDkgBatch(session, input, auth) {
   const response = await requestForPosition(session, input.lpPositionId, auth, "dkg_finalize", {
     case: "dkgFinalize",
@@ -442,41 +485,64 @@ async function makeAvailable(session, input, auth) {
 async function executeWithdrawal(session, input, auth) {
   validateLpWithdrawalPlan({
     destinationAddresses: input.destinationAddresses,
-    depositPrincipalLamports: input.depositPrincipalLamports,
-    earnedFeeLamports: input.earnedFeeLamports,
-    allowManyToOne: input.allowManyToOne
+    depositPrincipalLamports: input.withdrawalMode === "max_available" ? 1 : input.depositPrincipalLamports,
+    earnedFeeLamports: input.withdrawalMode === "max_available" ? 0 : input.earnedFeeLamports,
+    // Max mode deliberately does not preview source count. The coordinator
+    // owns the accepted split, so local destination validation must not reject
+    // a one-destination request based on an unknown current source count.
+    allowManyToOne: input.withdrawalMode === "max_available" || input.allowManyToOne
   });
   const response = await requestForPosition(session, input.lpPositionId, auth, "withdraw_request", {
     case: "withdrawRequest",
     value: {
       destination_addresses: input.destinationAddresses,
-      deposit_principal_lamports: input.depositPrincipalLamports,
-      earned_fee_lamports: input.earnedFeeLamports,
+      deposit_principal_lamports: input.withdrawalMode === "max_available" ? 0 : input.depositPrincipalLamports,
+      earned_fee_lamports: input.withdrawalMode === "max_available" ? 0 : input.earnedFeeLamports,
+      withdrawal_mode: input.withdrawalMode,
       requested_at_ms: input.requestedAtMs
     }
   });
   if (response.case !== "withdrawalExecution") {
     throw new Error("Unexpected LP withdrawal execution response");
   }
+  const execution = response.value;
+  if (BigInt(execution.accepted_lamports) !== BigInt(execution.accepted_deposit_principal_lamports) + BigInt(execution.accepted_earned_fee_lamports)) {
+    throw new PolicyValidationError(
+      "INVALID_WITHDRAWAL_PLAN",
+      "Coordinator accepted withdrawal total does not match its principal and fee split"
+    );
+  }
+  if (input.withdrawalMode === "exact" && (execution.accepted_deposit_principal_lamports !== input.depositPrincipalLamports || execution.accepted_earned_fee_lamports !== input.earnedFeeLamports)) {
+    throw new PolicyValidationError(
+      "INVALID_WITHDRAWAL_PLAN",
+      "Coordinator accepted withdrawal split does not match the signed exact claim"
+    );
+  }
   return {
-    withdrawalId: response.value.withdrawal_id,
-    txSignatures: [...response.value.tx_signatures]
+    withdrawalId: execution.withdrawal_id,
+    txSignatures: [...execution.tx_signatures],
+    acceptedLamports: execution.accepted_lamports,
+    acceptedDepositPrincipalLamports: execution.accepted_deposit_principal_lamports,
+    acceptedEarnedFeeLamports: execution.accepted_earned_fee_lamports
   };
 }
 function request(session, auth, action, payload) {
   return requestForPosition(session, auth.lpPositionId, auth, action, payload);
 }
-async function requestForPosition(session, lpPositionId, auth, action, payload) {
+async function requestForPosition(session, lpPositionId, auth, action, payload, options = {}) {
+  const timeoutMs = options.timeoutMs ?? LP_COMMAND_REQUEST_TIMEOUT_MS;
   assertAuthMatchesPosition(lpPositionId, auth);
   const protocol = await loadProtocol();
   const state = getSessionState(session);
   const attestation = state.channel?.attestation;
-  if (!attestation) throw new Error("LP coordinator attestation is not available");
+  if (!attestation) {
+    throw new TransportError("CONNECTION_LOST", "LP coordinator attestation is not available");
+  }
   const command = {
     lp_position_id: lpPositionId,
     action,
     nonce: randomBytes(32),
-    expires_at_ms: Date.now() + COMMAND_TTL_MS,
+    expires_at_ms: Date.now() + Math.min(COMMAND_TTL_MS, timeoutMs),
     coordinator_attestation_hash: await coordinatorAttestationHash(
       attestation.binaryHash,
       attestation.pubkeyHex
@@ -485,8 +551,10 @@ async function requestForPosition(session, lpPositionId, auth, action, payload)
   };
   const signature = await signLpCommandBytes(auth, protocol.encodeLpCommandForSigning(command));
   const { type, payload: envelopePayload } = protocol.lpSignedCommandEnvelope(command, signature);
+  const requestOptions = lpPositionPageRequestOptions(options);
   const envelope = await requestEnvelope(session, type, envelopePayload, {
-    timeoutMs: LP_COMMAND_REQUEST_TIMEOUT_MS
+    timeoutMs: requestOptions.timeoutMs ?? LP_COMMAND_REQUEST_TIMEOUT_MS,
+    signal: requestOptions.signal
   });
   return protocol.asLpCommandResponsePayload(envelope);
 }
@@ -545,6 +613,7 @@ function mapLpActorSync(actorSync) {
     lifetimeEarnedLamports: actorSync.lifetime_earned_lamports ?? 0,
     redeemablePrincipalSourceCount: actorSync.redeemable_principal_source_count ?? 0,
     redeemableFeeSourceCount: actorSync.redeemable_fee_source_count ?? 0,
+    redeemableSourceCount: actorSync.redeemable_source_count,
     pendingReservationCount: actorSync.pending_reservation_count,
     reservedPayoutLamports: actorSync.reserved_payout_lamports,
     estimatedNetworkFeeLamports: actorSync.estimated_network_fee_lamports,
@@ -588,6 +657,7 @@ function mapLpRedemptionHistory(history) {
   return {
     redemptionId: history.redemption_id,
     state: history.state,
+    ...history.withdrawal_mode === void 0 ? {} : { withdrawalMode: history.withdrawal_mode },
     acceptedLamports: history.accepted_lamports,
     acceptedDepositPrincipalLamports: history.accepted_deposit_principal_lamports,
     acceptedEarnedFeeLamports: history.accepted_earned_fee_lamports,
@@ -666,13 +736,17 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-7Y45MCCZ.js');
+  protocolPromise ??= import('./coordinator-ZNLGAYXD.js');
   return protocolPromise;
 }
 
 // src/lp/dkgBatch.ts
 var MAX_LP_DKG_CONCURRENCY = 8;
 var DEFAULT_LP_DKG_CONCURRENCY = MAX_LP_DKG_CONCURRENCY;
+var LP_DKG_WORKER_REQUEST_TIMEOUT_MS = 3e4;
+var LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE = "LP DKG worker request timed out";
+var LP_DKG_ABORT_CLEANUP_TIMEOUT_MS = 1e4;
+var LP_DKG_ABORT_CLEANUP_TIMEOUT_MESSAGE = "LP DKG session cleanup timed out";
 var LP_DKG_COMPLETED_SHARD_POLL_INTERVAL_MS = 500;
 var LP_DKG_COMPLETED_SHARD_POLL_TIMEOUT_MS = 5 * 6e4 + 15e3;
 var LP_DKG_ACTIVE_SESSION_RETRY_INTERVAL_MS = 2e3;
@@ -693,11 +767,20 @@ async function createLpDkgBatch(input) {
     return addresses2;
   }
   const workerCount = resolveConcurrency(input.count, input.concurrency);
-  const workers = Array.from({ length: workerCount }, () => createWorker(input.workerFactory));
+  const workers = [];
+  let workersTerminated = false;
+  const terminateWorkers = () => {
+    if (workersTerminated) return;
+    workersTerminated = true;
+    workers.forEach((worker) => worker.terminate());
+  };
   const addresses = new Array(input.count);
   let completed = 0;
   let nextOffset = 0;
   try {
+    for (let index = 0; index < workerCount; index += 1) {
+      workers.push(createWorker(input.workerFactory));
+    }
     await Promise.all(
       workers.map(async (worker) => {
         for (; ; ) {
@@ -717,8 +800,34 @@ async function createLpDkgBatch(input) {
       })
     );
     return addresses;
+  } catch (error) {
+    terminateWorkers();
+    if (!isLpDkgSessionCoordinationError(error)) {
+      await abortDkgSessionsAfterFailure(input);
+    }
+    throw error;
   } finally {
-    workers.forEach((worker) => worker.terminate());
+    terminateWorkers();
+  }
+}
+async function abortDkgSessionsAfterFailure(input) {
+  const abortDkgSessions2 = input.client.abortDkgSessions;
+  if (typeof abortDkgSessions2 !== "function") return;
+  let timeoutId;
+  try {
+    const cleanupTimeout = new Promise((_, reject) => {
+      timeoutId = globalThis.setTimeout(
+        () => reject(new Error(LP_DKG_ABORT_CLEANUP_TIMEOUT_MESSAGE)),
+        LP_DKG_ABORT_CLEANUP_TIMEOUT_MS
+      );
+    });
+    await Promise.race([
+      abortDkgSessions2.call(input.client, input.lpPositionId, input.auth),
+      cleanupTimeout
+    ]);
+  } catch {
+  } finally {
+    if (timeoutId !== void 0) globalThis.clearTimeout(timeoutId);
   }
 }
 async function createLpDkgShard(input, worker, index) {
@@ -802,6 +911,7 @@ async function getCompletedShardAddress(input, index) {
 }
 function workerRequest(worker, request2) {
   return new Promise((resolve, reject) => {
+    let timeoutId;
     const onMessage = (event) => {
       const message = event.data;
       if (message.id !== request2.id) return;
@@ -817,12 +927,22 @@ function workerRequest(worker, request2) {
       reject(new Error(event.message));
     };
     const cleanup = () => {
+      if (timeoutId !== void 0) globalThis.clearTimeout(timeoutId);
       worker.removeEventListener("message", onMessage);
       worker.removeEventListener("error", onError);
     };
     worker.addEventListener("message", onMessage);
     worker.addEventListener("error", onError);
-    worker.postMessage(request2);
+    timeoutId = globalThis.setTimeout(() => {
+      cleanup();
+      reject(new Error(LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE));
+    }, LP_DKG_WORKER_REQUEST_TIMEOUT_MS);
+    try {
+      worker.postMessage(request2);
+    } catch (error) {
+      cleanup();
+      reject(error instanceof Error ? error : new Error(String(error)));
+    }
   });
 }
 function createWorker(workerFactory) {
@@ -844,6 +964,13 @@ function isLpDkgCompletedOrVisibleError(error) {
 function isLpDkgActiveSessionError(error) {
   return error instanceof Error && error.message.includes("LP DKG session already active for position index");
 }
+function isLpDkgIndexDriftError(error) {
+  if (!(error instanceof Error)) return false;
+  return error.message.includes("LP DKG index") && error.message.includes("already exists for position") || error.message.includes("LP DKG expected index");
+}
+function isLpDkgSessionCoordinationError(error) {
+  return isLpDkgActiveSessionError(error) || isLpDkgIndexDriftError(error);
+}
 function resolveConcurrency(count, requested) {
   if (count <= 0) return 0;
   const concurrency = requested ?? DEFAULT_LP_DKG_CONCURRENCY;
@@ -867,6 +994,8 @@ var LP_DKG_ACTIVE_SESSION_RETRY_DELAY_MS = 2e3;
 var LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS2 = 5 * 6e4 + 15e3;
 var LP_WITHDRAWAL_CONFIRMATION_POLL_INTERVAL_MS = 3e3;
 var LP_WITHDRAWAL_CONFIRMATION_TIMEOUT_MS = 15 * 6e4;
+var LP_WITHDRAWAL_READINESS_RETRY_DELAY_MS = 1e3;
+var LP_WITHDRAWAL_READINESS_RETRY_ATTEMPTS = 30;
 var LP_TOP_UP_WAIT_POLL_INTERVAL_MS = 1e3;
 var LP_REDEMPTION_HISTORY_OPEN_STATES = /* @__PURE__ */ new Set([
   "requested",
@@ -882,8 +1011,9 @@ var WITHDRAWAL_MISSING_RECORD_MESSAGE = "LP withdrawal record is missing";
 var WITHDRAWAL_RECORD_MISMATCH_MESSAGE = "LP withdrawal record does not match this confirmation request";
 var WITHDRAWAL_NO_LAMPORTS_MESSAGE = "LP redemption did not land any lamports on-chain";
 var WITHDRAWAL_HISTORY_MISMATCH_MESSAGE = "LP redemption history does not match this request";
+var LP_WITHDRAWAL_UNRESOLVED_FUNDING_MESSAGE = "LP position has unresolved funding shards before redemption";
 var UNSUPPORTED_FEE_POLICY_MESSAGE = "LP fee policy overrides are not advertised by the coordinator";
-var FEE_SOURCE_COUNT_UNAVAILABLE_MESSAGE = "LP earned-fee source count is not available; pass allowManyToOne: true to acknowledge many-to-one withdrawal risk";
+var LP_FEE_SOURCE_COUNT_UNAVAILABLE_MESSAGE = "LP earned-fee source count is not available; pass allowManyToOne: true to acknowledge many-to-one withdrawal risk";
 var LpRedemptionReconcilingError = class extends LpLifecycleError {
   constructor() {
     super("LP_REDEMPTION_RECONCILING", LP_REDEMPTION_RECONCILING_MESSAGE);
@@ -902,6 +1032,16 @@ function isLpRedemptionReconcilingError(error) {
 function isLpPositionAuthMissingError(error) {
   return error instanceof LpPositionAuthMissingError || error instanceof Error && error.message === LP_MISSING_POSITION_CODE_MESSAGE;
 }
+function previewLpWithdrawalPlan(position, args = {}) {
+  const claim = resolveWithdrawalClaim(position, args);
+  return {
+    ...claim,
+    sourceCount: lpWithdrawalSourceCountForClaim(position, {
+      ...claim,
+      allowManyToOne: args.allowManyToOne
+    })
+  };
+}
 var lifecycleClients = /* @__PURE__ */ new WeakMap();
 function createLpLifecycleClient(session, runtime = {}) {
   const state = {
@@ -931,6 +1071,20 @@ function createLpLifecycleClient(session, runtime = {}) {
     const auth = requireAuth(positionId);
     return rememberPosition(await client.getPosition(positionId, auth));
   };
+  const executeWithdrawalAfterFundingReadiness = async (positionId, input, auth) => {
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await client.executeWithdrawal(input, auth);
+      } catch (error) {
+        const retryable = error instanceof CommandError && error.message.includes(LP_WITHDRAWAL_UNRESOLVED_FUNDING_MESSAGE);
+        if (!retryable || attempt >= LP_WITHDRAWAL_READINESS_RETRY_ATTEMPTS - 1) {
+          throw error;
+        }
+        await sleep2(LP_WITHDRAWAL_READINESS_RETRY_DELAY_MS);
+        await client.reconcileFunding(positionId, auth).catch(() => void 0);
+      }
+    }
+  };
   const completeDkgBatch2 = async (positionId, options = {}) => {
     assertAttested(session);
     const auth = requireAuth(positionId);
@@ -985,7 +1139,7 @@ function createLpLifecycleClient(session, runtime = {}) {
           activeSessionRetryStartedAtMs = null;
           continue;
         }
-        if (!isLpDkgActiveSessionError2(error)) throw error;
+        if (!isLpDkgActiveSessionError(error)) throw error;
         const currentTime = nowMs();
         activeSessionRetryStartedAtMs ??= currentTime;
         if (currentTime - activeSessionRetryStartedAtMs >= LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS2) {
@@ -1028,7 +1182,12 @@ function createLpLifecycleClient(session, runtime = {}) {
     async recoverPosition(args) {
       const auth = await deriveLpPositionCodeAuth(args.code);
       rememberAuth(auth);
-      const position = rememberPosition(await client.getPosition(auth.lpPositionId, auth));
+      const position = rememberPosition(
+        await client.getPosition(auth.lpPositionId, auth, {
+          deadlineMs: args.deadlineMs,
+          signal: args.signal
+        })
+      );
       assertPositionMatchesAuth(position, auth);
       return position;
     },
@@ -1163,7 +1322,10 @@ function createLpLifecycleClient(session, runtime = {}) {
       if (existingRedemption !== void 0) {
         const execution2 = {
           withdrawalId: existingRedemption.redemptionId,
-          txSignatures: [...existingRedemption.txSignatures]
+          txSignatures: [...existingRedemption.txSignatures],
+          acceptedLamports: existingRedemption.acceptedLamports,
+          acceptedDepositPrincipalLamports: existingRedemption.acceptedDepositPrincipalLamports,
+          acceptedEarnedFeeLamports: existingRedemption.acceptedEarnedFeeLamports
         };
         const redemption2 = {
           ...buildLpRedemptionRecord({
@@ -1183,38 +1345,44 @@ function createLpLifecycleClient(session, runtime = {}) {
         state.redemptions.set(execution2.withdrawalId, redemption2);
         return { execution: execution2, position: before, redemption: redemption2 };
       }
-      const claim = resolveWithdrawalClaim(before, args);
-      const sourceCount = lpWithdrawalSourceCountForClaim(before, {
-        ...claim,
-        allowManyToOne: args.allowManyToOne
-      });
-      const validationInput = {
-        lpPositionId: positionId,
-        destinationAddresses: args.destinationAddresses,
-        depositPrincipalLamports: claim.depositPrincipalLamports,
-        earnedFeeLamports: claim.earnedFeeLamports,
-        requestedAtMs: nowMs(),
-        allowManyToOne: args.allowManyToOne ?? false,
-        sourceCount
-      };
-      validateLpWithdrawalPlan(validationInput);
-      const execution = await client.executeWithdrawal(
+      const preview = args.withdrawalMode === "exact" ? previewLpWithdrawalPlan(before, args) : void 0;
+      const requestedAtMs = nowMs();
+      if (args.withdrawalMode === "exact") {
+        validateLpWithdrawalPlan({
+          destinationAddresses: args.destinationAddresses,
+          depositPrincipalLamports: preview.depositPrincipalLamports,
+          earnedFeeLamports: preview.earnedFeeLamports,
+          allowManyToOne: args.allowManyToOne ?? false,
+          sourceCount: preview.sourceCount
+        });
+      }
+      const execution = await executeWithdrawalAfterFundingReadiness(
+        positionId,
         {
-          lpPositionId: validationInput.lpPositionId,
-          destinationAddresses: validationInput.destinationAddresses,
-          depositPrincipalLamports: validationInput.depositPrincipalLamports,
-          earnedFeeLamports: validationInput.earnedFeeLamports,
-          requestedAtMs: validationInput.requestedAtMs,
-          allowManyToOne: args.allowManyToOne === true || sourceCount === 1
+          lpPositionId: positionId,
+          destinationAddresses: args.destinationAddresses,
+          depositPrincipalLamports: args.withdrawalMode === "max_available" ? 0 : preview.depositPrincipalLamports,
+          earnedFeeLamports: args.withdrawalMode === "max_available" ? 0 : preview.earnedFeeLamports,
+          withdrawalMode: args.withdrawalMode,
+          requestedAtMs,
+          allowManyToOne: args.allowManyToOne === true || preview?.sourceCount === 1
         },
         auth
       );
+      const acceptedLamports = execution.acceptedLamports;
+      if (args.withdrawalMode === "max_available" && acceptedLamports === void 0) {
+        throw new PolicyValidationError(
+          "INVALID_WITHDRAWAL_PLAN",
+          "LP redemption response did not include the sealed accepted amount"
+        );
+      }
+      const acceptedAmount = acceptedLamports ?? preview.depositPrincipalLamports + preview.earnedFeeLamports;
       const pendingRedemption = buildLpRedemptionRecord({
         execution,
         position: before,
         destinationAddresses: args.destinationAddresses,
-        acceptedLamports: claim.depositPrincipalLamports + claim.earnedFeeLamports,
-        requestedTargetLamports: (before.actorSync?.withdrawalRequestedLamports ?? 0) + claim.depositPrincipalLamports + claim.earnedFeeLamports,
+        acceptedLamports: acceptedAmount,
+        requestedTargetLamports: (before.actorSync?.withdrawalRequestedLamports ?? 0) + acceptedAmount,
         landedBaselineLamports: before.actorSync?.withdrawalLandedLamports ?? 0,
         landedFeeBaselineLamports: before.actorSync?.withdrawalLandedFeeLamports ?? 0,
         txSignatureBaseline: before.actorSync?.withdrawalTxHashes ?? [],
@@ -1235,10 +1403,32 @@ function createLpLifecycleClient(session, runtime = {}) {
         options
       });
       state.redemptions.set(record.redemptionId, record);
-      const deadlineMs = nowMs() + (runtime.withdrawalConfirmationTimeoutMs ?? LP_WITHDRAWAL_CONFIRMATION_TIMEOUT_MS);
+      const deadlineMs = options.deadlineMs ?? nowMs() + (runtime.withdrawalConfirmationTimeoutMs ?? LP_WITHDRAWAL_CONFIRMATION_TIMEOUT_MS);
       const pollIntervalMs = runtime.withdrawalConfirmationPollIntervalMs ?? LP_WITHDRAWAL_CONFIRMATION_POLL_INTERVAL_MS;
       for (; ; ) {
-        const position = rememberPosition(await client.getPosition(positionId, auth));
+        throwIfWithdrawalConfirmationAborted(options.signal);
+        if (nowMs() >= deadlineMs) {
+          markLpRedemptionReconciling(state, record, options);
+        }
+        const remainingMs = deadlineMs - nowMs();
+        if (remainingMs <= 0) {
+          markLpRedemptionReconciling(state, record, options);
+        }
+        let position;
+        try {
+          position = rememberPosition(
+            await client.getPosition(positionId, auth, {
+              deadlineMs,
+              signal: options.signal
+            })
+          );
+        } catch (error) {
+          if (isLpPositionObservationDeadlineError(error, deadlineMs, nowMs)) {
+            markLpRedemptionReconciling(state, record, options);
+          }
+          throw error;
+        }
+        throwIfWithdrawalConfirmationAborted(options.signal);
         options.onPosition?.(position);
         const reconciled = reconcileLpRedemptionFromActorSync(record, position);
         record = reconciled;
@@ -1254,12 +1444,10 @@ function createLpLifecycleClient(session, runtime = {}) {
         if (reconciled.status === "failed") {
           throw new Error(reconciled.error ?? WITHDRAWAL_NO_LAMPORTS_MESSAGE);
         }
-        if (nowMs() > deadlineMs) {
-          state.redemptions.set(record.redemptionId, { ...reconciled, status: "reconciling" });
-          options.onRedemptionUpdate?.({ ...reconciled, status: "reconciling" });
-          throw new LpRedemptionReconcilingError();
+        if (nowMs() >= deadlineMs) {
+          markLpRedemptionReconciling(state, reconciled, options);
         }
-        await sleep2(pollIntervalMs);
+        await sleepWithAbort(sleep2, pollIntervalMs, options.signal);
       }
     },
     async withdrawFees(_positionId, args) {
@@ -1368,10 +1556,12 @@ function isLpPositionReadyForInitialFunding(position) {
 }
 function resolveWithdrawalClaim(position, args) {
   if (args.depositPrincipalLamports !== void 0 || args.earnedFeeLamports !== void 0) {
-    return {
+    const claim = {
       depositPrincipalLamports: args.depositPrincipalLamports ?? 0,
       earnedFeeLamports: args.earnedFeeLamports ?? 0
     };
+    validateLpWithdrawalClaim(claim);
+    return claim;
   }
   const legacyDepositPrincipalLamports = position.shards.filter((shard) => shard.status === "AVAILABLE" && shard.amountLamports > 0).reduce((sum, shard) => sum + shard.amountLamports, 0);
   const actorRedeemablePrincipalLamports = Math.max(
@@ -1397,11 +1587,11 @@ function resolveWithdrawalClaim(position, args) {
   return { depositPrincipalLamports, earnedFeeLamports };
 }
 function findOpenRedemptionHistory(position, args) {
-  const hasExplicitClaim = args.depositPrincipalLamports !== void 0 || args.earnedFeeLamports !== void 0;
+  const hasExplicitClaim = args.withdrawalMode === "exact";
   const requestedPrincipalLamports = args.depositPrincipalLamports ?? 0;
   const requestedFeeLamports = args.earnedFeeLamports ?? 0;
   return position.actorSync?.redemptionHistory?.find(
-    (history) => LP_REDEMPTION_HISTORY_OPEN_STATES.has(history.state) && history.detailsTruncated !== true && sameStringList(history.destinationAddresses, args.destinationAddresses) && (!hasExplicitClaim || history.acceptedDepositPrincipalLamports === requestedPrincipalLamports && history.acceptedEarnedFeeLamports === requestedFeeLamports)
+    (history) => LP_REDEMPTION_HISTORY_OPEN_STATES.has(history.state) && history.detailsTruncated !== true && (history.withdrawalMode ?? "exact") === args.withdrawalMode && sameStringList(history.destinationAddresses, args.destinationAddresses) && (!hasExplicitClaim || history.acceptedDepositPrincipalLamports === requestedPrincipalLamports && history.acceptedEarnedFeeLamports === requestedFeeLamports)
   );
 }
 function hasActorSyncLpActivity(sync) {
@@ -1423,11 +1613,25 @@ function hasActorRedeemableProjection(sync) {
   return sync?.redeemableProjectionAvailable === true;
 }
 function validateExplicitWithdrawalInput(args) {
-  if (args.depositPrincipalLamports === void 0 && args.earnedFeeLamports === void 0) return;
+  if (args.withdrawalMode === "max_available") {
+    if (args.depositPrincipalLamports !== void 0 || args.earnedFeeLamports !== void 0) {
+      throw new PolicyValidationError(
+        "INVALID_WITHDRAWAL_PLAN",
+        "max_available withdrawal must not carry exact bucket claims"
+      );
+    }
+    return;
+  }
+  if (args.depositPrincipalLamports === void 0 || args.earnedFeeLamports === void 0) {
+    throw new PolicyValidationError(
+      "INVALID_WITHDRAWAL_PLAN",
+      "exact withdrawal requires both bucket claims"
+    );
+  }
   validateLpWithdrawalPlan({
     destinationAddresses: args.destinationAddresses,
-    depositPrincipalLamports: args.depositPrincipalLamports ?? 0,
-    earnedFeeLamports: args.earnedFeeLamports ?? 0,
+    depositPrincipalLamports: args.depositPrincipalLamports,
+    earnedFeeLamports: args.earnedFeeLamports,
     allowManyToOne: args.allowManyToOne,
     sourceCount: args.destinationAddresses.length
   });
@@ -1460,6 +1664,13 @@ function resolveWithdrawalRecord({
   };
 }
 function lpWithdrawalSourceCountForClaim(position, claim) {
+  const actorSync = position.actorSync;
+  const actorRedeemablePrincipalLamports = actorSync?.redeemablePrincipalLamports ?? 0;
+  const actorRedeemableFeeLamports = actorSync?.redeemableFeeLamports ?? 0;
+  const actorRedeemableSourceCount = actorSync?.redeemableSourceCount;
+  if (actorSync?.redeemableProjectionAvailable === true && claim.depositPrincipalLamports === actorRedeemablePrincipalLamports && claim.earnedFeeLamports === actorRedeemableFeeLamports && actorRedeemableSourceCount !== void 0) {
+    return actorRedeemableSourceCount;
+  }
   let remainingPrincipalLamports = claim.depositPrincipalLamports;
   let principalSourceCount = 0;
   const principalCandidates = [...position.shards].filter((shard) => shard.status === "AVAILABLE" && shard.amountLamports > 0).sort((left, right) => left.shardId.localeCompare(right.shardId));
@@ -1468,7 +1679,6 @@ function lpWithdrawalSourceCountForClaim(position, claim) {
     principalSourceCount += 1;
     remainingPrincipalLamports -= shard.amountLamports;
   }
-  const actorRedeemablePrincipalLamports = position.actorSync?.redeemablePrincipalLamports ?? 0;
   const actorRedeemablePrincipalSourceCount = position.actorSync?.redeemablePrincipalSourceCount ?? 0;
   if (claim.depositPrincipalLamports > 0 && position.actorSync?.redeemableProjectionAvailable === true && actorRedeemablePrincipalLamports >= claim.depositPrincipalLamports && actorRedeemablePrincipalSourceCount > 0) {
     principalSourceCount = actorRedeemablePrincipalSourceCount;
@@ -1477,7 +1687,7 @@ function lpWithdrawalSourceCountForClaim(position, claim) {
   if (claim.earnedFeeLamports > 0 && observedEarnedFeeSourceCount < 1 && claim.allowManyToOne !== true) {
     throw new PolicyValidationError(
       "INVALID_WITHDRAWAL_PLAN",
-      FEE_SOURCE_COUNT_UNAVAILABLE_MESSAGE
+      LP_FEE_SOURCE_COUNT_UNAVAILABLE_MESSAGE
     );
   }
   const earnedFeeSourceCount = claim.earnedFeeLamports > 0 ? Math.max(1, observedEarnedFeeSourceCount) : 0;
@@ -1617,13 +1827,6 @@ function sameStringList(left, right) {
 function uniqueStrings(values) {
   return Array.from(new Set(values));
 }
-function isLpDkgActiveSessionError2(error) {
-  return error instanceof Error && error.message.includes("LP DKG session already active for position index");
-}
-function isLpDkgIndexDriftError(error) {
-  if (!(error instanceof Error)) return false;
-  return error.message.includes("LP DKG index") && error.message.includes("already exists for position") || error.message.includes("LP DKG expected index");
-}
 function clonePosition(position) {
   return {
     ...position,
@@ -1650,6 +1853,30 @@ function throwIfTopUpWaitAborted(signal) {
   if (signal?.aborted !== true) return;
   throw new DOMException("LP top-up wait aborted", "AbortError");
 }
+function throwIfWithdrawalConfirmationAborted(signal) {
+  if (signal?.aborted !== true) return;
+  throw new DOMException("LP withdrawal confirmation wait aborted", "AbortError");
+}
+function markLpRedemptionReconciling(state, record, options) {
+  const reconciling = { ...record, status: "reconciling" };
+  state.redemptions.set(record.redemptionId, reconciling);
+  options.onRedemptionUpdate?.(reconciling);
+  throw new LpRedemptionReconcilingError();
+}
+function isLpPositionObservationDeadlineError(error, deadlineMs, nowMs) {
+  return error instanceof CommandError && error.code === "REJECTED_STALE_JOB" && nowMs() >= deadlineMs;
+}
+function sleepWithAbort(sleep2, delayMs, signal) {
+  if (signal === void 0) return sleep2(delayMs);
+  throwIfWithdrawalConfirmationAborted(signal);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(new DOMException("LP withdrawal confirmation wait aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    void sleep2(delayMs).then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  });
+}
 function defaultSleep(delayMs) {
   return new Promise((resolve) => {
     globalThis.setTimeout(resolve, delayMs);
@@ -1706,6 +1933,6 @@ function listPositions(session) {
   return defaultLpLifecycleClient(session).listPositions();
 }
 
-export { LP_COMMAND_REQUEST_TIMEOUT_MS, LP_MISSING_POSITION_CODE_MESSAGE, LP_REDEMPTION_RECONCILING_MESSAGE, bytesToHex, completeDkgBatch, confirmPositionCodeSaved, createLpCoordinatorClient, createLpDkgBatch, createLpLifecycleClient, createPosition, defaultLpLifecycleClient, deriveLpPositionCodeAuth, generateLpPositionCode, isLpPositionAuthMissingError, isLpRedemptionReconcilingError, listPositions, normalizeLpPositionCode, prepareInitialFunding, prepareTopUp2 as prepareTopUp, reconcileFunding2 as reconcileFunding, recoverPosition, refill, refreshPosition, signLpCommandBytes, waitForTopUp, waitForWithdrawalConfirmation, withdrawFees, withdrawPosition };
+export { LP_COMMAND_REQUEST_TIMEOUT_MS, LP_DKG_ABORT_CLEANUP_TIMEOUT_MS, LP_DKG_ABORT_REQUEST_TIMEOUT_MS, LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE, LP_DKG_WORKER_REQUEST_TIMEOUT_MS, LP_FEE_SOURCE_COUNT_UNAVAILABLE_MESSAGE, LP_MISSING_POSITION_CODE_MESSAGE, LP_REDEMPTION_RECONCILING_MESSAGE, bytesToHex, completeDkgBatch, confirmPositionCodeSaved, createLpCoordinatorClient, createLpDkgBatch, createLpLifecycleClient, createPosition, defaultLpLifecycleClient, deriveLpPositionCodeAuth, generateLpPositionCode, isLpPositionAuthMissingError, isLpRedemptionReconcilingError, listPositions, normalizeLpPositionCode, prepareInitialFunding, prepareTopUp2 as prepareTopUp, previewLpWithdrawalPlan, reconcileFunding2 as reconcileFunding, recoverPosition, refill, refreshPosition, signLpCommandBytes, waitForTopUp, waitForWithdrawalConfirmation, withdrawFees, withdrawPosition };
 //# sourceMappingURL=lp.js.map
 //# sourceMappingURL=lp.js.map