@invisible-labs/sdk 0.8.0-devnet → 0.10.0-devnet

package/dist/lp.js

@@ -1,10 +1,104 @@
-import { isValidLpPositionId, LP_DEFAULT_REFILL_BATCH_SIZE, LP_DEFAULT_TARGET_SHARDS, LP_MAX_TARGET_SHARDS, LP_MAX_REFILL_BATCH_SIZE } from './chunk-IG6JJFR2.js';
-import { publicKey, assertAttested, lamports } from './chunk-EBWTAXNT.js';
-import { requestEnvelope, CoordinatorMessageType } from './chunk-MZKJU3UA.js';
-import { getSessionState } from './chunk-HJFMDMPY.js';
-import { CommandError, WalletError, TransportError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-QRN46R3F.js';
+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-HWRMSK7E.js';
+import { publicKey, assertAttested, lamports } from './chunk-EPWTRF5U.js';
+import { requestEnvelope, CoordinatorMessageType } from './chunk-6AGC3IOB.js';
+import { getSessionState } from './chunk-6AKBRYKO.js';
+import { CommandError, WalletError, TransportError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-RWKG7N7I.js';
 import './chunk-VR6T6OJS.js';
 
+// src/lp/actorSync.ts
+function normalizeLpActorSync(sync) {
+  const total = sync.totalNetFundsLamports;
+  if (total === void 0) return sync;
+  const available = sync.redeemablePrincipalLamports + sync.redeemableFeeLamports;
+  if (sync.redeemableProjectionAvailable === true && Number.isSafeInteger(total) && total >= 0 && Number.isSafeInteger(sync.redeemablePrincipalLamports) && sync.redeemablePrincipalLamports >= 0 && Number.isSafeInteger(sync.redeemableFeeLamports) && sync.redeemableFeeLamports >= 0 && Number.isSafeInteger(available) && available >= 0 && total >= available) {
+    return sync;
+  }
+  return { ...sync, totalNetFundsLamports: void 0 };
+}
+function mergeLpActorSync(previous, next) {
+  if (next === void 0) return void 0;
+  if (previous?.lpPositionId === next.lpPositionId && (next.stateVersion < previous.stateVersion || next.stateVersion === previous.stateVersion && next.updatedAtMs < previous.updatedAtMs)) {
+    return normalizeLpActorSync(previous);
+  }
+  return normalizeLpActorSync(next);
+}
+
+// src/lp/feePolicy.ts
+var LP_FEE_POLICY_VERSION = 1;
+var LP_PARTNER_COMMISSION_BPS = 6e3;
+var LP_BASIS_POINT_DENOMINATOR = 10000n;
+var LP_FEE_POLICY_HASHES = {
+  internal: "53479c39d822899c0abe21990aeff40ea74681277b2744ef86234152cc94ca5a",
+  partner: "3e1a307504043bc0b25f03ccffdff1b42cd2b38699f000f7eb70ce9433a5b2a7"
+};
+var LP_ECONOMIC_UNSIGNED_PATTERN = /^(0|[1-9][0-9]*)$/;
+var LP_ECONOMIC_SIGNED_PATTERN = /^(0|-?[1-9][0-9]*)$/;
+var LP_ECONOMIC_UNSIGNED_MAX = (1n << 128n) - 1n;
+var LP_ECONOMIC_SIGNED_MIN = -(1n << 127n);
+var LP_ECONOMIC_SIGNED_MAX = (1n << 127n) - 1n;
+var LP_FEE_POLICY_INVALID_MESSAGE = "Coordinator LP fee policy evidence is missing or invalid";
+function validateLpFeePolicy(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new CommandError("REJECTED_STATE", LP_FEE_POLICY_INVALID_MESSAGE);
+  }
+  const policy = value;
+  if (policy.version !== LP_FEE_POLICY_VERSION || policy.profile !== "internal" && policy.profile !== "partner" || policy.commission_bps !== (policy.profile === "partner" ? LP_PARTNER_COMMISSION_BPS : 0) || typeof policy.policy_hash !== "string" || policy.policy_hash !== LP_FEE_POLICY_HASHES[policy.profile]) {
+    throw new CommandError("REJECTED_STATE", LP_FEE_POLICY_INVALID_MESSAGE);
+  }
+  return {
+    version: LP_FEE_POLICY_VERSION,
+    profile: policy.profile,
+    commission_bps: policy.profile === "partner" ? LP_PARTNER_COMMISSION_BPS : 0,
+    policy_hash: policy.policy_hash
+  };
+}
+function requireLpFeePolicyCapability(version) {
+  if (version !== LP_FEE_POLICY_VERSION) {
+    throw new RoutingError(
+      "VERSION_NOT_SUPPORTED",
+      "Coordinator does not support the LP fee policy contract"
+    );
+  }
+}
+function validateLpPositionFeePolicy(position, previous) {
+  if (position.feePolicy === void 0) {
+    if (previous?.feePolicy !== void 0 || position.actorSync?.feePolicy !== void 0 || position.actorSync?.feeBasisRevision !== void 0 || position.actorSync?.grossFeeLamports !== void 0 || position.actorSync?.protocolCommissionLamports !== void 0 || position.actorSync?.waivedProtocolCommissionLamports !== void 0) {
+      throw new CommandError("REJECTED_STATE", LP_FEE_POLICY_INVALID_MESSAGE);
+    }
+    return;
+  }
+  requireLpFeePolicyCapability(position.lpFeePolicyVersion);
+  const policy = validateLpFeePolicy(position.feePolicy);
+  const sync = position.actorSync;
+  const actorPolicy = validateLpFeePolicy(sync?.feePolicy);
+  if (JSON.stringify(policy) !== JSON.stringify(actorPolicy) || previous !== void 0 && (previous.feePolicy === void 0 || JSON.stringify(policy) !== JSON.stringify(validateLpFeePolicy(previous.feePolicy))) || sync?.lpPositionId !== position.id || sync?.redeemableProjectionAvailable !== true || !Number.isSafeInteger(sync.feeBasisRevision) || sync.feeBasisRevision < 0 || !Number.isSafeInteger(sync.grossFeeLamports) || sync.grossFeeLamports < 0 || !Number.isSafeInteger(sync.protocolCommissionLamports) || sync.protocolCommissionLamports < 0 || !Number.isSafeInteger(sync.waivedProtocolCommissionLamports) || sync.waivedProtocolCommissionLamports < 0 || sync.economicReturn === void 0) {
+    throw new CommandError("REJECTED_STATE", LP_FEE_POLICY_INVALID_MESSAGE);
+  }
+  if (BigInt(sync.protocolCommissionLamports) + BigInt(sync.waivedProtocolCommissionLamports) !== BigInt(sync.grossFeeLamports) * BigInt(policy.commission_bps) / LP_BASIS_POINT_DENOMINATOR) {
+    throw new CommandError("REJECTED_STATE", LP_FEE_POLICY_INVALID_MESSAGE);
+  }
+  for (const history of sync.redemptionHistory ?? []) {
+    if (history.feePolicyHash !== policy.policy_hash || !Number.isSafeInteger(history.feeBasisRevision) || history.feeBasisRevision < 0) {
+      throw new CommandError("REJECTED_STATE", LP_FEE_POLICY_INVALID_MESSAGE);
+    }
+  }
+  const summary = sync.economicReturn;
+  const totals = [
+    summary.providerRewardLamports,
+    summary.sourceExpenseCompensationLamports,
+    summary.chargedReimbursementLossLamports
+  ];
+  if (!totals.every(
+    (value) => typeof value === "string" && LP_ECONOMIC_UNSIGNED_PATTERN.test(value) && BigInt(value) <= LP_ECONOMIC_UNSIGNED_MAX
+  ) || typeof summary.netEconomicReturnLamports !== "string" || !LP_ECONOMIC_SIGNED_PATTERN.test(summary.netEconomicReturnLamports)) {
+    throw new CommandError("REJECTED_STATE", LP_FEE_POLICY_INVALID_MESSAGE);
+  }
+  const net = BigInt(summary.netEconomicReturnLamports);
+  if (net < LP_ECONOMIC_SIGNED_MIN || net > LP_ECONOMIC_SIGNED_MAX || net !== BigInt(summary.providerRewardLamports) - BigInt(summary.chargedReimbursementLossLamports) - BigInt(sync.protocolCommissionLamports)) {
+    throw new CommandError("REJECTED_STATE", LP_FEE_POLICY_INVALID_MESSAGE);
+  }
+}
+
 // src/lp/positionCode.ts
 var LEGACY_CODE_PREFIX = "ilp1";
 var CODE_PREFIX = "ilp2";
@@ -231,6 +325,12 @@ var COMMAND_TTL_MS = 3e4;
 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_POSITION_HYDRATION_TIMEOUT_MS = LP_COMMAND_REQUEST_TIMEOUT_MS;
+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_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;
 var LP_CREATION_WALLET_SIGNATURE_TIMEOUT_MS = 45e3;
 var LP_CREATION_PROOF_REQUEST_TIMEOUT_MS = 15e3;
@@ -325,6 +425,16 @@ async function authorizePositionCreation(session, intent, signer) {
       "Coordinator returned an unexpected LP creation authorization response"
     );
   }
+  requireLpFeePolicyCapability(challenge.value.lp_fee_policy_version);
+  const feePolicy = validateLpFeePolicy(challenge.value.fee_policy);
+  const consentLine = `LP Fee Policy: ${feePolicy.policy_hash}`;
+  const policyResource = `&fee_policy_hash=${feePolicy.policy_hash}&fee_policy_version=${feePolicy.version}`;
+  if (!challenge.value.message.split("\n").includes(consentLine) || !challenge.value.message.includes(policyResource)) {
+    throw new CommandError(
+      "REJECTED_STATE",
+      "Coordinator LP creation challenge does not bind the authorized fee policy"
+    );
+  }
   const localAuthorizationDeadlineMs = challengeRequestStartedAtMs + challenge.value.valid_for_ms;
   const walletTimeoutMs = lpCreationAuthorizationStepTimeout(
     localAuthorizationDeadlineMs,
@@ -396,7 +506,11 @@ async function authorizePositionCreation(session, intent, signer) {
     LP_CREATION_AUTHORIZATION_MARGIN_MS,
     LP_CREATION_MIN_STEP_TIMEOUT_MS
   );
-  return { authorizationId: authorization.value.authorization_id };
+  requireLpFeePolicyCapability(authorization.value.lp_fee_policy_version);
+  if (JSON.stringify(validateLpFeePolicy(authorization.value.fee_policy)) !== JSON.stringify(feePolicy)) {
+    throw new CommandError("REJECTED_STATE", "Coordinator changed the authorized LP fee policy");
+  }
+  return { authorizationId: authorization.value.authorization_id, feePolicy };
 }
 function lpCreationAuthorizationStepTimeout(localDeadlineMs, reservedMs, maximumTimeoutMs) {
   const availableMs = localDeadlineMs - Date.now() - reservedMs;
@@ -487,6 +601,7 @@ async function openPosition(session, input, auth, reconnectSession) {
     case: "positionOpen",
     value: {
       creation_authorization_id: input.creationAuthorizationId,
+      fee_policy: input.feePolicy,
       auth_public_key: Uint8Array.from(input.authPublicKey),
       refill_public_key: Uint8Array.from(input.refillPublicKey),
       redemption_commitment: Uint8Array.from(input.withdrawalCommitment),
@@ -506,6 +621,7 @@ async function openPosition(session, input, auth, reconnectSession) {
     timeoutMs: LP_POSITION_OPEN_REQUEST_TIMEOUT_MS
   };
   let response;
+  let responseSession = session;
   try {
     response = await requestForPosition(
       session,
@@ -517,17 +633,27 @@ async function openPosition(session, input, auth, reconnectSession) {
     );
   } 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
+    responseSession = reconnectSession === void 0 ? session : await reconnectSessionWithinDeadline(reconnectSession, commandDeadlineMs);
+  }
+  const position = await hydratePositionResponse(
+    responseSession,
+    auth.lpPositionId,
+    auth,
+    response,
+    {
+      deadlineMs: commandDeadlineMs
+    }
+  );
+  if (position.authPublicKey !== bytesToHex(Uint8Array.from(input.authPublicKey)) || position.refillPublicKey !== bytesToHex(Uint8Array.from(input.refillPublicKey)) || position.withdrawalCommitment !== bytesToHex(Uint8Array.from(input.withdrawalCommitment)) || position.committedLamports !== input.committedLamports || position.targetShardCount !== input.shardCount || position.refillThreshold !== input.refillThreshold || position.createdAt !== input.createdAtMs) {
+    throw new CommandError("REJECTED_STATE", LP_POSITION_OPEN_IDENTITY_MISMATCH_MESSAGE);
+  }
+  if (input.feePolicy !== void 0 && position.feePolicy?.policy_hash !== input.feePolicy.policy_hash) {
+    throw new CommandError(
+      "REJECTED_STATE",
+      "Coordinator opened the LP position with a different fee policy"
     );
   }
-  return expectPosition(response);
+  return position;
 }
 async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
   const remainingMs = deadlineMs - Date.now();
@@ -561,37 +687,131 @@ 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 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;
-    const actorSync = page.actorSync;
-    if (actorSync?.redemptionHistoryHasMore !== true) return mergedPosition;
-    const nextCursor = actorSync.redemptionHistoryNextCursor;
-    if (nextCursor === void 0 || seenCursors.has(nextCursor)) {
-      throw new CommandError(
-        "REJECTED_STATE",
-        "coordinator LP actor sync returned an invalid redemption history cursor"
+  return hydratePositionResponse(session, lpPositionId, auth, void 0, options);
+}
+async function hydratePositionResponse(session, lpPositionId, auth, initialResponse, options = {}) {
+  const boundedOptions = {
+    ...options,
+    deadlineMs: options.deadlineMs ?? Date.now() + LP_POSITION_HYDRATION_TIMEOUT_MS
+  };
+  for (let attempt = 0; attempt < LP_POSITION_SNAPSHOT_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const response = initialResponse ?? await requestForPosition(
+        session,
+        lpPositionId,
+        auth,
+        "position_get",
+        { case: "positionGet", value: {} },
+        boundedOptions
       );
+      if (response.case !== "position")
+        throw new CommandError("REJECTED_STATE", LP_SHARD_PAGE_INVALID_MESSAGE);
+      const first = response.value;
+      let full = first;
+      if (first.shards_snapshot_hash !== void 0 || first.shards_total_count !== void 0 || first.shards_next_index !== void 0) {
+        assertShardPage(first, first, lpPositionId, auth, 0);
+        const shards = [...first.shards];
+        let nextIndex = first.shards_next_index;
+        while (nextIndex !== void 0) {
+          const nextResponse = await requestForPosition(
+            session,
+            lpPositionId,
+            auth,
+            "position_get",
+            {
+              case: "positionGet",
+              value: {
+                shard_start_index: nextIndex,
+                shards_snapshot_hash: first.shards_snapshot_hash
+              }
+            },
+            boundedOptions
+          );
+          if (nextResponse.case !== "position")
+            throw new CommandError("REJECTED_STATE", LP_SHARD_PAGE_INVALID_MESSAGE);
+          assertShardPage(first, nextResponse.value, lpPositionId, auth, nextIndex);
+          shards.push(...nextResponse.value.shards);
+          nextIndex = nextResponse.value.shards_next_index;
+        }
+        if (shards.length !== first.shards_total_count)
+          throw new CommandError("REJECTED_STATE", LP_SHARD_PAGE_INVALID_MESSAGE);
+        full = { ...first, shards };
+      } else if (first.target_shard_count > LP_MAX_TOTAL_SHARDS || first.lp_position_id !== lpPositionId || first.shards.length > LP_MAX_INITIAL_SHARDS || first.status !== "dkg_pending" && first.target_shard_count > LP_MAX_INITIAL_SHARDS && first.shards.length !== first.target_shard_count || first.status === "dkg_pending" && first.target_shard_count > LP_MAX_INITIAL_SHARDS && first.target_shard_count - first.shards.length > LP_MAX_REFILL_BATCH_SIZE) {
+        throw new CommandError("REJECTED_STATE", LP_SHARD_PAGE_INVALID_MESSAGE);
+      }
+      let position = mapPosition(full);
+      let historyPage = first;
+      const seenCursors = /* @__PURE__ */ new Set();
+      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"
+          );
+        }
+        seenCursors.add(cursor);
+        const nextResponse = await requestForPosition(
+          session,
+          lpPositionId,
+          auth,
+          "position_get",
+          {
+            case: "positionGet",
+            value: {
+              redemption_history_cursor: cursor,
+              ...first.shards_snapshot_hash === void 0 ? {} : { shard_start_index: 0, shards_snapshot_hash: first.shards_snapshot_hash }
+            }
+          },
+          boundedOptions
+        );
+        if (nextResponse.case !== "position")
+          throw new CommandError("REJECTED_STATE", LP_SHARD_PAGE_INVALID_MESSAGE);
+        historyPage = nextResponse.value;
+        if (first.shards_snapshot_hash !== void 0)
+          assertShardPage(first, historyPage, lpPositionId, auth, 0);
+        const historyView = mapPosition(historyPage);
+        validateLpPositionFeePolicy(historyView, position);
+        const merged = mergePositionHistoryPages(position, historyView);
+        position = first.shards_snapshot_hash === void 0 ? merged : {
+          ...position,
+          actorSync: position.actorSync === void 0 ? void 0 : {
+            ...position.actorSync,
+            redemptionHistory: merged.actorSync?.redemptionHistory,
+            redemptionHistoryHasMore: historyView.actorSync?.redemptionHistoryHasMore ?? false,
+            redemptionHistoryNextCursor: historyView.actorSync?.redemptionHistoryNextCursor
+          }
+        };
+      }
+      lpPositionPageRequestOptions(boundedOptions);
+      return position;
+    } catch (error) {
+      if (!(error instanceof CommandError) || !error.message.includes(LP_SHARD_SNAPSHOT_CHANGED_MESSAGE) || attempt + 1 >= LP_POSITION_SNAPSHOT_MAX_ATTEMPTS)
+        throw error;
+      initialResponse = void 0;
+      lpPositionPageRequestOptions(boundedOptions);
     }
-    seenCursors.add(nextCursor);
-    cursor = nextCursor;
   }
+  throw new CommandError("REJECTED_STATE", LP_SHARD_SNAPSHOT_CHANGED_MESSAGE);
+}
+function assertShardPage(first, page, lpPositionId, auth, startIndex) {
+  const total = first.shards_total_count;
+  const invalid = () => {
+    throw new CommandError("REJECTED_STATE", LP_SHARD_PAGE_INVALID_MESSAGE);
+  };
+  if (total === void 0 || !Number.isInteger(total) || total < 1 || total > LP_MAX_TOTAL_SHARDS || total > first.target_shard_count || first.status !== "dkg_pending" && total !== first.target_shard_count || first.shards_snapshot_hash === void 0 || !LP_SHARD_SNAPSHOT_HASH_PATTERN.test(first.shards_snapshot_hash) || page.lp_position_id !== lpPositionId || page.shards_snapshot_hash !== first.shards_snapshot_hash || page.shards_total_count !== total || page.target_shard_count !== first.target_shard_count || page.status !== "dkg_pending" && total !== page.target_shard_count || page.created_at_ms !== first.created_at_ms || page.committed_lamports !== first.committed_lamports || page.earned_lamports !== first.earned_lamports || page.refill_threshold !== first.refill_threshold || page.fee_policy?.policy_hash !== first.fee_policy?.policy_hash || page.lp_fee_policy_version !== first.lp_fee_policy_version || bytesToHex(page.auth_public_key) !== bytesToHex(auth.authPublicKey) || bytesToHex(page.refill_public_key) !== bytesToHex(first.refill_public_key) || bytesToHex(page.redemption_commitment) !== bytesToHex(first.redemption_commitment) || page.shards.length !== Math.min(LP_SHARD_PAGE_SIZE, total - startIndex) || page.shards.length === 0)
+    invalid();
+  for (const [offset, shard] of page.shards.entries()) {
+    const index = startIndex + offset;
+    if (shard.index !== index || shard.lp_position_id !== lpPositionId || shard.shard_id !== `${lpPositionId}:shard:${index}`)
+      invalid();
+  }
+  const end = startIndex + page.shards.length;
+  if (total === void 0) invalid();
+  if (end < total ? page.shards_next_index !== end : page.shards_next_index !== void 0)
+    invalid();
+  if (page.status !== first.status)
+    throw new CommandError("REJECTED_STATE", LP_SHARD_SNAPSHOT_CHANGED_MESSAGE);
 }
 function lpPositionPageRequestOptions(options) {
   if (options.deadlineMs === void 0) return options;
@@ -614,7 +834,7 @@ async function finalizeDkgBatch(session, input, auth) {
       finalized_at_ms: input.finalizedAtMs
     }
   });
-  return expectPosition(response);
+  return hydratePositionResponse(session, auth.lpPositionId, auth, response);
 }
 async function refillPosition(session, input, auth) {
   const response = await requestForPosition(session, input.lpPositionId, auth, "refill", {
@@ -626,14 +846,14 @@ async function refillPosition(session, input, auth) {
       authorized_at_ms: input.authorizedAtMs
     }
   });
-  return expectPosition(response);
+  return hydratePositionResponse(session, auth.lpPositionId, auth, response);
 }
 async function reconcileFunding(session, lpPositionId, auth) {
   const response = await requestForPosition(session, lpPositionId, auth, "reconcile_funding", {
     case: "reconcileFunding",
     value: {}
   });
-  return expectPosition(response);
+  return hydratePositionResponse(session, auth.lpPositionId, auth, response);
 }
 async function planFunding(session, input, auth) {
   const response = await requestForPosition(session, input.lpPositionId, auth, "funding_plan", {
@@ -707,13 +927,21 @@ async function executeWithdrawal(session, input, auth) {
       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
+      requested_at_ms: input.requestedAtMs,
+      fee_policy_hash: input.feePolicyHash,
+      fee_basis_revision: input.feeBasisRevision
     }
   });
   if (response.case !== "withdrawalExecution") {
     throw new Error("Unexpected LP withdrawal execution response");
   }
   const execution = response.value;
+  if (execution.fee_policy_hash !== input.feePolicyHash || execution.fee_basis_revision !== input.feeBasisRevision) {
+    throw new PolicyValidationError(
+      "INVALID_WITHDRAWAL_PLAN",
+      "Coordinator accepted a different LP fee policy or fee basis"
+    );
+  }
   if (BigInt(execution.accepted_lamports) !== BigInt(execution.accepted_deposit_principal_lamports) + BigInt(execution.accepted_earned_fee_lamports)) {
     throw new PolicyValidationError(
       "INVALID_WITHDRAWAL_PLAN",
@@ -727,6 +955,8 @@ async function executeWithdrawal(session, input, auth) {
     );
   }
   return {
+    feePolicyHash: execution.fee_policy_hash,
+    feeBasisRevision: execution.fee_basis_revision,
     withdrawalId: execution.withdrawal_id,
     txSignatures: [...execution.tx_signatures],
     acceptedLamports: execution.accepted_lamports,
@@ -738,7 +968,7 @@ function request(session, auth, action, payload) {
   return requestForPosition(session, auth.lpPositionId, auth, action, payload);
 }
 async function requestForPosition(session, lpPositionId, auth, action, payload, options = {}) {
-  const timeoutMs = options.timeoutMs ?? LP_COMMAND_REQUEST_TIMEOUT_MS;
+  const timeoutMs = lpPositionPageRequestOptions(options).timeoutMs ?? LP_COMMAND_REQUEST_TIMEOUT_MS;
   assertAuthMatchesPosition(lpPositionId, auth);
   const protocol = await loadProtocol();
   const state = getSessionState(session);
@@ -773,12 +1003,10 @@ function assertAuthMatchesPosition(lpPositionId, auth) {
     "LP Position Code does not match the target LP position"
   );
 }
-function expectPosition(response) {
-  if (response.case !== "position") throw new Error("Unexpected LP position response");
-  return mapPosition(response.value);
-}
 function mapPosition(position) {
-  return {
+  const mapped = {
+    feePolicy: position.fee_policy === void 0 ? void 0 : validateLpFeePolicy(position.fee_policy),
+    lpFeePolicyVersion: position.lp_fee_policy_version,
     id: position.lp_position_id,
     status: position.status,
     targetShardCount: position.target_shard_count,
@@ -793,6 +1021,8 @@ function mapPosition(position) {
     redemptionPermission: mapLpRedemptionPermission(position.redemption_permission),
     ...position.actor_sync === void 0 ? {} : { actorSync: mapLpActorSync(position.actor_sync) }
   };
+  validateLpPositionFeePolicy(mapped);
+  return mapped;
 }
 function mapLpRedemptionPermission(permission) {
   if (permission === void 0) {
@@ -822,10 +1052,22 @@ function mapLpActorSync(actorSync) {
     );
   }
   const redeemableProjectionAvailable = redeemableBucketCount === redeemableBucketValues.length;
-  return {
+  return normalizeLpActorSync({
+    ...actorSync.economic_return === void 0 ? {} : {
+      economicReturn: mapLpEconomicReturn(
+        actorSync.economic_return,
+        actorSync.protocol_commission_lamports ?? 0
+      )
+    },
+    feePolicy: actorSync.fee_policy === void 0 ? void 0 : validateLpFeePolicy(actorSync.fee_policy),
+    feeBasisRevision: actorSync.fee_basis_revision,
+    grossFeeLamports: actorSync.gross_fee_lamports,
+    protocolCommissionLamports: actorSync.protocol_commission_lamports,
+    waivedProtocolCommissionLamports: actorSync.waived_protocol_commission_lamports,
     lpPositionId: actorSync.lp_position_id,
     status: actorSync.status,
     sourceLiquidityUse: actorSync.source_liquidity_use,
+    totalNetFundsLamports: actorSync.total_net_funds_lamports,
     redeemableProjectionAvailable,
     redeemablePrincipalLamports: actorSync.redeemable_principal_lamports ?? 0,
     redeemableFeeLamports: actorSync.redeemable_fee_lamports ?? 0,
@@ -851,6 +1093,33 @@ function mapLpActorSync(actorSync) {
     ...actorSync.redemption_history_next_cursor === void 0 ? {} : { redemptionHistoryNextCursor: actorSync.redemption_history_next_cursor },
     stateVersion: actorSync.state_version,
     updatedAtMs: actorSync.updated_at_ms
+  });
+}
+var LP_ECONOMIC_UNSIGNED_TOTAL_MAX = (1n << 128n) - 1n;
+var LP_ECONOMIC_SIGNED_TOTAL_MIN = -(1n << 127n);
+var LP_ECONOMIC_SIGNED_TOTAL_MAX = (1n << 127n) - 1n;
+var LP_ECONOMIC_UNSIGNED_DECIMAL = /^(0|[1-9][0-9]*)$/;
+var LP_ECONOMIC_SIGNED_DECIMAL = /^(0|-?[1-9][0-9]*)$/;
+function mapLpEconomicReturn(summary, protocolCommissionLamports) {
+  const unsigned = [
+    summary.provider_reward_lamports,
+    summary.source_expense_compensation_lamports,
+    summary.charged_reimbursement_loss_lamports
+  ];
+  const valid = unsigned.every(
+    (value) => typeof value === "string" && LP_ECONOMIC_UNSIGNED_DECIMAL.test(value) && BigInt(value) <= LP_ECONOMIC_UNSIGNED_TOTAL_MAX
+  ) && typeof summary.net_economic_return_lamports === "string" && LP_ECONOMIC_SIGNED_DECIMAL.test(summary.net_economic_return_lamports);
+  if (!valid)
+    throw new CommandError("REJECTED_STATE", "coordinator LP economic return totals are invalid");
+  const net = BigInt(summary.net_economic_return_lamports);
+  if (net < LP_ECONOMIC_SIGNED_TOTAL_MIN || net > LP_ECONOMIC_SIGNED_TOTAL_MAX || net !== BigInt(summary.provider_reward_lamports) - BigInt(summary.charged_reimbursement_loss_lamports) - BigInt(protocolCommissionLamports)) {
+    throw new CommandError("REJECTED_STATE", "coordinator LP economic return invariant is invalid");
+  }
+  return {
+    providerRewardLamports: summary.provider_reward_lamports,
+    sourceExpenseCompensationLamports: summary.source_expense_compensation_lamports,
+    chargedReimbursementLossLamports: summary.charged_reimbursement_loss_lamports,
+    netEconomicReturnLamports: summary.net_economic_return_lamports
   };
 }
 function mergePositionHistoryPages(first, next) {
@@ -874,6 +1143,8 @@ function mergePositionHistoryPages(first, next) {
 }
 function mapLpRedemptionHistory(history) {
   return {
+    feePolicyHash: history.fee_policy_hash,
+    feeBasisRevision: history.fee_basis_revision,
     redemptionId: history.redemption_id,
     state: history.state,
     ...history.withdrawal_mode === void 0 ? {} : { withdrawalMode: history.withdrawal_mode },
@@ -955,7 +1226,7 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-E2TS6NR2.js');
+  protocolPromise ??= import('./coordinator-T2B7253V.js');
   return protocolPromise;
 }
 
@@ -1253,6 +1524,7 @@ function isLpPositionAuthMissingError(error) {
   return error instanceof LpPositionAuthMissingError || error instanceof Error && error.message === LP_MISSING_POSITION_CODE_MESSAGE;
 }
 function previewLpWithdrawalPlan(position, args = {}) {
+  validateLpPositionFeePolicy(position);
   const claim = resolveWithdrawalClaim(position, args);
   return {
     ...claim,
@@ -1285,11 +1557,13 @@ function createLpLifecycleClient(session, runtime = {}) {
     return auth;
   };
   const rememberPosition = (position) => {
+    validateLpPositionFeePolicy(position, state.positions.get(position.id));
     const snapshot = clonePosition(position);
     const previous = state.positions.get(snapshot.id);
-    const merged = previous === void 0 ? snapshot : {
+    const merged = {
       ...snapshot,
-      redemptionPermission: mergeLpRedemptionPermission(
+      actorSync: mergeLpActorSync(previous?.actorSync, snapshot.actorSync),
+      redemptionPermission: previous === void 0 ? snapshot.redemptionPermission : mergeLpRedemptionPermission(
         previous.redemptionPermission,
         snapshot.redemptionPermission
       )
@@ -1327,7 +1601,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       const current = rememberPosition(await client.getPosition(positionId, auth));
       options.onPosition?.(current);
       const startIndex = current.shards.length;
-      const remaining = current.targetShardCount - startIndex;
+      const remaining = Math.min(current.targetShardCount - startIndex, LP_MAX_INITIAL_SHARDS);
       if (remaining <= 0) return current;
       emitDkgProgress(options, current, startIndex, remaining, 0);
       let expectedAddresses = null;
@@ -1357,7 +1631,9 @@ function createLpLifecycleClient(session, runtime = {}) {
         );
         options.onPosition?.(position);
         emitDkgProgress(options, position, startIndex, remaining, remaining);
-        return rememberPosition(position);
+        rememberPosition(position);
+        if (position.shards.length < position.targetShardCount) continue;
+        return position;
       } catch (error) {
         const reconciled = await tryRefreshCompletedDkgWindow({
           client,
@@ -1387,7 +1663,7 @@ function createLpLifecycleClient(session, runtime = {}) {
     async createPosition(args) {
       assertNoUnsupportedFeePolicy(args.feePolicy);
       const shardCount = args.shardCount ?? LP_DEFAULT_TARGET_SHARDS;
-      assertShardCount(shardCount, LP_MAX_TARGET_SHARDS, "shardCount");
+      assertShardCount(shardCount, LP_MAX_INITIAL_SHARDS, "shardCount");
       assertAttested(currentSession);
       const committedLamports = args.committedLamports ?? DEFAULT_SHARD_FUNDING_LAMPORTS;
       const refillThreshold = args.refillThreshold ?? Math.ceil(shardCount * DEFAULT_REFILL_THRESHOLD_RATIO);
@@ -1408,6 +1684,7 @@ function createLpLifecycleClient(session, runtime = {}) {
           {
             lpPositionId: positionId,
             creationAuthorizationId: creationAuthorization.authorizationId,
+            feePolicy: creationAuthorization.feePolicy,
             authPublicKey: Array.from(auth.authPublicKey),
             refillPublicKey: Array.from(auth.refillPublicKey),
             withdrawalCommitment: Array.from(auth.withdrawalCommitment),
@@ -1448,11 +1725,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       const auth = requireAuth(positionId);
       const current = await refreshPosition2(positionId);
       args.onPosition?.(current);
-      const refillShardCount = resolveLpRefillShardCount(
-        current,
-        requestedShardCount,
-        args.shardCount === void 0
-      );
+      const refillShardCount = resolveLpRefillShardCount(current, requestedShardCount);
       const authorizedPosition = rememberPosition(
         await client.refillPosition(
           {
@@ -1572,6 +1845,8 @@ function createLpLifecycleClient(session, runtime = {}) {
       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,
@@ -1616,6 +1891,8 @@ function createLpLifecycleClient(session, runtime = {}) {
           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
@@ -1744,6 +2021,7 @@ async function tryRefreshCompletedDkgWindow({
   const position = await client.getPosition(positionId, auth).catch(() => null);
   if (position === null) return null;
   if (!hasCompletedDkgWindow(position, startIndex, total, expectedAddresses)) return null;
+  validateLpPositionFeePolicy(position, state.positions.get(position.id));
   state.positions.set(position.id, clonePosition(position));
   return position;
 }
@@ -1785,21 +2063,12 @@ function assertShardCount(value, max, field) {
     );
   }
 }
-function resolveLpRefillShardCount(position, requestedShardCount, capDefaultBatch) {
-  const remainingShardCapacity = LP_MAX_TARGET_SHARDS - position.shards.length;
-  if (remainingShardCapacity <= 0) {
-    throw new PolicyValidationError(
-      "INVALID_AMOUNT",
-      `LP refill target_shard_count is already at ${LP_MAX_TARGET_SHARDS}`
-    );
-  }
-  const refillShardCount = capDefaultBatch ? Math.min(requestedShardCount, remainingShardCapacity) : requestedShardCount;
-  if (position.shards.length + refillShardCount > LP_MAX_TARGET_SHARDS) {
-    throw new PolicyValidationError(
-      "INVALID_AMOUNT",
-      `LP refill target_shard_count must be <= ${LP_MAX_TARGET_SHARDS}`
-    );
+function resolveLpRefillShardCount(position, requestedShardCount) {
+  const nextTarget = position.shards.length + requestedShardCount;
+  if (!Number.isSafeInteger(nextTarget) || nextTarget > LP_MAX_TOTAL_SHARDS) {
+    throw new PolicyValidationError("INVALID_AMOUNT", "LP refill target_shard_count overflows u32");
   }
+  const refillShardCount = requestedShardCount;
   return refillShardCount;
 }
 function isLpPositionReadyForInitialFunding(position) {
@@ -1851,7 +2120,9 @@ function hasActorSyncLpActivity(sync) {
 }
 function resolveRedeemablePrincipalLamports(sync, legacyAvailableLamports, actorRedeemablePrincipalLamports, actorRedeemableFeeLamports) {
   if (sync?.redeemableProjectionAvailable !== true) return legacyAvailableLamports;
-  if (legacyAvailableLamports <= 0) return actorRedeemablePrincipalLamports;
+  if (sync.feePolicy !== void 0 || legacyAvailableLamports <= 0) {
+    return actorRedeemablePrincipalLamports;
+  }
   if (actorRedeemablePrincipalLamports >= legacyAvailableLamports || hasActorSyncLpActivity(sync)) {
     return actorRedeemablePrincipalLamports;
   }
@@ -1956,6 +2227,8 @@ function buildLpRedemptionRecord({
   nowMs
 }) {
   return {
+    feePolicyHash: execution.feePolicyHash,
+    feeBasisRevision: execution.feeBasisRevision,
     redemptionId: execution.withdrawalId,
     lpPositionId: position.id,
     requestedAt: nowMs,
@@ -2004,7 +2277,7 @@ function reconcileLpRedemptionFromActorSync(record, position) {
 function reconcileLpRedemptionFromHistory(record, history) {
   const observedStateVersion = record.coordinatorStateVersion ?? 0;
   if (history.stateVersion < observedStateVersion) return record;
-  if (record.acceptedLamports !== void 0 && history.acceptedLamports !== record.acceptedLamports || history.detailsTruncated !== true && !sameStringList(history.destinationAddresses, record.destinationAddresses)) {
+  if (history.feePolicyHash !== record.feePolicyHash || history.feeBasisRevision !== record.feeBasisRevision || record.acceptedLamports !== void 0 && history.acceptedLamports !== record.acceptedLamports || history.detailsTruncated !== true && !sameStringList(history.destinationAddresses, record.destinationAddresses)) {
     return {
       ...record,
       status: "failed",
@@ -2017,6 +2290,7 @@ function reconcileLpRedemptionFromHistory(record, history) {
     ...record,
     coordinatorStateVersion: history.stateVersion,
     redeemedLamports: history.landedLamports,
+    networkFeeLossLamports: history.networkFeeLossLamports,
     txSignatures,
     destinationCount: history.destinationCount,
     txSignatureCount: history.txSignatureCount,
@@ -2053,6 +2327,8 @@ function hydrateLpRedemptionsFromPosition(state, position) {
 }
 function lpWithdrawalRecordFromHistory(position, history) {
   const record = {
+    feePolicyHash: history.feePolicyHash,
+    feeBasisRevision: history.feeBasisRevision,
     redemptionId: history.redemptionId,
     lpPositionId: position.id,
     requestedAt: history.createdAtMs,
@@ -2063,6 +2339,7 @@ function lpWithdrawalRecordFromHistory(position, history) {
     landedBaselineLamports: 0,
     landedFeeBaselineLamports: 0,
     redeemedLamports: history.landedLamports,
+    networkFeeLossLamports: history.networkFeeLossLamports,
     txSignatures: [...history.txSignatures],
     txSignatureBaseline: [],
     coordinatorStateVersion: history.stateVersion,
@@ -2081,6 +2358,7 @@ function uniqueStrings(values) {
 function clonePosition(position) {
   return {
     ...position,
+    feePolicy: position.feePolicy === void 0 ? void 0 : { ...position.feePolicy },
     shards: position.shards.map((shard) => ({ ...shard })),
     actorSync: position.actorSync === void 0 ? void 0 : {
       ...position.actorSync,
@@ -2193,6 +2471,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, normalizeLpPositionCode, prepareInitialFunding, prepareTopUp2 as prepareTopUp, previewLpWithdrawalPlan, 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, mergeLpActorSync, normalizeLpActorSync, normalizeLpPositionCode, prepareInitialFunding, prepareTopUp2 as prepareTopUp, previewLpWithdrawalPlan, reconcileFunding2 as reconcileFunding, recoverPosition, refill, refreshPosition, signLpCommandBytes, validateLpPositionFeePolicy, waitForTopUp, waitForWithdrawalConfirmation, withdrawFees, withdrawPosition };
 //# sourceMappingURL=lp.js.map
 //# sourceMappingURL=lp.js.map