@invisible-labs/sdk 0.9.0-devnet → 0.10.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 { 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";
@@ -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;
@@ -330,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,
@@ -401,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;
@@ -492,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),
@@ -511,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,
@@ -522,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 hydratePositionResponse(session, auth.lpPositionId, auth, response);
+  return position;
 }
 async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
   const remainingMs = deadlineMs - Date.now();
@@ -650,6 +771,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 +799,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;
@@ -805,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",
@@ -825,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,
@@ -872,7 +1004,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 +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) {
@@ -916,11 +1052,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 +1093,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 +1112,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 +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 },
@@ -1077,7 +1226,7 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-DHL3AP7V.js');
+  protocolPromise ??= import('./coordinator-T2B7253V.js');
   return protocolPromise;
 }
 
@@ -1375,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,
@@ -1407,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
       )
@@ -1532,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),
@@ -1692,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,
@@ -1736,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
@@ -1864,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;
 }
@@ -1962,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;
   }
@@ -2067,6 +2227,8 @@ function buildLpRedemptionRecord({
   nowMs
 }) {
   return {
+    feePolicyHash: execution.feePolicyHash,
+    feeBasisRevision: execution.feeBasisRevision,
     redemptionId: execution.withdrawalId,
     lpPositionId: position.id,
     requestedAt: nowMs,
@@ -2115,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",
@@ -2165,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,
@@ -2194,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,
@@ -2306,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