@invisible-labs/sdk 0.6.0-devnet.3 → 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-4X5OCCQW.js';
 import { publicKey, assertAttested, lamports } from './chunk-NHEHCUS5.js';
-import { requestEnvelope } from './chunk-QQSI3ZD7.js';
+import { requestEnvelope } from './chunk-UADJCUPK.js';
 import { getSessionState } from './chunk-V5HXJRBW.js';
-import { CommandError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-GHBQF3A7.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);
@@ -245,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);
@@ -295,7 +299,7 @@ async function abortDkgSessions(session, lpPositionId, auth) {
       case: "dkgAbort",
       value: {}
     },
-    LP_DKG_ABORT_REQUEST_TIMEOUT_MS
+    { 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 };
@@ -348,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;
@@ -373,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",
@@ -461,36 +485,59 @@ 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, timeoutMs = LP_COMMAND_REQUEST_TIMEOUT_MS) {
+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,
@@ -504,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
+    timeoutMs: requestOptions.timeoutMs ?? LP_COMMAND_REQUEST_TIMEOUT_MS,
+    signal: requestOptions.signal
   });
   return protocol.asLpCommandResponsePayload(envelope);
 }
@@ -564,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,
@@ -607,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,
@@ -685,7 +736,7 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-VVJ33WF2.js');
+  protocolPromise ??= import('./coordinator-ZNLGAYXD.js');
   return protocolPromise;
 }
 
@@ -962,7 +1013,7 @@ var WITHDRAWAL_NO_LAMPORTS_MESSAGE = "LP redemption did not land any lamports on
 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);
@@ -981,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 = {
@@ -1121,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;
     },
@@ -1256,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({
@@ -1276,39 +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 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 ?? [],
@@ -1329,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;
@@ -1348,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) {
@@ -1462,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(
@@ -1491,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) {
@@ -1517,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
   });
@@ -1554,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));
@@ -1562,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;
@@ -1571,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;
@@ -1737,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);
@@ -1793,6 +1933,6 @@ function listPositions(session) {
   return defaultLpLifecycleClient(session).listPositions();
 }
 
-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_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