@invisible-labs/sdk 0.6.0-devnet.3 → 0.6.0-devnet.5

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 { getSessionState } from './chunk-V5HXJRBW.js';
-import { CommandError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-GHBQF3A7.js';
+import { publicKey, assertAttested, lamports } from './chunk-EBWTAXNT.js';
+import { requestEnvelope, CoordinatorMessageType } from './chunk-3MDHAS4D.js';
+import { getSessionState } from './chunk-HJFMDMPY.js';
+import { CommandError, WalletError, TransportError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-QRN46R3F.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);
@@ -224,59 +228,206 @@ function validateDestinationAddresses(destinationAddresses) {
 
 // src/lp/coordinatorClient.ts
 var COMMAND_TTL_MS = 3e4;
-var LP_COMMAND_REQUEST_TIMEOUT_MS = 12e4;
+var LP_POSITION_OPEN_COMMAND_TTL_MS = 55e3;
+var LP_POSITION_OPEN_REQUEST_TIMEOUT_MS = 2e4;
+var LP_COMMAND_REQUEST_TIMEOUT_MS = COMMAND_TTL_MS;
+var LP_CREATION_CHALLENGE_REQUEST_TIMEOUT_MS = 3e4;
+var LP_CREATION_WALLET_SIGNATURE_TIMEOUT_MS = 45e3;
+var LP_CREATION_PROOF_REQUEST_TIMEOUT_MS = 15e3;
+var LP_CREATION_PROOF_RETRY_TIMEOUT_MS = 15e3;
+var LP_CREATION_AUTHORIZATION_MARGIN_MS = 15e3;
+var LP_CREATION_MIN_STEP_TIMEOUT_MS = 1;
 var LP_DKG_ABORT_REQUEST_TIMEOUT_MS = 1e4;
 var encoder2 = new TextEncoder();
 var protocolPromise = null;
-function createLpCoordinatorClient(session) {
+function createLpCoordinatorClient(session, options = {}) {
+  const sessionRef = { current: session };
+  const reconnectSession = options.reconnectSession === void 0 ? void 0 : async () => {
+    const nextSession = await options.reconnectSession();
+    sessionRef.current = nextSession;
+    return nextSession;
+  };
   return {
+    authorizePositionCreation(intent, signer) {
+      return authorizePositionCreation(sessionRef.current, intent, signer);
+    },
     initDkg(input, auth) {
-      return initDkg(session, input, auth);
+      return initDkg(sessionRef.current, input, auth);
     },
     abortDkgSessions(lpPositionId, auth) {
-      return abortDkgSessions(session, lpPositionId, auth);
+      return abortDkgSessions(sessionRef.current, lpPositionId, auth);
     },
     dkgRound1(input, auth) {
-      return dkgRound1(session, input, auth);
+      return dkgRound1(sessionRef.current, input, auth);
     },
     dkgRound2(input, auth) {
-      return dkgRound2(session, input, auth);
+      return dkgRound2(sessionRef.current, input, auth);
     },
     openPosition(input, auth) {
-      return openPosition(session, input, auth);
+      return openPosition(sessionRef.current, input, auth, reconnectSession);
     },
-    getPosition(lpPositionId, auth) {
-      return getPosition(session, lpPositionId, auth);
+    getPosition(lpPositionId, auth, options2) {
+      return getPosition(sessionRef.current, lpPositionId, auth, options2);
     },
     finalizeDkgBatch(input, auth) {
-      return finalizeDkgBatch(session, input, auth);
+      return finalizeDkgBatch(sessionRef.current, input, auth);
     },
     refillPosition(input, auth) {
-      return refillPosition(session, input, auth);
+      return refillPosition(sessionRef.current, input, auth);
     },
     reconcileFunding(lpPositionId, auth) {
-      return reconcileFunding(session, lpPositionId, auth);
+      return reconcileFunding(sessionRef.current, lpPositionId, auth);
     },
     planFunding(input, auth) {
-      return planFunding(session, input, auth);
+      return planFunding(sessionRef.current, input, auth);
     },
     confirmFunding(input, auth) {
-      return confirmFunding(session, input, auth);
+      return confirmFunding(sessionRef.current, input, auth);
     },
     prepareTopUp(lpPositionId, auth) {
-      return prepareTopUp(session, lpPositionId, auth);
+      return prepareTopUp(sessionRef.current, lpPositionId, auth);
     },
     getTopUpStatus(input, auth) {
-      return getTopUpStatus(session, input, auth);
+      return getTopUpStatus(sessionRef.current, input, auth);
     },
     makeAvailable(input, auth) {
-      return makeAvailable(session, input, auth);
+      return makeAvailable(sessionRef.current, input, auth);
     },
     executeWithdrawal(input, auth) {
-      return executeWithdrawal(session, input, auth);
+      return executeWithdrawal(sessionRef.current, input, auth);
     }
   };
 }
+async function authorizePositionCreation(session, intent, signer) {
+  const signerPublicKey = publicKey(signer.publicKey);
+  const challengeRequestStartedAtMs = Date.now();
+  const challengeEnvelope = await requestEnvelope(
+    session,
+    CoordinatorMessageType.LpCreateAuthorization,
+    {
+      case: "challenge",
+      value: {
+        public_key: signerPublicKey,
+        intent: {
+          committed_lamports: intent.committedLamports,
+          shard_count: intent.shardCount,
+          shard_amount_lamports: intent.shardAmountLamports,
+          refill_threshold: intent.refillThreshold
+        }
+      }
+    },
+    { timeoutMs: LP_CREATION_CHALLENGE_REQUEST_TIMEOUT_MS }
+  );
+  const challenge = challengeEnvelope.payload;
+  if (challenge.case !== "challenge") {
+    throw new CommandError(
+      "REJECTED_STATE",
+      "Coordinator returned an unexpected LP creation authorization response"
+    );
+  }
+  const localAuthorizationDeadlineMs = challengeRequestStartedAtMs + challenge.value.valid_for_ms;
+  const walletTimeoutMs = lpCreationAuthorizationStepTimeout(
+    localAuthorizationDeadlineMs,
+    LP_CREATION_PROOF_REQUEST_TIMEOUT_MS + LP_CREATION_PROOF_RETRY_TIMEOUT_MS + LP_CREATION_AUTHORIZATION_MARGIN_MS,
+    LP_CREATION_WALLET_SIGNATURE_TIMEOUT_MS
+  );
+  const signature = await signLpCreationMessageWithTimeout(
+    signer,
+    encoder2.encode(challenge.value.message),
+    walletTimeoutMs
+  );
+  if (!(signature instanceof Uint8Array) || signature.length !== 64) {
+    throw new WalletError(
+      "WALLET_INVALID_SIGNATURE",
+      "Solana wallet returned an invalid LP creation signature"
+    );
+  }
+  const proofPayload = {
+    case: "proof",
+    value: {
+      authorization_id: challenge.value.authorization_id,
+      public_key: signerPublicKey,
+      message: challenge.value.message,
+      signature
+    }
+  };
+  let proofEnvelope;
+  try {
+    const proofTimeoutMs = lpCreationAuthorizationStepTimeout(
+      localAuthorizationDeadlineMs,
+      LP_CREATION_PROOF_RETRY_TIMEOUT_MS + LP_CREATION_AUTHORIZATION_MARGIN_MS,
+      LP_CREATION_PROOF_REQUEST_TIMEOUT_MS
+    );
+    proofEnvelope = await requestEnvelope(
+      session,
+      CoordinatorMessageType.LpCreateAuthorization,
+      proofPayload,
+      { timeoutMs: proofTimeoutMs }
+    );
+  } catch (error) {
+    if (!isAmbiguousCoordinatorRequestFailure(error)) throw error;
+    const proofRetryTimeoutMs = lpCreationAuthorizationStepTimeout(
+      localAuthorizationDeadlineMs,
+      LP_CREATION_AUTHORIZATION_MARGIN_MS,
+      LP_CREATION_PROOF_RETRY_TIMEOUT_MS
+    );
+    proofEnvelope = await requestEnvelope(
+      session,
+      CoordinatorMessageType.LpCreateAuthorization,
+      proofPayload,
+      { timeoutMs: proofRetryTimeoutMs }
+    );
+  }
+  const authorization = proofEnvelope.payload;
+  if (authorization.case !== "authorized") {
+    throw new CommandError(
+      "REJECTED_STATE",
+      "Coordinator returned an unexpected LP creation authorization proof response"
+    );
+  }
+  if (authorization.value.authorization_id !== challenge.value.authorization_id) {
+    throw new CommandError(
+      "REJECTED_STATE",
+      "Coordinator returned an LP creation authorization for a different challenge"
+    );
+  }
+  lpCreationAuthorizationStepTimeout(
+    localAuthorizationDeadlineMs,
+    LP_CREATION_AUTHORIZATION_MARGIN_MS,
+    LP_CREATION_MIN_STEP_TIMEOUT_MS
+  );
+  return { authorizationId: authorization.value.authorization_id };
+}
+function lpCreationAuthorizationStepTimeout(localDeadlineMs, reservedMs, maximumTimeoutMs) {
+  const availableMs = localDeadlineMs - Date.now() - reservedMs;
+  if (availableMs < LP_CREATION_MIN_STEP_TIMEOUT_MS) {
+    throw new CommandError(
+      "REJECTED_EXPIRED",
+      "LP creation authorization expired; request a fresh coordinator challenge"
+    );
+  }
+  return Math.min(availableMs, maximumTimeoutMs);
+}
+async function signLpCreationMessageWithTimeout(signer, message, timeoutMs) {
+  let timeoutId;
+  try {
+    return await Promise.race([
+      signer.signMessage(message),
+      new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(
+            new WalletError(
+              "WALLET_USER_REJECTED",
+              "Solana wallet did not sign the LP creation challenge before it expired"
+            )
+          );
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeoutId !== void 0) clearTimeout(timeoutId);
+  }
+}
 async function initDkg(session, input, auth) {
   const response = await requestForPosition(session, input.lpPositionId, auth, "dkg_init", {
     case: "dkgInit",
@@ -295,7 +446,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 };
@@ -331,10 +482,11 @@ async function dkgRound2(session, input, auth) {
     index: response.value.index
   };
 }
-async function openPosition(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "position_open", {
+async function openPosition(session, input, auth, reconnectSession) {
+  const payload = {
     case: "positionOpen",
     value: {
+      creation_authorization_id: input.creationAuthorizationId,
       auth_public_key: Uint8Array.from(input.authPublicKey),
       refill_public_key: Uint8Array.from(input.refillPublicKey),
       redemption_commitment: Uint8Array.from(input.withdrawalCommitment),
@@ -345,18 +497,86 @@ async function openPosition(session, input, auth) {
       addresses: input.addresses,
       created_at_ms: input.createdAtMs
     }
-  });
+  };
+  const commandDeadlineMs = Date.now() + LP_POSITION_OPEN_COMMAND_TTL_MS;
+  const commandOptions = {
+    commandNonce: randomBytes(32),
+    commandExpiresAtMs: commandDeadlineMs,
+    deadlineMs: commandDeadlineMs,
+    timeoutMs: LP_POSITION_OPEN_REQUEST_TIMEOUT_MS
+  };
+  let response;
+  try {
+    response = await requestForPosition(
+      session,
+      input.lpPositionId,
+      auth,
+      "position_open",
+      payload,
+      commandOptions
+    );
+  } catch (error) {
+    if (!isAmbiguousLpPositionOpenFailure(error)) throw error;
+    const replaySession = reconnectSession === void 0 ? session : await reconnectSessionWithinDeadline(reconnectSession, commandDeadlineMs);
+    response = await requestForPosition(
+      replaySession,
+      input.lpPositionId,
+      auth,
+      "position_open",
+      payload,
+      commandOptions
+    );
+  }
   return expectPosition(response);
 }
-async function getPosition(session, lpPositionId, auth) {
+async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
+  const remainingMs = deadlineMs - Date.now();
+  if (remainingMs <= 0) {
+    throw new CommandError(
+      "REJECTED_EXPIRED",
+      "LP position-open command expired before coordinator reconnect"
+    );
+  }
+  let timer;
+  try {
+    return await new Promise((resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new CommandError(
+            "REJECTED_EXPIRED",
+            "LP position-open command expired during coordinator reconnect"
+          )
+        );
+      }, remainingMs);
+      Promise.resolve().then(reconnectSession).then(resolve, reject);
+    });
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function isAmbiguousLpPositionOpenFailure(error) {
+  return isAmbiguousCoordinatorRequestFailure(error);
+}
+function isAmbiguousCoordinatorRequestFailure(error) {
+  return error instanceof TransportError || error instanceof CommandError && error.code === "REJECTED_STALE_JOB";
+}
+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 +593,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,41 +693,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, 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,
-    nonce: randomBytes(32),
-    expires_at_ms: Date.now() + Math.min(COMMAND_TTL_MS, timeoutMs),
+    nonce: options.commandNonce === void 0 ? randomBytes(32) : new Uint8Array(options.commandNonce),
+    expires_at_ms: options.commandExpiresAtMs ?? Date.now() + Math.min(COMMAND_TTL_MS, timeoutMs),
     coordinator_attestation_hash: await coordinatorAttestationHash(
       attestation.binaryHash,
       attestation.pubkeyHex
@@ -504,8 +759,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);
 }
@@ -533,9 +790,20 @@ function mapPosition(position) {
     refillThreshold: position.refill_threshold,
     shards: position.shards.map(mapShard),
     createdAt: position.created_at_ms,
+    redemptionPermission: mapLpRedemptionPermission(position.redemption_permission),
     ...position.actor_sync === void 0 ? {} : { actorSync: mapLpActorSync(position.actor_sync) }
   };
 }
+function mapLpRedemptionPermission(permission) {
+  if (permission === void 0) {
+    return { state: "unknown", grantRevision: 0, observedAtMs: 0 };
+  }
+  return {
+    state: permission.state,
+    grantRevision: permission.grant_revision,
+    observedAtMs: permission.observed_at_ms
+  };
+}
 function mapLpActorSync(actorSync) {
   const redeemableBucketValues = [
     actorSync.redeemable_principal_lamports,
@@ -564,6 +832,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 +876,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 +955,7 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-VVJ33WF2.js');
+  protocolPromise ??= import('./coordinator-PEWHNZ7I.js');
   return protocolPromise;
 }
 
@@ -960,9 +1230,10 @@ 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_REDEMPTION_PERMISSION_UNAVAILABLE_MESSAGE = "LP redemption is unavailable until the coordinator confirms permission";
 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 +1252,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 = {
@@ -989,7 +1270,13 @@ function createLpLifecycleClient(session, runtime = {}) {
     redemptions: /* @__PURE__ */ new Map(),
     topUps: /* @__PURE__ */ new Map()
   };
-  const client = runtime.coordinatorClient ?? createLpCoordinatorClient(session);
+  let currentSession = session;
+  const reconnectSession = runtime.reconnectSession === void 0 ? void 0 : async () => {
+    const nextSession = await runtime.reconnectSession();
+    currentSession = nextSession;
+    return nextSession;
+  };
+  const client = runtime.coordinatorClient ?? createLpCoordinatorClient(session, { reconnectSession });
   const nowMs = runtime.nowMs ?? Date.now;
   const sleep2 = runtime.sleep ?? defaultSleep;
   const requireAuth = (positionId) => {
@@ -999,9 +1286,17 @@ function createLpLifecycleClient(session, runtime = {}) {
   };
   const rememberPosition = (position) => {
     const snapshot = clonePosition(position);
-    state.positions.set(snapshot.id, snapshot);
-    hydrateLpRedemptionsFromPosition(state, snapshot);
-    return position;
+    const previous = state.positions.get(snapshot.id);
+    const merged = previous === void 0 ? snapshot : {
+      ...snapshot,
+      redemptionPermission: mergeLpRedemptionPermission(
+        previous.redemptionPermission,
+        snapshot.redemptionPermission
+      )
+    };
+    state.positions.set(merged.id, merged);
+    hydrateLpRedemptionsFromPosition(state, merged);
+    return merged;
   };
   const rememberAuth = (auth) => {
     state.authByPosition.set(auth.lpPositionId, auth);
@@ -1025,7 +1320,7 @@ function createLpLifecycleClient(session, runtime = {}) {
     }
   };
   const completeDkgBatch2 = async (positionId, options = {}) => {
-    assertAttested(session);
+    assertAttested(currentSession);
     const auth = requireAuth(positionId);
     let activeSessionRetryStartedAtMs = null;
     for (; ; ) {
@@ -1089,39 +1384,55 @@ function createLpLifecycleClient(session, runtime = {}) {
     }
   };
   return {
-    async createPosition(args = {}) {
+    async createPosition(args) {
       assertNoUnsupportedFeePolicy(args.feePolicy);
       const shardCount = args.shardCount ?? LP_DEFAULT_TARGET_SHARDS;
       assertShardCount(shardCount, LP_MAX_TARGET_SHARDS, "shardCount");
-      assertAttested(session);
+      assertAttested(currentSession);
+      const committedLamports = args.committedLamports ?? DEFAULT_SHARD_FUNDING_LAMPORTS;
+      const refillThreshold = args.refillThreshold ?? Math.ceil(shardCount * DEFAULT_REFILL_THRESHOLD_RATIO);
+      const creationAuthorization = await client.authorizePositionCreation(
+        {
+          committedLamports,
+          shardCount,
+          shardAmountLamports: DEFAULT_SHARD_FUNDING_LAMPORTS,
+          refillThreshold
+        },
+        args.wallet
+      );
       const positionId = runtime.idFactory?.() ?? generateId(LP_ID_PREFIX);
       const auth = await generateLpPositionCode(positionId);
       rememberAuth(auth);
-      args.onPositionCode?.({ positionId, lpPositionCode: auth.code });
-      const committedLamports = args.committedLamports ?? DEFAULT_SHARD_FUNDING_LAMPORTS;
       const position = rememberPosition(
         await client.openPosition(
           {
             lpPositionId: positionId,
+            creationAuthorizationId: creationAuthorization.authorizationId,
             authPublicKey: Array.from(auth.authPublicKey),
             refillPublicKey: Array.from(auth.refillPublicKey),
             withdrawalCommitment: Array.from(auth.withdrawalCommitment),
             committedLamports,
             shardCount,
             shardAmountLamports: DEFAULT_SHARD_FUNDING_LAMPORTS,
-            refillThreshold: args.refillThreshold ?? Math.ceil(shardCount * DEFAULT_REFILL_THRESHOLD_RATIO),
+            refillThreshold,
             addresses: [],
             createdAtMs: nowMs()
           },
           auth
         )
       );
+      args.onPositionCode?.({ positionId, lpPositionCode: auth.code });
       return { positionId, lpPositionCode: auth.code, position };
     },
     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;
     },
@@ -1133,7 +1444,7 @@ function createLpLifecycleClient(session, runtime = {}) {
     async refill(positionId, args = {}) {
       const requestedShardCount = args.shardCount ?? LP_DEFAULT_REFILL_BATCH_SIZE;
       assertShardCount(requestedShardCount, LP_MAX_REFILL_BATCH_SIZE, "shardCount");
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const current = await refreshPosition2(positionId);
       args.onPosition?.(current);
@@ -1165,7 +1476,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       });
     },
     async prepareInitialFunding(positionId) {
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const currentPosition = rememberPosition(await client.getPosition(positionId, auth));
       if (!isLpPositionReadyForInitialFunding(currentPosition)) return null;
@@ -1194,7 +1505,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return fundingPlanFromShard(position, plannedShard);
     },
     async prepareTopUp(positionId) {
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const request2 = await client.prepareTopUp(positionId, auth);
       state.topUps.set(request2.topUpId, request2);
@@ -1242,21 +1553,30 @@ function createLpLifecycleClient(session, runtime = {}) {
       }
     },
     async reconcileFunding(positionId) {
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       return rememberPosition(await client.reconcileFunding(positionId, auth));
     },
     async withdrawPosition(positionId, args) {
       validateExplicitWithdrawalInput(args);
       validateWithdrawalDestinations(args);
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const before = rememberPosition(await client.reconcileFunding(positionId, auth));
+      if (before.redemptionPermission?.state !== "enabled") {
+        throw new PolicyValidationError(
+          "INVALID_REDEMPTION_PLAN",
+          LP_REDEMPTION_PERMISSION_UNAVAILABLE_MESSAGE
+        );
+      }
       const existingRedemption = findOpenRedemptionHistory(before, args);
       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 +1596,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 +1654,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,17 +1695,15 @@ 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) {
       publicKey(args.destination);
-      assertAttested(session);
+      assertAttested(currentSession);
       throw new RoutingError(
         "VERSION_NOT_SUPPORTED",
         "LP fee withdrawal is not advertised by the coordinator"
@@ -1462,10 +1807,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 +1838,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 +1864,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 +1915,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 +1930,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 +1938,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;
@@ -1725,6 +2092,15 @@ function clonePosition(position) {
     }
   };
 }
+function mergeLpRedemptionPermission(existing, next) {
+  const current = existing ?? { state: "unknown", grantRevision: 0, observedAtMs: 0 };
+  const incoming = next ?? { state: "unknown", grantRevision: 0, observedAtMs: 0 };
+  if (incoming.state === "unknown") return incoming;
+  if (current.state === "enabled" && incoming.state !== "enabled") return current;
+  if (incoming.grantRevision > current.grantRevision) return incoming;
+  if (incoming.grantRevision < current.grantRevision) return current;
+  return incoming.observedAtMs > current.observedAtMs ? incoming : current;
+}
 function generateId(prefix) {
   return `${prefix}_${Array.from(randomBytes2(8)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
@@ -1737,6 +2113,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);
@@ -1744,7 +2144,7 @@ function defaultSleep(delayMs) {
 }
 
 // src/lp/index.ts
-function createPosition(session, args = {}) {
+function createPosition(session, args) {
   return defaultLpLifecycleClient(session).createPosition(args);
 }
 function recoverPosition(session, args) {
@@ -1793,6 +2193,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