@invisible-labs/sdk 0.9.0-devnet → 0.11.0-devnet

package/dist/lp.js

@@ -1,10 +1,104 @@
-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-ISIWWGSR.js';
-import { getSessionState } from './chunk-6AKBRYKO.js';
-import { CommandError, WalletError, TransportError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-RWKG7N7I.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-TNLSUQGJ.js';
+import { publicKey, assertAttested, lamports } from './chunk-TYTVF3A4.js';
+import { requestEnvelope, CoordinatorMessageType } from './chunk-NOKBFHDP.js';
+import { getSessionState } from './chunk-DOTYDYVB.js';
+import { CommandError, TransportError, PolicyValidationError, LpLifecycleError, RoutingError, WalletError } from './chunk-A4R3DHKN.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";
@@ -235,6 +329,7 @@ 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;
@@ -248,62 +343,108 @@ var protocolPromise = null;
 function createLpCoordinatorClient(session, options = {}) {
   const sessionRef = { current: session };
   const reconnectSession = options.reconnectSession === void 0 ? void 0 : async () => {
+    options.signal?.throwIfAborted();
     const nextSession = await options.reconnectSession();
+    options.signal?.throwIfAborted();
     sessionRef.current = nextSession;
     return nextSession;
   };
+  const run = (operation, signal) => withLpClientSignal(options.signal, signal, operation);
   return {
     authorizePositionCreation(intent, signer) {
-      return authorizePositionCreation(sessionRef.current, intent, signer);
+      return run((signal) => authorizePositionCreation(sessionRef.current, intent, signer, signal));
     },
-    initDkg(input, auth) {
-      return initDkg(sessionRef.current, input, auth);
+    initDkg(input, auth, options2) {
+      return run((signal) => initDkg(sessionRef.current, input, auth, { signal }), options2?.signal);
     },
     abortDkgSessions(lpPositionId, auth) {
       return abortDkgSessions(sessionRef.current, lpPositionId, auth);
     },
-    dkgRound1(input, auth) {
-      return dkgRound1(sessionRef.current, input, auth);
+    dkgRound1(input, auth, options2) {
+      return run(
+        (signal) => dkgRound1(sessionRef.current, input, auth, { signal }),
+        options2?.signal
+      );
     },
-    dkgRound2(input, auth) {
-      return dkgRound2(sessionRef.current, input, auth);
+    dkgRound2(input, auth, options2) {
+      return run(
+        (signal) => dkgRound2(sessionRef.current, input, auth, { signal }),
+        options2?.signal
+      );
     },
     openPosition(input, auth) {
-      return openPosition(sessionRef.current, input, auth, reconnectSession);
+      return run(
+        (signal) => openPosition(sessionRef.current, input, auth, reconnectSession, signal)
+      );
     },
     getPosition(lpPositionId, auth, options2) {
-      return getPosition(sessionRef.current, lpPositionId, auth, options2);
+      return run(
+        (signal) => getPosition(sessionRef.current, lpPositionId, auth, { ...options2, signal }),
+        options2?.signal
+      );
     },
     finalizeDkgBatch(input, auth) {
-      return finalizeDkgBatch(sessionRef.current, input, auth);
+      return run((signal) => finalizeDkgBatch(sessionRef.current, input, auth, { signal }));
     },
     refillPosition(input, auth) {
-      return refillPosition(sessionRef.current, input, auth);
+      return run((signal) => refillPosition(sessionRef.current, input, auth, { signal }));
     },
     reconcileFunding(lpPositionId, auth) {
-      return reconcileFunding(sessionRef.current, lpPositionId, auth);
+      return run((signal) => reconcileFunding(sessionRef.current, lpPositionId, auth, { signal }));
     },
     planFunding(input, auth) {
-      return planFunding(sessionRef.current, input, auth);
+      return run((signal) => planFunding(sessionRef.current, input, auth, { signal }));
     },
     confirmFunding(input, auth) {
-      return confirmFunding(sessionRef.current, input, auth);
+      return run((signal) => confirmFunding(sessionRef.current, input, auth, { signal }));
     },
     prepareTopUp(lpPositionId, auth) {
-      return prepareTopUp(sessionRef.current, lpPositionId, auth);
+      return run((signal) => prepareTopUp(sessionRef.current, lpPositionId, auth, { signal }));
     },
     getTopUpStatus(input, auth) {
-      return getTopUpStatus(sessionRef.current, input, auth);
+      return run((signal) => getTopUpStatus(sessionRef.current, input, auth, { signal }));
     },
     makeAvailable(input, auth) {
-      return makeAvailable(sessionRef.current, input, auth);
+      return run((signal) => makeAvailable(sessionRef.current, input, auth, { signal }));
     },
     executeWithdrawal(input, auth) {
-      return executeWithdrawal(sessionRef.current, input, auth);
+      return run((signal) => executeWithdrawal(sessionRef.current, input, auth, { signal }));
+    }
+  };
+}
+async function withLpClientSignal(clientSignal, requestSignal, operation) {
+  const perform = async (signal) => {
+    try {
+      signal?.throwIfAborted();
+      return await operation(signal);
+    } catch (error) {
+      if (clientSignal?.aborted && signal?.reason === clientSignal.reason && error instanceof Error && error.name === "AbortError") {
+        throw clientSignal.reason;
+      }
+      throw error;
     }
   };
+  if (clientSignal === void 0) return perform(requestSignal);
+  if (requestSignal === void 0 || requestSignal === clientSignal) {
+    clientSignal.throwIfAborted();
+    return perform(clientSignal);
+  }
+  const controller = new AbortController();
+  const abortClient = () => controller.abort(clientSignal.reason);
+  const abortRequest = () => controller.abort(requestSignal.reason);
+  clientSignal.addEventListener("abort", abortClient, { once: true });
+  requestSignal.addEventListener("abort", abortRequest, { once: true });
+  try {
+    if (clientSignal.aborted) abortClient();
+    if (requestSignal.aborted) abortRequest();
+    controller.signal.throwIfAborted();
+    return await perform(controller.signal);
+  } finally {
+    clientSignal.removeEventListener("abort", abortClient);
+    requestSignal.removeEventListener("abort", abortRequest);
+  }
 }
-async function authorizePositionCreation(session, intent, signer) {
+async function authorizePositionCreation(session, intent, signer, signal) {
   const signerPublicKey = publicKey(signer.publicKey);
   const challengeRequestStartedAtMs = Date.now();
   const challengeEnvelope = await requestEnvelope(
@@ -321,7 +462,7 @@ async function authorizePositionCreation(session, intent, signer) {
         }
       }
     },
-    { timeoutMs: LP_CREATION_CHALLENGE_REQUEST_TIMEOUT_MS }
+    { timeoutMs: LP_CREATION_CHALLENGE_REQUEST_TIMEOUT_MS, signal }
   );
   const challenge = challengeEnvelope.payload;
   if (challenge.case !== "challenge") {
@@ -330,6 +471,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,
@@ -367,7 +518,7 @@ async function authorizePositionCreation(session, intent, signer) {
       session,
       CoordinatorMessageType.LpCreateAuthorization,
       proofPayload,
-      { timeoutMs: proofTimeoutMs }
+      { timeoutMs: proofTimeoutMs, signal }
     );
   } catch (error) {
     if (!isAmbiguousCoordinatorRequestFailure(error)) throw error;
@@ -380,7 +531,7 @@ async function authorizePositionCreation(session, intent, signer) {
       session,
       CoordinatorMessageType.LpCreateAuthorization,
       proofPayload,
-      { timeoutMs: proofRetryTimeoutMs }
+      { timeoutMs: proofRetryTimeoutMs, signal }
     );
   }
   const authorization = proofEnvelope.payload;
@@ -401,7 +552,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;
@@ -433,15 +588,22 @@ async function signLpCreationMessageWithTimeout(signer, message, timeoutMs) {
     if (timeoutId !== void 0) clearTimeout(timeoutId);
   }
 }
-async function initDkg(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "dkg_init", {
-    case: "dkgInit",
-    value: { index: input.index }
-  });
+async function initDkg(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "dkg_init",
+    {
+      case: "dkgInit",
+      value: { index: input.index }
+    },
+    options
+  );
   if (response.case !== "dkgInit") throw new Error("Unexpected LP DKG init response");
   return { sessionId: response.value.session_id };
 }
-async function abortDkgSessions(session, lpPositionId, auth) {
+async function abortDkgSessions(session, lpPositionId, auth, signal) {
   const response = await requestForPosition(
     session,
     lpPositionId,
@@ -451,34 +613,46 @@ async function abortDkgSessions(session, lpPositionId, auth) {
       case: "dkgAbort",
       value: {}
     },
-    { timeoutMs: LP_DKG_ABORT_REQUEST_TIMEOUT_MS }
+    { timeoutMs: LP_DKG_ABORT_REQUEST_TIMEOUT_MS, signal }
   );
   if (response.case !== "dkgAbort") throw new Error("Unexpected LP DKG abort response");
   return { abortedSessionCount: response.value.aborted_session_count };
 }
-async function dkgRound1(session, input, auth) {
-  const response = await request(session, auth, "dkg_round1", {
-    case: "dkgRound1",
-    value: {
-      session_id: input.sessionId,
-      package: Uint8Array.from(input.package)
-    }
-  });
+async function dkgRound1(session, input, auth, options = {}) {
+  const response = await request(
+    session,
+    auth,
+    "dkg_round1",
+    {
+      case: "dkgRound1",
+      value: {
+        session_id: input.sessionId,
+        package: Uint8Array.from(input.package)
+      }
+    },
+    options
+  );
   if (response.case !== "dkgRound1") throw new Error("Unexpected LP DKG round1 response");
   return {
     package: response.value.package,
     round2ForLp: response.value.round2_for_lp
   };
 }
-async function dkgRound2(session, input, auth) {
-  const response = await request(session, auth, "dkg_round2", {
-    case: "dkgRound2",
-    value: {
-      session_id: input.sessionId,
-      package: Uint8Array.from(input.package),
-      delegated_share: Uint8Array.from(input.delegatedShare)
-    }
-  });
+async function dkgRound2(session, input, auth, options = {}) {
+  const response = await request(
+    session,
+    auth,
+    "dkg_round2",
+    {
+      case: "dkgRound2",
+      value: {
+        session_id: input.sessionId,
+        package: Uint8Array.from(input.package),
+        delegated_share: Uint8Array.from(input.delegatedShare)
+      }
+    },
+    options
+  );
   if (response.case !== "dkgRound2") throw new Error("Unexpected LP DKG round2 response");
   return {
     address: response.value.address,
@@ -487,11 +661,12 @@ async function dkgRound2(session, input, auth) {
     index: response.value.index
   };
 }
-async function openPosition(session, input, auth, reconnectSession) {
+async function openPosition(session, input, auth, reconnectSession, signal) {
   const payload = {
     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),
@@ -505,12 +680,14 @@ async function openPosition(session, input, auth, reconnectSession) {
   };
   const commandDeadlineMs = Date.now() + LP_POSITION_OPEN_COMMAND_TTL_MS;
   const commandOptions = {
+    signal,
     commandNonce: randomBytes(32),
     commandExpiresAtMs: commandDeadlineMs,
     deadlineMs: commandDeadlineMs,
     timeoutMs: LP_POSITION_OPEN_REQUEST_TIMEOUT_MS
   };
   let response;
+  let responseSession = session;
   try {
     response = await requestForPosition(
       session,
@@ -522,19 +699,31 @@ 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, signal);
+  }
+  const position = await hydratePositionResponse(
+    responseSession,
+    auth.lpPositionId,
+    auth,
+    response,
+    {
+      deadlineMs: commandDeadlineMs,
+      signal
+    }
+  );
+  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 hydratePositionResponse(session, auth.lpPositionId, auth, response);
+  return position;
 }
-async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
+async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs, signal) {
+  signal?.throwIfAborted();
   const remainingMs = deadlineMs - Date.now();
   if (remainingMs <= 0) {
     throw new CommandError(
@@ -543,8 +732,12 @@ async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
     );
   }
   let timer;
+  let removeAbort;
   try {
     return await new Promise((resolve, reject) => {
+      const onAbort = () => reject(signal?.reason);
+      signal?.addEventListener("abort", onAbort, { once: true });
+      removeAbort = () => signal?.removeEventListener("abort", onAbort);
       timer = setTimeout(() => {
         reject(
           new CommandError(
@@ -553,10 +746,14 @@ async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
           )
         );
       }, remainingMs);
-      Promise.resolve().then(reconnectSession).then(resolve, reject);
+      Promise.resolve().then(() => {
+        signal?.throwIfAborted();
+        return reconnectSession();
+      }).then(resolve, reject);
     });
   } finally {
     if (timer !== void 0) clearTimeout(timer);
+    removeAbort?.();
   }
 }
 function isAmbiguousLpPositionOpenFailure(error) {
@@ -650,6 +847,7 @@ async function hydratePositionResponse(session, lpPositionId, auth, initialRespo
         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,
@@ -677,7 +875,7 @@ function assertShardPage(first, page, lpPositionId, auth, startIndex) {
   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 || 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)
+  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;
@@ -703,48 +901,76 @@ function lpPositionPageRequestOptions(options) {
     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",
-    value: {
-      start_index: input.startIndex,
-      addresses: input.addresses,
-      finalized_at_ms: input.finalizedAtMs
-    }
-  });
-  return hydratePositionResponse(session, auth.lpPositionId, auth, response);
+async function finalizeDkgBatch(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "dkg_finalize",
+    {
+      case: "dkgFinalize",
+      value: {
+        start_index: input.startIndex,
+        addresses: input.addresses,
+        finalized_at_ms: input.finalizedAtMs
+      }
+    },
+    options
+  );
+  return hydratePositionResponse(session, auth.lpPositionId, auth, response, options);
 }
-async function refillPosition(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "refill", {
-    case: "refill",
-    value: {
-      shard_count: input.shardCount,
-      shard_amount_lamports: input.shardAmountLamports,
-      addresses: input.addresses,
-      authorized_at_ms: input.authorizedAtMs
-    }
-  });
-  return hydratePositionResponse(session, auth.lpPositionId, auth, response);
+async function refillPosition(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "refill",
+    {
+      case: "refill",
+      value: {
+        shard_count: input.shardCount,
+        shard_amount_lamports: input.shardAmountLamports,
+        addresses: input.addresses,
+        authorized_at_ms: input.authorizedAtMs
+      }
+    },
+    options
+  );
+  return hydratePositionResponse(session, auth.lpPositionId, auth, response, options);
 }
-async function reconcileFunding(session, lpPositionId, auth) {
-  const response = await requestForPosition(session, lpPositionId, auth, "reconcile_funding", {
-    case: "reconcileFunding",
-    value: {}
-  });
-  return hydratePositionResponse(session, auth.lpPositionId, auth, response);
+async function reconcileFunding(session, lpPositionId, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    lpPositionId,
+    auth,
+    "reconcile_funding",
+    {
+      case: "reconcileFunding",
+      value: {}
+    },
+    options
+  );
+  return hydratePositionResponse(session, auth.lpPositionId, auth, response, options);
 }
-async function planFunding(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "funding_plan", {
-    case: "fundingPlan",
-    value: {
-      shard_count: input.shardCount,
-      planned_at_ms: input.nowMs
-    }
-  });
+async function planFunding(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "funding_plan",
+    {
+      case: "fundingPlan",
+      value: {
+        shard_count: input.shardCount,
+        planned_at_ms: input.nowMs
+      }
+    },
+    options
+  );
   if (response.case !== "shards") throw new Error("Unexpected LP funding plan response");
   return response.value.map(mapShard);
 }
-async function confirmFunding(session, input, auth) {
+async function confirmFunding(session, input, auth, options = {}) {
   const response = await requestForPosition(
     session,
     input.lpPositionId,
@@ -757,38 +983,60 @@ async function confirmFunding(session, input, auth) {
         amount_lamports: input.amountLamports,
         funding_tx_signature: input.fundingTxSignature
       }
-    }
+    },
+    options
   );
   if (response.case !== "shard") throw new Error("Unexpected LP funding confirmation response");
   return mapShard(response.value);
 }
-async function prepareTopUp(session, lpPositionId, auth) {
-  const response = await requestForPosition(session, lpPositionId, auth, "prepare_top_up", {
-    case: "prepareTopUp",
-    value: {}
-  });
+async function prepareTopUp(session, lpPositionId, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    lpPositionId,
+    auth,
+    "prepare_top_up",
+    {
+      case: "prepareTopUp",
+      value: {}
+    },
+    options
+  );
   if (response.case !== "topUpRequest") throw new Error("Unexpected LP top-up response");
   return mapTopUpRequest(response.value);
 }
-async function getTopUpStatus(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "top_up_status", {
-    case: "topUpStatus",
-    value: { top_up_id: input.topUpId }
-  });
+async function getTopUpStatus(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "top_up_status",
+    {
+      case: "topUpStatus",
+      value: { top_up_id: input.topUpId }
+    },
+    options
+  );
   if (response.case !== "topUpRequest") throw new Error("Unexpected LP top-up response");
   return mapTopUpRequest(response.value);
 }
-async function makeAvailable(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "make_available", {
-    case: "makeAvailable",
-    value: {
-      shard_id: input.shardId
-    }
-  });
+async function makeAvailable(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "make_available",
+    {
+      case: "makeAvailable",
+      value: {
+        shard_id: input.shardId
+      }
+    },
+    options
+  );
   if (response.case !== "shard") throw new Error("Unexpected LP availability response");
   return mapShard(response.value);
 }
-async function executeWithdrawal(session, input, auth) {
+async function executeWithdrawal(session, input, auth, options = {}) {
   validateLpWithdrawalPlan({
     destinationAddresses: input.destinationAddresses,
     depositPrincipalLamports: input.withdrawalMode === "max_available" ? 1 : input.depositPrincipalLamports,
@@ -798,20 +1046,35 @@ async function executeWithdrawal(session, input, auth) {
     // 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.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
-    }
-  });
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "withdraw_request",
+    {
+      case: "withdrawRequest",
+      value: {
+        destination_addresses: input.destinationAddresses,
+        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,
+        fee_policy_hash: input.feePolicyHash,
+        fee_basis_revision: input.feeBasisRevision
+      }
+    },
+    options
+  );
   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",
@@ -825,6 +1088,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,
@@ -832,13 +1097,15 @@ async function executeWithdrawal(session, input, auth) {
     acceptedEarnedFeeLamports: execution.accepted_earned_fee_lamports
   };
 }
-function request(session, auth, action, payload) {
-  return requestForPosition(session, auth.lpPositionId, auth, action, payload);
+function request(session, auth, action, payload, options = {}) {
+  return requestForPosition(session, auth.lpPositionId, auth, action, payload, options);
 }
 async function requestForPosition(session, lpPositionId, auth, action, payload, options = {}) {
+  options.signal?.throwIfAborted();
   const timeoutMs = lpPositionPageRequestOptions(options).timeoutMs ?? LP_COMMAND_REQUEST_TIMEOUT_MS;
   assertAuthMatchesPosition(lpPositionId, auth);
   const protocol = await loadProtocol();
+  options.signal?.throwIfAborted();
   const state = getSessionState(session);
   const attestation = state.channel?.attestation;
   if (!attestation) {
@@ -855,7 +1122,9 @@ async function requestForPosition(session, lpPositionId, auth, action, payload,
     ),
     payload
   };
+  options.signal?.throwIfAborted();
   const signature = await signLpCommandBytes(auth, protocol.encodeLpCommandForSigning(command));
+  options.signal?.throwIfAborted();
   const { type, payload: envelopePayload } = protocol.lpSignedCommandEnvelope(command, signature);
   const requestOptions = lpPositionPageRequestOptions(options);
   const envelope = await requestEnvelope(session, type, envelopePayload, {
@@ -872,7 +1141,9 @@ function assertAuthMatchesPosition(lpPositionId, auth) {
   );
 }
 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,
@@ -887,6 +1158,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) {
@@ -916,11 +1189,22 @@ function mapLpActorSync(actorSync) {
     );
   }
   const redeemableProjectionAvailable = redeemableBucketCount === redeemableBucketValues.length;
-  return {
-    ...actorSync.economic_return === void 0 ? {} : { economicReturn: mapLpEconomicReturn(actorSync.economic_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,
@@ -946,14 +1230,14 @@ 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) {
+function mapLpEconomicReturn(summary, protocolCommissionLamports) {
   const unsigned = [
     summary.provider_reward_lamports,
     summary.source_expense_compensation_lamports,
@@ -965,7 +1249,7 @@ function mapLpEconomicReturn(summary) {
   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)) {
+  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 {
@@ -996,6 +1280,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 },
@@ -1077,13 +1363,14 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-DHL3AP7V.js');
+  protocolPromise ??= import('./coordinator-EQEL23A3.js');
   return protocolPromise;
 }
 
 // src/lp/dkgBatch.ts
-var MAX_LP_DKG_CONCURRENCY = 8;
+var MAX_LP_DKG_CONCURRENCY = 16;
 var DEFAULT_LP_DKG_CONCURRENCY = MAX_LP_DKG_CONCURRENCY;
+var LP_DKG_WORKER_FAILURE_MESSAGE = "LP DKG worker failed";
 var LP_DKG_WORKER_REQUEST_TIMEOUT_MS = 3e4;
 var LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE = "LP DKG worker request timed out";
 var LP_DKG_ABORT_CLEANUP_TIMEOUT_MS = 1e4;
@@ -1093,21 +1380,28 @@ var LP_DKG_COMPLETED_SHARD_POLL_TIMEOUT_MS = 5 * 6e4 + 15e3;
 var LP_DKG_ACTIVE_SESSION_RETRY_INTERVAL_MS = 2e3;
 var LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS = LP_DKG_COMPLETED_SHARD_POLL_TIMEOUT_MS;
 async function createLpDkgBatch(input) {
+  input.signal?.throwIfAborted();
   if (input.useDeterministicTestAddresses === true) {
     const addresses2 = Array.from(
       { length: input.count },
       (_, offset) => testAddress(input.lpPositionId, input.startIndex + offset)
     );
     for (const [offset, address] of addresses2.entries()) {
+      input.signal?.throwIfAborted();
       input.onProgress?.({
         completed: offset + 1,
         total: input.count,
         address
       });
     }
+    input.signal?.throwIfAborted();
     return addresses2;
   }
-  const workerCount = resolveConcurrency(input.count, input.concurrency);
+  const workerCount = resolveLpDkgConcurrency(input.count, input.concurrency);
+  const cancellation = new AbortController();
+  const cancel = () => cancellation.abort(input.signal?.reason);
+  input.signal?.addEventListener("abort", cancel, { once: true });
+  if (input.signal?.aborted) cancel();
   const workers = [];
   let workersTerminated = false;
   const terminateWorkers = () => {
@@ -1120,16 +1414,19 @@ async function createLpDkgBatch(input) {
   let nextOffset = 0;
   try {
     for (let index = 0; index < workerCount; index += 1) {
+      cancellation.signal.throwIfAborted();
       workers.push(createWorker(input.workerFactory));
     }
     await Promise.all(
       workers.map(async (worker) => {
         for (; ; ) {
+          cancellation.signal.throwIfAborted();
           const offset = nextOffset;
           nextOffset += 1;
           if (offset >= input.count) return;
           const index = input.startIndex + offset;
-          const address = await createLpDkgShard(input, worker, index);
+          const address = await createLpDkgShard(input, worker, index, cancellation.signal);
+          cancellation.signal.throwIfAborted();
           addresses[offset] = address;
           completed += 1;
           input.onProgress?.({
@@ -1142,12 +1439,14 @@ async function createLpDkgBatch(input) {
     );
     return addresses;
   } catch (error) {
+    cancellation.abort(error);
     terminateWorkers();
     if (!isLpDkgSessionCoordinationError(error)) {
       await abortDkgSessionsAfterFailure(input);
     }
     throw error;
   } finally {
+    input.signal?.removeEventListener("abort", cancel);
     terminateWorkers();
   }
 }
@@ -1171,61 +1470,82 @@ async function abortDkgSessionsAfterFailure(input) {
     if (timeoutId !== void 0) globalThis.clearTimeout(timeoutId);
   }
 }
-async function createLpDkgShard(input, worker, index) {
+async function createLpDkgShard(input, worker, index, signal) {
   const deadline = Date.now() + LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS;
   let sawActiveSession = false;
   for (; ; ) {
     if (sawActiveSession) {
-      const completedAddress = await getCompletedShardAddress(input, index);
+      const completedAddress = await getCompletedShardAddress(input, index, signal);
       if (completedAddress !== null) return completedAddress;
     }
     try {
-      return await runLpDkgShard(input, worker, index);
+      return await runLpDkgShard(input, worker, index, signal);
     } catch (error) {
       if (isLpDkgCompletedOrVisibleError(error)) {
-        return waitForCompletedShardAddress(input, index);
+        return waitForCompletedShardAddress(input, index, signal);
       }
       if (!isLpDkgActiveSessionError(error)) throw error;
       sawActiveSession = true;
-      const completedAddress = await getCompletedShardAddress(input, index);
+      const completedAddress = await getCompletedShardAddress(input, index, signal);
       if (completedAddress !== null) return completedAddress;
       if (Date.now() >= deadline) throw error;
-      await sleep(LP_DKG_ACTIVE_SESSION_RETRY_INTERVAL_MS);
+      await abortable(sleep(LP_DKG_ACTIVE_SESSION_RETRY_INTERVAL_MS), signal);
     }
   }
 }
-async function runLpDkgShard(input, worker, index) {
+async function runLpDkgShard(input, worker, index, signal) {
   const roundId = `lp_dkg_${Date.now()}_${index}_${Math.random().toString(16).slice(2)}`;
-  const initResponse = await input.client.initDkg(
-    { lpPositionId: input.lpPositionId, index },
-    input.auth
+  signal.throwIfAborted();
+  const initResponse = await abortable(
+    input.client.initDkg({ lpPositionId: input.lpPositionId, index }, input.auth, { signal }),
+    signal
   );
-  const round1 = await workerRequest(worker, {
-    id: roundId,
-    type: "round1"
-  });
-  if (round1.type !== "round1") throw new Error("LP DKG worker returned wrong round1 type");
-  const round1Response = await input.client.dkgRound1(
+  const round1 = await workerRequest(
+    worker,
     {
-      sessionId: initResponse.sessionId,
-      package: round1.package
+      id: roundId,
+      type: "round1"
     },
-    input.auth
+    signal
   );
-  const round2 = await workerRequest(worker, {
-    id: roundId,
-    type: "round2",
-    teeRound1: Array.from(round1Response.package),
-    teeRound2ForLp: Array.from(round1Response.round2ForLp)
-  });
-  if (round2.type !== "round2") throw new Error("LP DKG worker returned wrong round2 type");
-  const round2Response = await input.client.dkgRound2(
+  if (round1.type !== "round1")
+    throw lpDkgWorkerFailure(new Error("LP DKG worker returned wrong round1 type"));
+  signal.throwIfAborted();
+  const round1Response = await abortable(
+    input.client.dkgRound1(
+      {
+        sessionId: initResponse.sessionId,
+        package: round1.package
+      },
+      input.auth,
+      { signal }
+    ),
+    signal
+  );
+  const round2 = await workerRequest(
+    worker,
     {
-      sessionId: initResponse.sessionId,
-      package: round2.package,
-      delegatedShare: round2.delegatedShare
+      id: roundId,
+      type: "round2",
+      teeRound1: Array.from(round1Response.package),
+      teeRound2ForLp: Array.from(round1Response.round2ForLp)
     },
-    input.auth
+    signal
+  );
+  if (round2.type !== "round2")
+    throw lpDkgWorkerFailure(new Error("LP DKG worker returned wrong round2 type"));
+  signal.throwIfAborted();
+  const round2Response = await abortable(
+    input.client.dkgRound2(
+      {
+        sessionId: initResponse.sessionId,
+        package: round2.package,
+        delegatedShare: round2.delegatedShare
+      },
+      input.auth,
+      { signal }
+    ),
+    signal
   );
   if (!bytesEqual(Uint8Array.from(round2.jointPubkey), round2Response.jointPubkey)) {
     throw new Error(`LP DKG joint pubkey mismatch at index ${index}`);
@@ -1235,22 +1555,27 @@ async function runLpDkgShard(input, worker, index) {
   }
   return round2Response.address;
 }
-async function waitForCompletedShardAddress(input, index) {
+async function waitForCompletedShardAddress(input, index, signal) {
   const deadline = Date.now() + LP_DKG_COMPLETED_SHARD_POLL_TIMEOUT_MS;
   for (; ; ) {
-    const address = await getCompletedShardAddress(input, index);
+    const address = await getCompletedShardAddress(input, index, signal);
     if (address !== null) return address;
     if (Date.now() >= deadline) {
       throw new Error(`LP DKG completed shard ${index} did not become visible`);
     }
-    await sleep(LP_DKG_COMPLETED_SHARD_POLL_INTERVAL_MS);
+    await abortable(sleep(LP_DKG_COMPLETED_SHARD_POLL_INTERVAL_MS), signal);
   }
 }
-async function getCompletedShardAddress(input, index) {
-  const position = await input.client.getPosition(input.lpPositionId, input.auth);
+async function getCompletedShardAddress(input, index, signal) {
+  signal.throwIfAborted();
+  const position = await abortable(
+    input.client.getPosition(input.lpPositionId, input.auth, { signal }),
+    signal
+  );
   return position.shards.find((candidate) => candidate.index === index)?.address ?? null;
 }
-function workerRequest(worker, request2) {
+function workerRequest(worker, request2, signal) {
+  signal.throwIfAborted();
   return new Promise((resolve, reject) => {
     let timeoutId;
     const onMessage = (event) => {
@@ -1258,37 +1583,54 @@ function workerRequest(worker, request2) {
       if (message.id !== request2.id) return;
       cleanup();
       if (message.type === "error") {
-        reject(new Error(message.error));
+        reject(lpDkgWorkerFailure(message.error));
       } else {
         resolve(message);
       }
     };
     const onError = (event) => {
       cleanup();
-      reject(new Error(event.message));
+      reject(lpDkgWorkerFailure(new Error(event.message)));
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason);
     };
     const cleanup = () => {
+      signal.removeEventListener("abort", onAbort);
       if (timeoutId !== void 0) globalThis.clearTimeout(timeoutId);
       worker.removeEventListener("message", onMessage);
       worker.removeEventListener("error", onError);
     };
+    signal.addEventListener("abort", onAbort, { once: true });
     worker.addEventListener("message", onMessage);
     worker.addEventListener("error", onError);
     timeoutId = globalThis.setTimeout(() => {
       cleanup();
-      reject(new Error(LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE));
+      reject(lpDkgWorkerFailure(new Error(LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE)));
     }, LP_DKG_WORKER_REQUEST_TIMEOUT_MS);
     try {
       worker.postMessage(request2);
     } catch (error) {
       cleanup();
-      reject(error instanceof Error ? error : new Error(String(error)));
+      reject(lpDkgWorkerFailure(error));
     }
   });
 }
 function createWorker(workerFactory) {
-  if (workerFactory !== void 0) return workerFactory();
-  return new Worker(new URL("./dkgWorker.js", import.meta.url), { type: "module" });
+  try {
+    if (workerFactory !== void 0) return workerFactory();
+    return new Worker(new URL("./dkgWorker.js", import.meta.url), { type: "module" });
+  } catch (error) {
+    throw lpDkgWorkerFailure(error);
+  }
+}
+function lpDkgWorkerFailure(cause) {
+  return new LpLifecycleError(
+    "LP_DKG_WORKER_FAILED",
+    cause instanceof Error ? cause.message : typeof cause === "string" ? cause : LP_DKG_WORKER_FAILURE_MESSAGE,
+    { cause }
+  );
 }
 function bytesEqual(a, b) {
   if (a.byteLength !== b.byteLength) return false;
@@ -1312,12 +1654,20 @@ function isLpDkgIndexDriftError(error) {
 function isLpDkgSessionCoordinationError(error) {
   return isLpDkgActiveSessionError(error) || isLpDkgIndexDriftError(error);
 }
-function resolveConcurrency(count, requested) {
+function resolveLpDkgConcurrency(count, requested) {
   if (count <= 0) return 0;
   const concurrency = requested ?? DEFAULT_LP_DKG_CONCURRENCY;
   if (!Number.isFinite(concurrency)) return Math.min(count, DEFAULT_LP_DKG_CONCURRENCY);
   return Math.max(1, Math.min(count, MAX_LP_DKG_CONCURRENCY, Math.floor(concurrency)));
 }
+function abortable(promise, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    void promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
 function sleep(delayMs) {
   return new Promise((resolve) => {
     globalThis.setTimeout(resolve, delayMs);
@@ -1375,6 +1725,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,
@@ -1384,6 +1735,46 @@ function previewLpWithdrawalPlan(position, args = {}) {
     })
   };
 }
+var dkgAdmissions = /* @__PURE__ */ new WeakMap();
+var LP_DKG_BUSY_MESSAGE = "LP DKG session capacity is busy; wait for the active batch to finish";
+var LP_CLIENT_INVALIDATED_MESSAGE = "LP client invalidated by a reconnect capacity conflict; create a new LP lifecycle client and recover positions using their saved Position Codes";
+function getDkgAdmission(session) {
+  let admission = dkgAdmissions.get(session);
+  if (admission === void 0) {
+    admission = { reservations: /* @__PURE__ */ new Set() };
+    dkgAdmissions.set(session, admission);
+  }
+  while (admission.parent !== void 0) admission = admission.parent;
+  dkgAdmissions.set(session, admission);
+  return admission;
+}
+function assertDkgCapacity(reservations) {
+  let workerCount = 0;
+  const positions = /* @__PURE__ */ new Set();
+  for (const reservation of reservations) {
+    workerCount += reservation.workerCount;
+    if (positions.has(reservation.positionId) || workerCount > MAX_LP_DKG_CONCURRENCY) {
+      throw new LpLifecycleError("LP_DKG_BUSY", LP_DKG_BUSY_MESSAGE);
+    }
+    positions.add(reservation.positionId);
+  }
+}
+function reserveDkg(session, positionId, workerCount) {
+  const admission = getDkgAdmission(session);
+  const reservation = { positionId, workerCount };
+  assertDkgCapacity([...admission.reservations, reservation]);
+  admission.reservations.add(reservation);
+  return () => getDkgAdmission(session).reservations.delete(reservation);
+}
+function transferDkgAdmission(previousSession, nextSession) {
+  const previous = getDkgAdmission(previousSession);
+  const next = getDkgAdmission(nextSession);
+  if (previous === next) return;
+  assertDkgCapacity([...previous.reservations, ...next.reservations]);
+  for (const reservation of previous.reservations) next.reservations.add(reservation);
+  previous.reservations.clear();
+  previous.parent = next;
+}
 var lifecycleClients = /* @__PURE__ */ new WeakMap();
 function createLpLifecycleClient(session, runtime = {}) {
   const state = {
@@ -1392,26 +1783,47 @@ function createLpLifecycleClient(session, runtime = {}) {
     redemptions: /* @__PURE__ */ new Map(),
     topUps: /* @__PURE__ */ new Map()
   };
+  const cancellation = new AbortController();
+  const assertUsable = () => cancellation.signal.throwIfAborted();
   let currentSession = session;
   const reconnectSession = runtime.reconnectSession === void 0 ? void 0 : async () => {
     const nextSession = await runtime.reconnectSession();
+    assertUsable();
+    try {
+      transferDkgAdmission(currentSession, nextSession);
+    } catch (error) {
+      if (error instanceof LpLifecycleError && error.code === "LP_DKG_BUSY") {
+        const invalidated = new LpLifecycleError(
+          "LP_CLIENT_INVALIDATED",
+          LP_CLIENT_INVALIDATED_MESSAGE,
+          { cause: error }
+        );
+        cancellation.abort(invalidated);
+        throw invalidated;
+      }
+      throw error;
+    }
     currentSession = nextSession;
     return nextSession;
   };
-  const client = runtime.coordinatorClient ?? createLpCoordinatorClient(session, { reconnectSession });
+  const client = runtime.coordinatorClient ?? createLpCoordinatorClient(session, { reconnectSession, signal: cancellation.signal });
   const nowMs = runtime.nowMs ?? Date.now;
   const sleep2 = runtime.sleep ?? defaultSleep;
   const requireAuth = (positionId) => {
+    assertUsable();
     const auth = state.authByPosition.get(positionId);
     if (auth === void 0) throw new LpPositionAuthMissingError();
     return auth;
   };
   const rememberPosition = (position) => {
+    assertUsable();
+    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
       )
@@ -1421,6 +1833,7 @@ function createLpLifecycleClient(session, runtime = {}) {
     return merged;
   };
   const rememberAuth = (auth) => {
+    assertUsable();
     state.authByPosition.set(auth.lpPositionId, auth);
   };
   const refreshPosition2 = async (positionId) => {
@@ -1441,7 +1854,8 @@ function createLpLifecycleClient(session, runtime = {}) {
       }
     }
   };
-  const completeDkgBatch2 = async (positionId, options = {}) => {
+  const completeDkgBatch2 = async (positionId, options = {}, hasReservation = false) => {
+    assertUsable();
     assertAttested(currentSession);
     const auth = requireAuth(positionId);
     let activeSessionRetryStartedAtMs = null;
@@ -1451,10 +1865,16 @@ function createLpLifecycleClient(session, runtime = {}) {
       const startIndex = current.shards.length;
       const remaining = Math.min(current.targetShardCount - startIndex, LP_MAX_INITIAL_SHARDS);
       if (remaining <= 0) return current;
-      emitDkgProgress(options, current, startIndex, remaining, 0);
+      const release = hasReservation ? () => void 0 : reserveDkg(
+        currentSession,
+        positionId,
+        runtime.useDeterministicTestAddresses === true ? 0 : resolveLpDkgConcurrency(remaining, options.concurrency ?? runtime.dkgConcurrency)
+      );
       let expectedAddresses = null;
       try {
+        emitDkgProgress(options, current, startIndex, remaining, 0);
         const addresses = await createLpDkgBatch({
+          signal: cancellation.signal,
           lpPositionId: positionId,
           startIndex,
           count: remaining,
@@ -1467,6 +1887,7 @@ function createLpLifecycleClient(session, runtime = {}) {
             emitDkgProgress(options, current, startIndex, remaining, progress.completed);
           }
         });
+        assertUsable();
         expectedAddresses = addresses;
         const position = await client.finalizeDkgBatch(
           {
@@ -1483,6 +1904,7 @@ function createLpLifecycleClient(session, runtime = {}) {
         if (position.shards.length < position.targetShardCount) continue;
         return position;
       } catch (error) {
+        assertUsable();
         const reconciled = await tryRefreshCompletedDkgWindow({
           client,
           positionId,
@@ -1504,11 +1926,14 @@ function createLpLifecycleClient(session, runtime = {}) {
           throw error;
         }
         await sleep2(LP_DKG_ACTIVE_SESSION_RETRY_DELAY_MS);
+      } finally {
+        release();
       }
     }
   };
   return {
     async createPosition(args) {
+      assertUsable();
       assertNoUnsupportedFeePolicy(args.feePolicy);
       const shardCount = args.shardCount ?? LP_DEFAULT_TARGET_SHARDS;
       assertShardCount(shardCount, LP_MAX_INITIAL_SHARDS, "shardCount");
@@ -1532,6 +1957,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),
@@ -1549,6 +1975,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return { positionId, lpPositionCode: auth.code, position };
     },
     async recoverPosition(args) {
+      assertUsable();
       const auth = await deriveLpPositionCodeAuth(args.code);
       rememberAuth(auth);
       const position = rememberPosition(
@@ -1561,11 +1988,13 @@ function createLpLifecycleClient(session, runtime = {}) {
       return position;
     },
     confirmPositionCodeSaved(_positionId) {
+      assertUsable();
       return;
     },
     completeDkgBatch: completeDkgBatch2,
     refreshPosition: refreshPosition2,
     async refill(positionId, args = {}) {
+      assertUsable();
       const requestedShardCount = args.shardCount ?? LP_DEFAULT_REFILL_BATCH_SIZE;
       assertShardCount(requestedShardCount, LP_MAX_REFILL_BATCH_SIZE, "shardCount");
       assertAttested(currentSession);
@@ -1573,29 +2002,44 @@ function createLpLifecycleClient(session, runtime = {}) {
       const current = await refreshPosition2(positionId);
       args.onPosition?.(current);
       const refillShardCount = resolveLpRefillShardCount(current, requestedShardCount);
-      const authorizedPosition = rememberPosition(
-        await client.refillPosition(
+      const release = reserveDkg(
+        currentSession,
+        positionId,
+        runtime.useDeterministicTestAddresses === true ? 0 : resolveLpDkgConcurrency(refillShardCount, runtime.dkgConcurrency)
+      );
+      try {
+        const authorizedPosition = rememberPosition(
+          await client.refillPosition(
+            {
+              lpPositionId: positionId,
+              shardCount: refillShardCount,
+              shardAmountLamports: DEFAULT_SHARD_FUNDING_LAMPORTS,
+              addresses: [],
+              authorizedAtMs: nowMs()
+            },
+            auth
+          )
+        );
+        args.onPosition?.(authorizedPosition);
+        if (authorizedPosition.shards.length >= authorizedPosition.targetShardCount) {
+          return authorizedPosition;
+        }
+        return await completeDkgBatch2(
+          positionId,
           {
-            lpPositionId: positionId,
-            shardCount: refillShardCount,
-            shardAmountLamports: DEFAULT_SHARD_FUNDING_LAMPORTS,
-            addresses: [],
-            authorizedAtMs: nowMs()
+            onProgress: args.onProgress,
+            onPosition: args.onPosition,
+            workerFactory: args.workerFactory,
+            concurrency: resolveLpDkgConcurrency(refillShardCount, runtime.dkgConcurrency)
           },
-          auth
-        )
-      );
-      args.onPosition?.(authorizedPosition);
-      if (authorizedPosition.shards.length >= authorizedPosition.targetShardCount) {
-        return authorizedPosition;
+          true
+        );
+      } finally {
+        release();
       }
-      return completeDkgBatch2(positionId, {
-        onProgress: args.onProgress,
-        onPosition: args.onPosition,
-        workerFactory: args.workerFactory
-      });
     },
     async prepareInitialFunding(positionId) {
+      assertUsable();
       assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const currentPosition = rememberPosition(await client.getPosition(positionId, auth));
@@ -1625,6 +2069,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return fundingPlanFromShard(position, plannedShard);
     },
     async prepareTopUp(positionId) {
+      assertUsable();
       assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const request2 = await client.prepareTopUp(positionId, auth);
@@ -1632,6 +2077,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return request2;
     },
     async waitForTopUp(topUpId, options = {}) {
+      assertUsable();
       const cached = state.topUps.get(topUpId);
       if (cached !== void 0 && options.positionId !== void 0 && cached.positionId !== options.positionId) {
         throw new PolicyValidationError(
@@ -1673,11 +2119,13 @@ function createLpLifecycleClient(session, runtime = {}) {
       }
     },
     async reconcileFunding(positionId) {
+      assertUsable();
       assertAttested(currentSession);
       const auth = requireAuth(positionId);
       return rememberPosition(await client.reconcileFunding(positionId, auth));
     },
     async withdrawPosition(positionId, args) {
+      assertUsable();
       validateExplicitWithdrawalInput(args);
       validateWithdrawalDestinations(args);
       assertAttested(currentSession);
@@ -1692,6 +2140,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,
@@ -1736,6 +2186,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
@@ -1766,6 +2218,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return { execution, position, redemption };
     },
     async waitForWithdrawalConfirmation(positionId, execution, options = {}) {
+      assertUsable();
       const auth = requireAuth(positionId);
       let record = resolveWithdrawalRecord({
         state,
@@ -1822,6 +2275,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       }
     },
     async withdrawFees(_positionId, args) {
+      assertUsable();
       publicKey(args.destination);
       assertAttested(currentSession);
       throw new RoutingError(
@@ -1830,6 +2284,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       );
     },
     async listPositions() {
+      assertUsable();
       return [...state.positions.values()].map(clonePosition);
     }
   };
@@ -1864,6 +2319,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;
 }
@@ -1962,7 +2418,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;
   }
@@ -2067,6 +2525,8 @@ function buildLpRedemptionRecord({
   nowMs
 }) {
   return {
+    feePolicyHash: execution.feePolicyHash,
+    feeBasisRevision: execution.feeBasisRevision,
     redemptionId: execution.withdrawalId,
     lpPositionId: position.id,
     requestedAt: nowMs,
@@ -2115,7 +2575,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",
@@ -2165,6 +2625,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,
@@ -2194,6 +2656,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,
@@ -2306,6 +2769,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