@invisible-labs/sdk 0.13.2-devnet → 0.13.3-devnet

package/dist/lp.js

@@ -1,6 +1,6 @@
 import { isValidLpPositionId, LP_MAX_TOTAL_SHARDS, LP_MAX_INITIAL_SHARDS, LP_MAX_REFILL_BATCH_SIZE, LP_SHARD_PAGE_SIZE, LP_DEFAULT_REFILL_BATCH_SIZE, LP_DEFAULT_TARGET_SHARDS } from './chunk-TNLSUQGJ.js';
 import { publicKey, assertAttested, lamports } from './chunk-TYTVF3A4.js';
-import { requestEnvelope, CoordinatorMessageType } from './chunk-NOKBFHDP.js';
+import { requestEnvelope, CoordinatorMessageType } from './chunk-5YOVJLHU.js';
 import { getSessionState } from './chunk-DOTYDYVB.js';
 import { CommandError, TransportError, PolicyValidationError, LpLifecycleError, RoutingError, WalletError } from './chunk-A4R3DHKN.js';
 import './chunk-VR6T6OJS.js';
@@ -320,6 +320,50 @@ function validateDestinationAddresses(destinationAddresses) {
   }
 }
 
+// src/lp/positionSummary.ts
+var LP_POSITION_SUMMARY_MAX_SHARDS = 2;
+var LP_POSITION_SUMMARY_ANCHOR_SHARD_INDEX = 0;
+var LP_FUNDING_QUEUED_STATUS = "FUNDING_QUEUED";
+var LP_SHARD_STATUSES = [
+  "PREGENERATED",
+  "FUNDING_QUEUED",
+  "FUNDED",
+  "COOLING",
+  "AVAILABLE",
+  "RESERVED",
+  "RETIRED",
+  "REDEEMED"
+];
+function emptyLpShardStatusTotals() {
+  return Object.fromEntries(
+    LP_SHARD_STATUSES.map((status) => [status, { count: 0, lamports: 0 }])
+  );
+}
+function selectLpPositionSummaryShards(shards) {
+  const anchor = shards.find((shard) => shard.index === LP_POSITION_SUMMARY_ANCHOR_SHARD_INDEX);
+  const fundingQueued = shards.filter((shard) => shard.status === LP_FUNDING_QUEUED_STATUS).reduce((lowest, shard) => lowest === void 0 || shard.index < lowest.index ? shard : lowest, void 0);
+  return [anchor, fundingQueued].filter(
+    (shard, position, selected) => shard !== void 0 && selected.indexOf(shard) === position
+  );
+}
+function summarizeLpPosition(position) {
+  const { shards, ...identity } = position;
+  const shardTotals = emptyLpShardStatusTotals();
+  for (const shard of shards) {
+    const total = shardTotals[shard.status];
+    shardTotals[shard.status] = {
+      count: total.count + 1,
+      lamports: total.lamports + shard.amountLamports
+    };
+  }
+  return {
+    ...identity,
+    shardsTotalCount: shards.length,
+    shardTotals,
+    shards: selectLpPositionSummaryShards(shards)
+  };
+}
+
 // src/lp/coordinatorClient.ts
 var COMMAND_TTL_MS = 3e4;
 var LP_POSITION_OPEN_COMMAND_TTL_MS = 55e3;
@@ -330,6 +374,11 @@ var LP_POSITION_PAGE_STALL_TIMEOUT_MS = 3e4;
 var LP_POSITION_SNAPSHOT_MAX_ATTEMPTS = 3;
 var LP_SHARD_SNAPSHOT_CHANGED_MESSAGE = "LP shard snapshot changed";
 var LP_SHARD_PAGE_INVALID_MESSAGE = "coordinator LP shard page is invalid";
+var LP_POSITION_SUMMARY_INVALID_MESSAGE = "coordinator LP position summary is invalid";
+var LP_POSITION_SUMMARY_VIEW = "summary";
+var LP_LEGACY_UNSET_TARGET_SHARD_COUNT = 0;
+var LP_REDEMPTION_HISTORY_FIRST_PAGE = "first_page";
+var LP_REDEMPTION_HISTORY_CURSOR_INVALID_MESSAGE = "coordinator LP actor sync returned an invalid redemption history cursor";
 var LP_POSITION_OPEN_IDENTITY_MISMATCH_MESSAGE = "Coordinator returned a different LP position identity or creation intent";
 var LP_SHARD_SNAPSHOT_HASH_PATTERN = /^[0-9a-f]{64}$/;
 var LP_CREATION_CHALLENGE_REQUEST_TIMEOUT_MS = 3e4;
@@ -384,6 +433,12 @@ function createLpCoordinatorClient(session, options = {}) {
         options2?.signal
       );
     },
+    getPositionSummary(lpPositionId, auth, options2) {
+      return run(
+        (signal) => getPositionSummary(sessionRef.current, lpPositionId, auth, { ...options2, signal }),
+        options2?.signal
+      );
+    },
     finalizeDkgBatch(input, auth) {
       return run((signal) => finalizeDkgBatch(sessionRef.current, input, auth, { signal }));
     },
@@ -393,6 +448,12 @@ function createLpCoordinatorClient(session, options = {}) {
     reconcileFunding(lpPositionId, auth) {
       return run((signal) => reconcileFunding(sessionRef.current, lpPositionId, auth, { signal }));
     },
+    reconcileFundingSummary(lpPositionId, auth, options2) {
+      return run(
+        (signal) => reconcileFundingSummary(sessionRef.current, lpPositionId, auth, { ...options2, signal }),
+        options2?.signal
+      );
+    },
     planFunding(input, auth) {
       return run((signal) => planFunding(sessionRef.current, input, auth, { signal }));
     },
@@ -766,8 +827,78 @@ function isAmbiguousCoordinatorRequestFailure(error) {
 async function getPosition(session, lpPositionId, auth, options = {}) {
   return hydratePositionResponse(session, lpPositionId, auth, void 0, options);
 }
-async function hydratePositionResponse(session, lpPositionId, auth, initialResponse, options = {}) {
-  const boundedOptions = {
+async function getPositionSummary(session, lpPositionId, auth, options = {}) {
+  const boundedOptions = boundedPositionObservationOptions(options);
+  const response = await requestForPosition(
+    session,
+    lpPositionId,
+    auth,
+    "position_get",
+    { case: "positionGet", value: { view: LP_POSITION_SUMMARY_VIEW } },
+    boundedOptions
+  );
+  return completePositionSummary(session, lpPositionId, auth, response, boundedOptions);
+}
+async function reconcileFundingSummary(session, lpPositionId, auth, options = {}) {
+  const boundedOptions = boundedPositionObservationOptions(options);
+  const response = await requestForPosition(
+    session,
+    lpPositionId,
+    auth,
+    "reconcile_funding",
+    { case: "reconcileFunding", value: { view: LP_POSITION_SUMMARY_VIEW } },
+    boundedOptions
+  );
+  return completePositionSummary(session, lpPositionId, auth, response, boundedOptions);
+}
+async function completePositionSummary(session, lpPositionId, auth, firstResponse, options) {
+  if (firstResponse.case !== "positionSummary")
+    throw new CommandError("REJECTED_STATE", LP_POSITION_SUMMARY_INVALID_MESSAGE);
+  const first = mapPositionSummary(firstResponse.value, lpPositionId, auth);
+  if (options.redemptionHistory === LP_REDEMPTION_HISTORY_FIRST_PAGE) return first;
+  const historyByRedemptionId = /* @__PURE__ */ new Map();
+  for (const history of first.actorSync?.redemptionHistory ?? [])
+    historyByRedemptionId.set(history.redemptionId, history);
+  let page = first;
+  const seenCursors = /* @__PURE__ */ new Set();
+  while (page.actorSync?.redemptionHistoryHasMore === true) {
+    const cursor = page.actorSync.redemptionHistoryNextCursor;
+    if (cursor === void 0 || seenCursors.has(cursor)) {
+      throw new CommandError("REJECTED_STATE", LP_REDEMPTION_HISTORY_CURSOR_INVALID_MESSAGE);
+    }
+    seenCursors.add(cursor);
+    const nextResponse = await requestForPosition(
+      session,
+      lpPositionId,
+      auth,
+      "position_get",
+      {
+        case: "positionGet",
+        value: { view: LP_POSITION_SUMMARY_VIEW, redemption_history_cursor: cursor }
+      },
+      options
+    );
+    if (nextResponse.case !== "positionSummary")
+      throw new CommandError("REJECTED_STATE", LP_POSITION_SUMMARY_INVALID_MESSAGE);
+    page = mapPositionSummary(nextResponse.value, lpPositionId, auth);
+    validateLpPositionFeePolicy(page, first);
+    for (const history of page.actorSync?.redemptionHistory ?? [])
+      historyByRedemptionId.set(history.redemptionId, history);
+  }
+  lpPositionPageRequestOptions(options);
+  if (first.actorSync === void 0) return first;
+  return {
+    ...first,
+    actorSync: {
+      ...first.actorSync,
+      redemptionHistory: [...historyByRedemptionId.values()],
+      redemptionHistoryHasMore: false,
+      redemptionHistoryNextCursor: void 0
+    }
+  };
+}
+function boundedPositionObservationOptions(options) {
+  return {
     ...options,
     deadlineMs: options.deadlineMs ?? Date.now() + LP_POSITION_HYDRATION_MAX_MS,
     timeoutMs: Math.min(
@@ -775,6 +906,52 @@ async function hydratePositionResponse(session, lpPositionId, auth, initialRespo
       LP_POSITION_PAGE_STALL_TIMEOUT_MS
     )
   };
+}
+function mapPositionSummary(summary, lpPositionId, auth) {
+  const invalid = () => {
+    throw new CommandError("REJECTED_STATE", LP_POSITION_SUMMARY_INVALID_MESSAGE);
+  };
+  const total = summary.shards_total_count;
+  const effectiveTargetShardCount = summary.target_shard_count === LP_LEGACY_UNSET_TARGET_SHARD_COUNT ? total : summary.target_shard_count;
+  if (summary.lp_position_id !== lpPositionId || bytesToHex(summary.auth_public_key) !== bytesToHex(auth.authPublicKey) || !Number.isInteger(total) || total < 0 || total > LP_MAX_TOTAL_SHARDS || total > effectiveTargetShardCount || summary.shards.length > LP_POSITION_SUMMARY_MAX_SHARDS)
+    invalid();
+  const seenIndexes = /* @__PURE__ */ new Set();
+  for (const shard of summary.shards) {
+    if (shard.index >= total || seenIndexes.has(shard.index) || shard.lp_position_id !== lpPositionId || shard.shard_id !== `${lpPositionId}:shard:${shard.index}`)
+      invalid();
+    seenIndexes.add(shard.index);
+  }
+  const shardTotals = emptyLpShardStatusTotals();
+  let countSum = 0;
+  for (const [status, statusTotal] of Object.entries(summary.shard_totals)) {
+    shardTotals[mapStatus(status)] = { count: statusTotal.count, lamports: statusTotal.lamports };
+    countSum += statusTotal.count;
+  }
+  if (countSum !== total) invalid();
+  const mapped = {
+    feePolicy: summary.fee_policy === void 0 ? void 0 : validateLpFeePolicy(summary.fee_policy),
+    lpFeePolicyVersion: summary.lp_fee_policy_version,
+    id: summary.lp_position_id,
+    status: summary.status,
+    targetShardCount: summary.target_shard_count,
+    authPublicKey: bytesToHex(summary.auth_public_key),
+    refillPublicKey: bytesToHex(summary.refill_public_key),
+    withdrawalCommitment: bytesToHex(summary.redemption_commitment),
+    committedLamports: summary.committed_lamports,
+    earnedLamports: summary.earned_lamports,
+    refillThreshold: summary.refill_threshold,
+    createdAt: summary.created_at_ms,
+    redemptionPermission: mapLpRedemptionPermission(summary.redemption_permission),
+    ...summary.actor_sync === void 0 ? {} : { actorSync: mapLpActorSync(summary.actor_sync) },
+    shardsTotalCount: total,
+    shardTotals,
+    shards: summary.shards.map(mapShard)
+  };
+  validateLpPositionFeePolicy(mapped);
+  return mapped;
+}
+async function hydratePositionResponse(session, lpPositionId, auth, initialResponse, options = {}) {
+  const boundedOptions = boundedPositionObservationOptions(options);
   for (let attempt = 0; attempt < LP_POSITION_SNAPSHOT_MAX_ATTEMPTS; attempt += 1) {
     try {
       const response = initialResponse ?? await requestForPosition(
@@ -826,10 +1003,7 @@ async function hydratePositionResponse(session, lpPositionId, auth, initialRespo
       while (historyPage.actor_sync?.redemption_history_has_more === true) {
         const cursor = historyPage.actor_sync.redemption_history_next_cursor;
         if (cursor === void 0 || seenCursors.has(cursor)) {
-          throw new CommandError(
-            "REJECTED_STATE",
-            "coordinator LP actor sync returned an invalid redemption history cursor"
-          );
+          throw new CommandError("REJECTED_STATE", LP_REDEMPTION_HISTORY_CURSOR_INVALID_MESSAGE);
         }
         seenCursors.add(cursor);
         const nextResponse = await requestForPosition(
@@ -1368,7 +1542,7 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-EQEL23A3.js');
+  protocolPromise ??= import('./coordinator-MLBKEKGO.js');
   return protocolPromise;
 }
 
@@ -1693,6 +1867,10 @@ 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_POSITION_SUMMARY_UNSUPPORTED_COORDINATOR_CODE = "ERR_INVALID_PAYLOAD";
+var LP_POSITION_SUMMARY_SCHEMA_REJECTION_PREFIX = "json schema validation failed: ";
+var LP_POSITION_SUMMARY_SCHEMA_REJECTION_VIEW_TOKEN = '"view":"summary"';
+var summaryUnsupportedSessions = /* @__PURE__ */ new WeakSet();
 var LP_REDEMPTION_HISTORY_OPEN_STATES = /* @__PURE__ */ new Set([
   "requested",
   "match_requested",
@@ -1710,6 +1888,7 @@ var WITHDRAWAL_HISTORY_MISMATCH_MESSAGE = "LP redemption history does not match
 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 LP_WITHDRAWAL_FULL_INVENTORY_REQUIRED_MESSAGE = "LP withdrawal plan requires the full shard inventory";
 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() {
@@ -1729,16 +1908,24 @@ function isLpRedemptionReconcilingError(error) {
 function isLpPositionAuthMissingError(error) {
   return error instanceof LpPositionAuthMissingError || error instanceof Error && error.message === LP_MISSING_POSITION_CODE_MESSAGE;
 }
+function isLpPositionSummaryUnsupportedError(error) {
+  if (!(error instanceof CommandError) || error.coordinatorCode !== LP_POSITION_SUMMARY_UNSUPPORTED_COORDINATOR_CODE)
+    return false;
+  const message = error.coordinatorMessage ?? error.message;
+  return message.startsWith(LP_POSITION_SUMMARY_SCHEMA_REJECTION_PREFIX) && message.includes(LP_POSITION_SUMMARY_SCHEMA_REJECTION_VIEW_TOKEN);
+}
+function isTransientLpObservationError(error) {
+  return error instanceof CommandError && (error.code === "RETRYABLE_BUSY" || error.code === "REJECTED_STALE_JOB" && error.coordinatorCode === void 0);
+}
+var LpPositionSummaryUnsupportedProbe = class extends Error {
+};
 function previewLpWithdrawalPlan(position, args = {}) {
   validateLpPositionFeePolicy(position);
-  const claim = resolveWithdrawalClaim(position, args);
-  return {
-    ...claim,
-    sourceCount: lpWithdrawalSourceCountForClaim(position, {
-      ...claim,
-      allowManyToOne: args.allowManyToOne
-    })
-  };
+  return previewWithdrawalFromBasis(fullWithdrawalBasis(position), args);
+}
+function previewLpWithdrawalPlanFromSummary(summary, args = {}) {
+  validateLpPositionFeePolicy(summary);
+  return previewWithdrawalFromBasis(summaryWithdrawalBasis(summary), args);
 }
 var dkgAdmissions = /* @__PURE__ */ new WeakMap();
 var LP_DKG_BUSY_MESSAGE = "LP DKG session capacity is busy; wait for the active batch to finish";
@@ -1845,7 +2032,7 @@ function createLpLifecycleClient(session, runtime = {}) {
     const auth = requireAuth(positionId);
     return rememberPosition(await client.getPosition(positionId, auth));
   };
-  const executeWithdrawalAfterFundingReadiness = async (positionId, input, auth) => {
+  const executeWithdrawalAfterFundingReadiness = async (input, auth, reconcile) => {
     for (let attempt = 0; ; attempt += 1) {
       try {
         return await client.executeWithdrawal(input, auth);
@@ -1855,8 +2042,148 @@ function createLpLifecycleClient(session, runtime = {}) {
           throw error;
         }
         await sleep2(LP_WITHDRAWAL_READINESS_RETRY_DELAY_MS);
-        await client.reconcileFunding(positionId, auth).catch(() => void 0);
+        await reconcile().catch(() => void 0);
+      }
+    }
+  };
+  const recoverPosition2 = async (args) => {
+    assertUsable();
+    const auth = await deriveLpPositionCodeAuth(args.code);
+    rememberAuth(auth);
+    const position = rememberPosition(
+      await client.getPosition(auth.lpPositionId, auth, {
+        deadlineMs: args.deadlineMs,
+        signal: args.signal
+      })
+    );
+    assertPositionMatchesAuth(position, auth);
+    return position;
+  };
+  const withSummarySupport = async (summaryRead, fullRead) => {
+    const session2 = currentSession;
+    if (summaryUnsupportedSessions.has(session2)) return fullRead();
+    try {
+      return await summaryRead();
+    } catch (error) {
+      if (!isLpPositionSummaryUnsupportedError(error)) throw error;
+      summaryUnsupportedSessions.add(session2);
+    }
+    return fullRead();
+  };
+  const executeWithdrawalPlan = async (positionId, args, auth, before, plan, reconcile) => {
+    if (plan.kind === "existing") {
+      state.redemptions.set(plan.execution.withdrawalId, plan.redemption);
+      return { execution: plan.execution, redemption: plan.redemption, submitted: false };
+    }
+    const preview = plan.preview;
+    const requestedAtMs = nowMs();
+    const execution = await executeWithdrawalAfterFundingReadiness(
+      {
+        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,
+        feePolicyHash: before.feePolicy?.policy_hash,
+        feeBasisRevision: before.actorSync?.feeBasisRevision,
+        allowManyToOne: args.allowManyToOne === true || preview?.sourceCount === 1
+      },
+      auth,
+      reconcile
+    );
+    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 redemption = buildLpRedemptionRecord({
+      execution,
+      position: before,
+      destinationAddresses: args.destinationAddresses,
+      acceptedLamports: acceptedAmount,
+      requestedTargetLamports: (before.actorSync?.withdrawalRequestedLamports ?? 0) + acceptedAmount,
+      landedBaselineLamports: before.actorSync?.withdrawalLandedLamports ?? 0,
+      landedFeeBaselineLamports: before.actorSync?.withdrawalLandedFeeLamports ?? 0,
+      txSignatureBaseline: before.actorSync?.withdrawalTxHashes ?? [],
+      nowMs: nowMs()
+    });
+    state.redemptions.set(execution.withdrawalId, redemption);
+    return { execution, redemption, submitted: true };
+  };
+  const withdrawPosition2 = async (positionId, args) => {
+    assertUsable();
+    validateExplicitWithdrawalInput(args);
+    validateWithdrawalDestinations(args);
+    assertAttested(currentSession);
+    const auth = requireAuth(positionId);
+    const before = rememberPosition(await client.reconcileFunding(positionId, auth));
+    const plan = planWithdrawal(before, fullWithdrawalBasis(before), args);
+    const result = await executeWithdrawalPlan(
+      positionId,
+      args,
+      auth,
+      before,
+      plan,
+      () => client.reconcileFunding(positionId, auth)
+    );
+    if (!result.submitted) return { ...result, position: before };
+    const position = await client.getPosition(positionId, auth).then((refreshed) => rememberPosition(refreshed)).catch(() => before);
+    const redemption = { ...result.redemption, lpPositionId: position.id };
+    state.redemptions.set(result.execution.withdrawalId, redemption);
+    return { execution: result.execution, position, redemption };
+  };
+  const observeWithdrawalConfirmation = async (positionId, execution, options, observe, reconcileRecord, onView) => {
+    let record = resolveWithdrawalRecord({
+      state,
+      positionId,
+      execution,
+      options
+    });
+    state.redemptions.set(record.redemptionId, record);
+    const deadlineMs = options.deadlineMs ?? nowMs() + (runtime.withdrawalConfirmationTimeoutMs ?? LP_WITHDRAWAL_CONFIRMATION_TIMEOUT_MS);
+    const pollIntervalMs = runtime.withdrawalConfirmationPollIntervalMs ?? LP_WITHDRAWAL_CONFIRMATION_POLL_INTERVAL_MS;
+    for (; ; ) {
+      throwIfWithdrawalConfirmationAborted(options.signal);
+      if (nowMs() >= deadlineMs) {
+        markLpRedemptionReconciling(state, record, options);
+      }
+      const remainingMs = deadlineMs - nowMs();
+      if (remainingMs <= 0) {
+        markLpRedemptionReconciling(state, record, options);
+      }
+      let view;
+      try {
+        view = await observe(deadlineMs);
+      } catch (error) {
+        if (isLpPositionObservationDeadlineError(error, deadlineMs, nowMs)) {
+          markLpRedemptionReconciling(state, record, options);
+        }
+        throw error;
+      }
+      throwIfWithdrawalConfirmationAborted(options.signal);
+      onView?.(view);
+      const reconciled = reconcileRecord(record, view);
+      record = reconciled;
+      state.redemptions.set(record.redemptionId, reconciled);
+      options.onRedemptionUpdate?.(reconciled);
+      if (reconciled.status === "confirmed") {
+        return {
+          withdrawalId: execution.withdrawalId,
+          txSignatures: reconciled.txSignatures,
+          redeemedLamports: reconciled.redeemedLamports
+        };
       }
+      if (reconciled.status === "failed") {
+        throw new Error(reconciled.error ?? WITHDRAWAL_NO_LAMPORTS_MESSAGE);
+      }
+      if (nowMs() >= deadlineMs) {
+        markLpRedemptionReconciling(state, reconciled, options);
+      }
+      await sleepWithAbort(sleep2, pollIntervalMs, options.signal);
     }
   };
   const completeDkgBatch2 = async (positionId, options = {}, hasReservation = false) => {
@@ -1979,18 +2306,23 @@ function createLpLifecycleClient(session, runtime = {}) {
       args.onPositionCode?.({ positionId, lpPositionCode: auth.code });
       return { positionId, lpPositionCode: auth.code, position };
     },
-    async recoverPosition(args) {
+    recoverPosition: recoverPosition2,
+    async recoverPositionSummary(args) {
       assertUsable();
       const auth = await deriveLpPositionCodeAuth(args.code);
       rememberAuth(auth);
-      const position = rememberPosition(
-        await client.getPosition(auth.lpPositionId, auth, {
-          deadlineMs: args.deadlineMs,
-          signal: args.signal
-        })
+      return withSummarySupport(
+        async () => {
+          const summary = await client.getPositionSummary(auth.lpPositionId, auth, {
+            deadlineMs: args.deadlineMs,
+            signal: args.signal,
+            redemptionHistory: "first_page"
+          });
+          assertPositionMatchesAuth(summary, auth);
+          return summary;
+        },
+        async () => summarizeLpPosition(await recoverPosition2(args))
       );
-      assertPositionMatchesAuth(position, auth);
-      return position;
     },
     confirmPositionCodeSaved(_positionId) {
       assertUsable();
@@ -2129,154 +2461,130 @@ function createLpLifecycleClient(session, runtime = {}) {
       const auth = requireAuth(positionId);
       return rememberPosition(await client.reconcileFunding(positionId, auth));
     },
-    async withdrawPosition(positionId, args) {
+    withdrawPosition: withdrawPosition2,
+    async reconcileFundingSummary(positionId) {
+      assertUsable();
+      assertAttested(currentSession);
+      const auth = requireAuth(positionId);
+      return withSummarySupport(
+        () => client.reconcileFundingSummary(positionId, auth, { redemptionHistory: "first_page" }),
+        async () => summarizeLpPosition(rememberPosition(await client.reconcileFunding(positionId, auth)))
+      );
+    },
+    async refreshPositionSummary(positionId, options = {}) {
+      assertUsable();
+      const auth = requireAuth(positionId);
+      return withSummarySupport(
+        () => client.getPositionSummary(positionId, auth, {
+          redemptionHistory: options.redemptionHistory
+        }),
+        async () => summarizeLpPosition(await refreshPosition2(positionId))
+      );
+    },
+    async withdrawPositionSummary(positionId, args) {
       assertUsable();
       validateExplicitWithdrawalInput(args);
       validateWithdrawalDestinations(args);
       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 = {
-          feePolicyHash: existingRedemption.feePolicyHash,
-          feeBasisRevision: existingRedemption.feeBasisRevision,
-          withdrawalId: existingRedemption.redemptionId,
-          txSignatures: [...existingRedemption.txSignatures],
-          acceptedLamports: existingRedemption.acceptedLamports,
-          acceptedDepositPrincipalLamports: existingRedemption.acceptedDepositPrincipalLamports,
-          acceptedEarnedFeeLamports: existingRedemption.acceptedEarnedFeeLamports
-        };
-        const redemption2 = {
-          ...buildLpRedemptionRecord({
-            execution: execution2,
-            position: before,
-            destinationAddresses: existingRedemption.destinationAddresses,
-            acceptedLamports: existingRedemption.acceptedLamports,
-            requestedTargetLamports: existingRedemption.acceptedLamports,
-            landedBaselineLamports: 0,
-            landedFeeBaselineLamports: 0,
-            txSignatureBaseline: [],
-            nowMs: existingRedemption.createdAtMs
-          }),
-          redeemedLamports: existingRedemption.landedLamports,
-          coordinatorStateVersion: existingRedemption.stateVersion
+      const viaFullPosition = async () => {
+        const result2 = await withdrawPosition2(positionId, args);
+        return {
+          execution: result2.execution,
+          summary: summarizeLpPosition(result2.position),
+          redemption: result2.redemption
         };
-        state.redemptions.set(execution2.withdrawalId, redemption2);
-        return { execution: execution2, position: before, redemption: redemption2 };
-      }
-      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
-        });
+      };
+      let before;
+      let plan;
+      try {
+        const reconciled = await withSummarySupport(
+          () => client.reconcileFundingSummary(positionId, auth),
+          async () => void 0
+        );
+        if (reconciled === void 0) return viaFullPosition();
+        before = reconciled;
+        assertPositionMatchesAuth(before, auth);
+        plan = planWithdrawal(before, summaryWithdrawalBasis(before), args);
+      } catch (error) {
+        if (error instanceof LpWithdrawalNeedsFullInventoryError) return viaFullPosition();
+        throw error;
       }
-      const execution = await executeWithdrawalAfterFundingReadiness(
+      const result = await executeWithdrawalPlan(
         positionId,
-        {
-          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,
-          feePolicyHash: before.feePolicy?.policy_hash,
-          feeBasisRevision: before.actorSync?.feeBasisRevision,
-          allowManyToOne: args.allowManyToOne === true || preview?.sourceCount === 1
-        },
-        auth
+        args,
+        auth,
+        before,
+        plan,
+        () => client.reconcileFundingSummary(positionId, 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: acceptedAmount,
-        requestedTargetLamports: (before.actorSync?.withdrawalRequestedLamports ?? 0) + acceptedAmount,
-        landedBaselineLamports: before.actorSync?.withdrawalLandedLamports ?? 0,
-        landedFeeBaselineLamports: before.actorSync?.withdrawalLandedFeeLamports ?? 0,
-        txSignatureBaseline: before.actorSync?.withdrawalTxHashes ?? [],
-        nowMs: nowMs()
-      });
-      state.redemptions.set(execution.withdrawalId, pendingRedemption);
-      const position = await client.getPosition(positionId, auth).then((refreshed) => rememberPosition(refreshed)).catch(() => before);
-      const redemption = { ...pendingRedemption, lpPositionId: position.id };
-      state.redemptions.set(execution.withdrawalId, redemption);
-      return { execution, position, redemption };
+      if (!result.submitted) return { ...result, summary: before };
+      const summary = await client.getPositionSummary(positionId, auth).catch(() => before);
+      return { execution: result.execution, summary, redemption: result.redemption };
     },
     async waitForWithdrawalConfirmation(positionId, execution, options = {}) {
       assertUsable();
       const auth = requireAuth(positionId);
-      let record = resolveWithdrawalRecord({
-        state,
+      return observeWithdrawalConfirmation(
         positionId,
         execution,
-        options
-      });
-      state.redemptions.set(record.redemptionId, record);
-      const deadlineMs = options.deadlineMs ?? nowMs() + (runtime.withdrawalConfirmationTimeoutMs ?? LP_WITHDRAWAL_CONFIRMATION_TIMEOUT_MS);
+        options,
+        async (deadlineMs) => rememberPosition(
+          await client.getPosition(positionId, auth, { deadlineMs, signal: options.signal })
+        ),
+        reconcileLpRedemptionFromActorSync,
+        options.onPosition
+      );
+    },
+    async waitForWithdrawalConfirmationSummary(positionId, execution, options = {}) {
+      assertUsable();
+      const auth = requireAuth(positionId);
+      const { onSummary, ...observation } = options;
+      const session2 = currentSession;
+      const observeFull = () => observeWithdrawalConfirmation(
+        positionId,
+        execution,
+        observation,
+        async (deadlineMs) => rememberPosition(
+          await client.getPosition(positionId, auth, { deadlineMs, signal: options.signal })
+        ),
+        reconcileLpRedemptionFromCorrelatedHistory,
+        onSummary === void 0 ? void 0 : (position) => onSummary(summarizeLpPosition(position))
+      );
+      if (summaryUnsupportedSessions.has(session2)) return observeFull();
       const pollIntervalMs = runtime.withdrawalConfirmationPollIntervalMs ?? LP_WITHDRAWAL_CONFIRMATION_POLL_INTERVAL_MS;
-      for (; ; ) {
-        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, {
+      let summaryObserved = false;
+      const observeSummary = async (deadlineMs) => {
+        for (; ; ) {
+          try {
+            const summary = await client.getPositionSummary(positionId, auth, {
               deadlineMs,
               signal: options.signal
-            })
-          );
-        } catch (error) {
-          if (isLpPositionObservationDeadlineError(error, deadlineMs, nowMs)) {
-            markLpRedemptionReconciling(state, record, options);
+            });
+            summaryObserved = true;
+            return summary;
+          } catch (error) {
+            if (!summaryObserved && isLpPositionSummaryUnsupportedError(error)) {
+              summaryUnsupportedSessions.add(session2);
+              throw new LpPositionSummaryUnsupportedProbe();
+            }
+            if (!isTransientLpObservationError(error) || nowMs() >= deadlineMs) throw error;
+            await sleepWithAbort(sleep2, pollIntervalMs, options.signal);
           }
-          throw error;
-        }
-        throwIfWithdrawalConfirmationAborted(options.signal);
-        options.onPosition?.(position);
-        const reconciled = reconcileLpRedemptionFromActorSync(record, position);
-        record = reconciled;
-        state.redemptions.set(record.redemptionId, reconciled);
-        options.onRedemptionUpdate?.(reconciled);
-        if (reconciled.status === "confirmed") {
-          return {
-            withdrawalId: execution.withdrawalId,
-            txSignatures: reconciled.txSignatures,
-            redeemedLamports: reconciled.redeemedLamports
-          };
-        }
-        if (reconciled.status === "failed") {
-          throw new Error(reconciled.error ?? WITHDRAWAL_NO_LAMPORTS_MESSAGE);
         }
-        if (nowMs() >= deadlineMs) {
-          markLpRedemptionReconciling(state, reconciled, options);
-        }
-        await sleepWithAbort(sleep2, pollIntervalMs, options.signal);
+      };
+      try {
+        return await observeWithdrawalConfirmation(
+          positionId,
+          execution,
+          observation,
+          observeSummary,
+          reconcileLpRedemptionFromCorrelatedHistory,
+          onSummary
+        );
+      } catch (error) {
+        if (!(error instanceof LpPositionSummaryUnsupportedProbe)) throw error;
+        return observeFull();
       }
     },
     async withdrawFees(_positionId, args) {
@@ -2377,7 +2685,92 @@ function resolveLpRefillShardCount(position, requestedShardCount) {
 function isLpPositionReadyForInitialFunding(position) {
   return position.status === "active" && position.shards.length >= position.targetShardCount;
 }
-function resolveWithdrawalClaim(position, args) {
+var LpWithdrawalNeedsFullInventoryError = class extends Error {
+  constructor() {
+    super(LP_WITHDRAWAL_FULL_INVENTORY_REQUIRED_MESSAGE);
+    this.name = "LpWithdrawalNeedsFullInventoryError";
+  }
+};
+function fullWithdrawalBasis(position) {
+  return {
+    actorSync: position.actorSync,
+    earnedLamports: position.earnedLamports,
+    availableShards: position.shards.filter(
+      (shard) => shard.status === "AVAILABLE" && shard.amountLamports > 0
+    )
+  };
+}
+function summaryWithdrawalBasis(summary) {
+  return { actorSync: summary.actorSync, earnedLamports: summary.earnedLamports };
+}
+function requireAvailableShards(basis) {
+  if (basis.availableShards === void 0) throw new LpWithdrawalNeedsFullInventoryError();
+  return basis.availableShards;
+}
+function previewWithdrawalFromBasis(basis, args) {
+  const claim = resolveWithdrawalClaim(basis, args);
+  return {
+    ...claim,
+    sourceCount: lpWithdrawalSourceCountForClaim(basis, {
+      ...claim,
+      allowManyToOne: args.allowManyToOne
+    })
+  };
+}
+function planWithdrawal(before, basis, args) {
+  if (before.redemptionPermission?.state !== "enabled") {
+    throw new PolicyValidationError(
+      "INVALID_REDEMPTION_PLAN",
+      LP_REDEMPTION_PERMISSION_UNAVAILABLE_MESSAGE
+    );
+  }
+  const existingRedemption = findOpenRedemptionHistory(before.actorSync?.redemptionHistory, args);
+  if (existingRedemption !== void 0) {
+    const execution = {
+      feePolicyHash: existingRedemption.feePolicyHash,
+      feeBasisRevision: existingRedemption.feeBasisRevision,
+      withdrawalId: existingRedemption.redemptionId,
+      txSignatures: [...existingRedemption.txSignatures],
+      acceptedLamports: existingRedemption.acceptedLamports,
+      acceptedDepositPrincipalLamports: existingRedemption.acceptedDepositPrincipalLamports,
+      acceptedEarnedFeeLamports: existingRedemption.acceptedEarnedFeeLamports
+    };
+    const redemption = {
+      ...buildLpRedemptionRecord({
+        execution,
+        position: before,
+        destinationAddresses: existingRedemption.destinationAddresses,
+        acceptedLamports: existingRedemption.acceptedLamports,
+        requestedTargetLamports: existingRedemption.acceptedLamports,
+        landedBaselineLamports: 0,
+        landedFeeBaselineLamports: 0,
+        txSignatureBaseline: [],
+        nowMs: existingRedemption.createdAtMs
+      }),
+      redeemedLamports: existingRedemption.landedLamports,
+      coordinatorStateVersion: existingRedemption.stateVersion
+    };
+    return { kind: "existing", execution, redemption };
+  }
+  if (args.withdrawalMode !== "exact") return { kind: "submit", preview: void 0 };
+  validateLpPositionFeePolicy(before);
+  const preview = previewWithdrawalFromBasis(basis, args);
+  validateLpWithdrawalPlan({
+    destinationAddresses: args.destinationAddresses,
+    depositPrincipalLamports: preview.depositPrincipalLamports,
+    earnedFeeLamports: preview.earnedFeeLamports,
+    allowManyToOne: args.allowManyToOne ?? false,
+    sourceCount: preview.sourceCount
+  });
+  return { kind: "submit", preview };
+}
+function reconcileLpRedemptionFromCorrelatedHistory(record, view) {
+  const history = view.actorSync?.redemptionHistory?.find(
+    (candidate) => candidate.redemptionId === record.redemptionId
+  );
+  return history === void 0 ? record : reconcileLpRedemptionFromHistory(record, history);
+}
+function resolveWithdrawalClaim(basis, args) {
   if (args.depositPrincipalLamports !== void 0 || args.earnedFeeLamports !== void 0) {
     const claim = {
       depositPrincipalLamports: args.depositPrincipalLamports ?? 0,
@@ -2386,20 +2779,19 @@ function resolveWithdrawalClaim(position, args) {
     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(
-    0,
-    position.actorSync?.redeemablePrincipalLamports ?? 0
-  );
-  const actorRedeemableFeeLamports = Math.max(0, position.actorSync?.redeemableFeeLamports ?? 0);
-  const hasActorProjection = hasActorRedeemableProjection(position.actorSync);
+  const sync = basis.actorSync;
+  const principalFromActorOnly = sync?.redeemableProjectionAvailable === true && sync.feePolicy !== void 0;
+  const legacyDepositPrincipalLamports = principalFromActorOnly ? 0 : requireAvailableShards(basis).reduce((sum, shard) => sum + shard.amountLamports, 0);
+  const actorRedeemablePrincipalLamports = Math.max(0, sync?.redeemablePrincipalLamports ?? 0);
+  const actorRedeemableFeeLamports = Math.max(0, sync?.redeemableFeeLamports ?? 0);
+  const hasActorProjection = hasActorRedeemableProjection(sync);
   const depositPrincipalLamports = resolveRedeemablePrincipalLamports(
-    position.actorSync,
+    sync,
     legacyDepositPrincipalLamports,
     actorRedeemablePrincipalLamports,
     actorRedeemableFeeLamports
   );
-  const earnedFeeLamports = hasActorProjection ? actorRedeemableFeeLamports : Math.max(0, position.earnedLamports);
+  const earnedFeeLamports = hasActorProjection ? actorRedeemableFeeLamports : Math.max(0, basis.earnedLamports);
   const totalLamports = depositPrincipalLamports + earnedFeeLamports;
   if (!Number.isSafeInteger(totalLamports) || totalLamports <= 0) {
     throw new PolicyValidationError(
@@ -2409,12 +2801,12 @@ function resolveWithdrawalClaim(position, args) {
   }
   return { depositPrincipalLamports, earnedFeeLamports };
 }
-function findOpenRedemptionHistory(position, args) {
+function findOpenRedemptionHistory(history, args) {
   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 && (history.withdrawalMode ?? "exact") === args.withdrawalMode && sameStringList(history.destinationAddresses, args.destinationAddresses) && (!hasExplicitClaim || history.acceptedDepositPrincipalLamports === requestedPrincipalLamports && history.acceptedEarnedFeeLamports === requestedFeeLamports)
+  return history?.find(
+    (history2) => LP_REDEMPTION_HISTORY_OPEN_STATES.has(history2.state) && history2.detailsTruncated !== true && (history2.withdrawalMode ?? "exact") === args.withdrawalMode && sameStringList(history2.destinationAddresses, args.destinationAddresses) && (!hasExplicitClaim || history2.acceptedDepositPrincipalLamports === requestedPrincipalLamports && history2.acceptedEarnedFeeLamports === requestedFeeLamports)
   );
 }
 function hasActorSyncLpActivity(sync) {
@@ -2488,27 +2880,31 @@ function resolveWithdrawalRecord({
     landedFeeBaselineLamports: record.landedFeeBaselineLamports ?? 0
   };
 }
-function lpWithdrawalSourceCountForClaim(position, claim) {
-  const actorSync = position.actorSync;
+function lpWithdrawalSourceCountForClaim(basis, claim) {
+  const actorSync = basis.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;
+  const actorRedeemablePrincipalSourceCount = actorSync?.redeemablePrincipalSourceCount ?? 0;
+  const actorPrincipalSourceOverride = claim.depositPrincipalLamports > 0 && actorSync?.redeemableProjectionAvailable === true && actorRedeemablePrincipalLamports >= claim.depositPrincipalLamports && actorRedeemablePrincipalSourceCount > 0;
   let principalSourceCount = 0;
-  const principalCandidates = [...position.shards].filter((shard) => shard.status === "AVAILABLE" && shard.amountLamports > 0).sort((left, right) => left.shardId.localeCompare(right.shardId));
-  for (const shard of principalCandidates) {
-    if (remainingPrincipalLamports <= 0) break;
-    principalSourceCount += 1;
-    remainingPrincipalLamports -= shard.amountLamports;
-  }
-  const actorRedeemablePrincipalSourceCount = position.actorSync?.redeemablePrincipalSourceCount ?? 0;
-  if (claim.depositPrincipalLamports > 0 && position.actorSync?.redeemableProjectionAvailable === true && actorRedeemablePrincipalLamports >= claim.depositPrincipalLamports && actorRedeemablePrincipalSourceCount > 0) {
+  if (actorPrincipalSourceOverride) {
     principalSourceCount = actorRedeemablePrincipalSourceCount;
+  } else if (claim.depositPrincipalLamports > 0) {
+    let remainingPrincipalLamports = claim.depositPrincipalLamports;
+    const principalCandidates = [...requireAvailableShards(basis)].sort(
+      (left, right) => left.shardId.localeCompare(right.shardId)
+    );
+    for (const shard of principalCandidates) {
+      if (remainingPrincipalLamports <= 0) break;
+      principalSourceCount += 1;
+      remainingPrincipalLamports -= shard.amountLamports;
+    }
   }
-  const observedEarnedFeeSourceCount = position.actorSync?.redeemableProjectionAvailable === true ? position.actorSync.redeemableFeeSourceCount ?? 0 : position.actorSync?.redeemableFeeSourceCount || position.actorSync?.reimbursementDueSourceCount || 0;
+  const observedEarnedFeeSourceCount = actorSync?.redeemableProjectionAvailable === true ? actorSync.redeemableFeeSourceCount ?? 0 : actorSync?.redeemableFeeSourceCount || actorSync?.reimbursementDueSourceCount || 0;
   if (claim.earnedFeeLamports > 0 && observedEarnedFeeSourceCount < 1 && claim.allowManyToOne !== true) {
     throw new PolicyValidationError(
       "INVALID_WITHDRAWAL_PLAN",
@@ -2731,6 +3127,9 @@ function createPosition(session, args) {
 function recoverPosition(session, args) {
   return defaultLpLifecycleClient(session).recoverPosition(args);
 }
+function recoverPositionSummary(session, args) {
+  return defaultLpLifecycleClient(session).recoverPositionSummary(args);
+}
 function confirmPositionCodeSaved(session, positionId) {
   defaultLpLifecycleClient(session).confirmPositionCodeSaved(positionId);
 }
@@ -2758,6 +3157,19 @@ function reconcileFunding2(session, positionId) {
 function withdrawPosition(session, positionId, args) {
   return defaultLpLifecycleClient(session).withdrawPosition(positionId, args);
 }
+function reconcileFundingSummary2(session, positionId) {
+  return defaultLpLifecycleClient(session).reconcileFundingSummary(positionId);
+}
+function withdrawPositionSummary(session, positionId, args) {
+  return defaultLpLifecycleClient(session).withdrawPositionSummary(positionId, args);
+}
+function waitForWithdrawalConfirmationSummary(session, positionId, execution, options = {}) {
+  return defaultLpLifecycleClient(session).waitForWithdrawalConfirmationSummary(
+    positionId,
+    execution,
+    options
+  );
+}
 function waitForWithdrawalConfirmation(session, positionId, execution, options = {}) {
   return defaultLpLifecycleClient(session).waitForWithdrawalConfirmation(
     positionId,
@@ -2774,6 +3186,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_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, mergeLpActorSync, normalizeLpActorSync, normalizeLpPositionCode, prepareInitialFunding, prepareTopUp2 as prepareTopUp, previewLpWithdrawalPlan, reconcileFunding2 as reconcileFunding, recoverPosition, refill, refreshPosition, signLpCommandBytes, validateLpPositionFeePolicy, 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_POSITION_SUMMARY_MAX_SHARDS, LP_POSITION_SUMMARY_SCHEMA_REJECTION_PREFIX, LP_POSITION_SUMMARY_SCHEMA_REJECTION_VIEW_TOKEN, LP_REDEMPTION_RECONCILING_MESSAGE, LP_SHARD_STATUSES, LP_WITHDRAWAL_FULL_INVENTORY_REQUIRED_MESSAGE, bytesToHex, completeDkgBatch, confirmPositionCodeSaved, createLpCoordinatorClient, createLpDkgBatch, createLpLifecycleClient, createPosition, defaultLpLifecycleClient, deriveLpPositionCodeAuth, generateLpPositionCode, isLpPositionAuthMissingError, isLpPositionSummaryUnsupportedError, isLpRedemptionReconcilingError, listPositions, mergeLpActorSync, normalizeLpActorSync, normalizeLpPositionCode, prepareInitialFunding, prepareTopUp2 as prepareTopUp, previewLpWithdrawalPlan, previewLpWithdrawalPlanFromSummary, reconcileFunding2 as reconcileFunding, reconcileFundingSummary2 as reconcileFundingSummary, recoverPosition, recoverPositionSummary, refill, refreshPosition, signLpCommandBytes, summarizeLpPosition, validateLpPositionFeePolicy, waitForTopUp, waitForWithdrawalConfirmation, waitForWithdrawalConfirmationSummary, withdrawFees, withdrawPosition, withdrawPositionSummary };
 //# sourceMappingURL=lp.js.map
 //# sourceMappingURL=lp.js.map