@invisible-labs/sdk 0.6.0-devnet.1

package/dist/lp.js

@@ -0,0 +1,1711 @@
+import { isValidLpPositionId, LP_DEFAULT_REFILL_BATCH_SIZE, LP_DEFAULT_TARGET_SHARDS, LP_MAX_TARGET_SHARDS, LP_MAX_REFILL_BATCH_SIZE } from './chunk-TQNNTV5F.js';
+import { publicKey, assertAttested, lamports } from './chunk-SZAYO2L5.js';
+import { requestEnvelope } from './chunk-XUWBGET5.js';
+import { getSessionState } from './chunk-JRMKCE3S.js';
+import { CommandError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-OHIM2YWU.js';
+import './chunk-VR6T6OJS.js';
+
+// src/lp/positionCode.ts
+var LEGACY_CODE_PREFIX = "ilp1";
+var CODE_PREFIX = "ilp2";
+var SECRET_HEX_LENGTH = 64;
+var encoder = new TextEncoder();
+async function generateLpPositionCode(lpPositionId) {
+  validateLpPositionId(lpPositionId);
+  const secret = new Uint8Array(32);
+  getCrypto().getRandomValues(secret);
+  const keyPair = await getCrypto().subtle.generateKey({ name: "Ed25519" }, true, [
+    "sign",
+    "verify"
+  ]);
+  const [privatePkcs8, publicRaw] = await Promise.all([
+    getCrypto().subtle.exportKey("pkcs8", keyPair.privateKey),
+    getCrypto().subtle.exportKey("raw", keyPair.publicKey)
+  ]);
+  const code = encodeCode(
+    lpPositionId,
+    bytesToHex(secret),
+    bytesToHex(new Uint8Array(privatePkcs8)),
+    bytesToHex(new Uint8Array(publicRaw))
+  );
+  secret.fill(0);
+  return deriveLpPositionCodeAuth(code);
+}
+async function deriveLpPositionCodeAuth(input) {
+  const code = normalizeLpPositionCode(input);
+  const parsed = parseCode(code);
+  const secret = hexToBytes(parsed.secretHex);
+  try {
+    const authPublicKey = parsed.authPublicKeyHex ? hexToBytes(parsed.authPublicKeyHex) : new Uint8Array();
+    const authPrivateKeyPkcs8 = parsed.authPrivateKeyPkcs8Hex ? hexToBytes(parsed.authPrivateKeyPkcs8Hex) : new Uint8Array();
+    if (authPublicKey.length > 0 || authPrivateKeyPkcs8.length > 0) {
+      await assertAuthKeyPair(authPrivateKeyPkcs8, authPublicKey);
+    }
+    const refillPublicKey = await deriveBytes(
+      "invisible-lp-refill-public-key-v0",
+      parsed.lpPositionId,
+      secret
+    );
+    const withdrawalCommitment = await deriveBytes(
+      "invisible-lp-redemption-commitment-v0",
+      parsed.lpPositionId,
+      secret
+    );
+    return {
+      code,
+      lpPositionId: parsed.lpPositionId,
+      authPublicKey,
+      authPrivateKeyPkcs8,
+      refillPublicKey,
+      withdrawalCommitment
+    };
+  } finally {
+    secret.fill(0);
+  }
+}
+function normalizeLpPositionCode(input) {
+  return input.trim();
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function signLpCommandBytes(auth, bytes) {
+  if (auth.authPrivateKeyPkcs8.length === 0 || auth.authPublicKey.length === 0) {
+    throw new Error("LP Position Code cannot sign owner commands; create a new ilp2 code");
+  }
+  const privateKey = await getCrypto().subtle.importKey(
+    "pkcs8",
+    bufferSource(auth.authPrivateKeyPkcs8),
+    { name: "Ed25519" },
+    false,
+    ["sign"]
+  );
+  return new Uint8Array(
+    await getCrypto().subtle.sign({ name: "Ed25519" }, privateKey, bufferSource(bytes))
+  );
+}
+function encodeCode(lpPositionId, secretHex, authPrivateKeyPkcs8Hex, authPublicKeyHex) {
+  return `${CODE_PREFIX}:${lpPositionId}:${secretHex}:${authPrivateKeyPkcs8Hex}:${authPublicKeyHex}`;
+}
+function parseCode(code) {
+  const parts = code.split(":");
+  if (parts.length === 3 && parts[0] === LEGACY_CODE_PREFIX) {
+    const [, lpPositionId2, secretHex2] = parts;
+    validateLpPositionId(lpPositionId2);
+    if (!new RegExp(`^[0-9a-fA-F]{${SECRET_HEX_LENGTH}}$`).test(secretHex2)) {
+      throw new Error("LP Position Code secret must be 32 bytes hex");
+    }
+    return { lpPositionId: lpPositionId2, secretHex: secretHex2.toLowerCase() };
+  }
+  if (parts.length !== 5 || parts[0] !== CODE_PREFIX) {
+    throw new Error("LP Position Code must use the ilp2 format");
+  }
+  const [, lpPositionId, secretHex, authPrivateKeyPkcs8Hex, authPublicKeyHex] = parts;
+  validateLpPositionId(lpPositionId);
+  if (!new RegExp(`^[0-9a-fA-F]{${SECRET_HEX_LENGTH}}$`).test(secretHex)) {
+    throw new Error("LP Position Code secret must be 32 bytes hex");
+  }
+  if (!/^[0-9a-fA-F]+$/.test(authPrivateKeyPkcs8Hex) || authPrivateKeyPkcs8Hex.length < 64) {
+    throw new Error("LP Position Code auth private key must be pkcs8 hex");
+  }
+  if (!new RegExp(`^[0-9a-fA-F]{${SECRET_HEX_LENGTH}}$`).test(authPublicKeyHex)) {
+    throw new Error("LP Position Code auth public key must be 32 bytes hex");
+  }
+  return {
+    lpPositionId,
+    secretHex: secretHex.toLowerCase(),
+    authPrivateKeyPkcs8Hex: authPrivateKeyPkcs8Hex.toLowerCase(),
+    authPublicKeyHex: authPublicKeyHex.toLowerCase()
+  };
+}
+function validateLpPositionId(lpPositionId) {
+  if (!isValidLpPositionId(lpPositionId)) {
+    throw new Error("LP Position Code has an invalid position id");
+  }
+}
+async function deriveBytes(domain, lpPositionId, secret) {
+  const domainBytes = encoder.encode(`${domain}:${lpPositionId}:`);
+  const material = new Uint8Array(domainBytes.length + secret.length);
+  material.set(domainBytes);
+  material.set(secret, domainBytes.length);
+  const digest = await getCrypto().subtle.digest("SHA-256", material);
+  material.fill(0);
+  return new Uint8Array(digest);
+}
+async function assertAuthKeyPair(privatePkcs8, publicRaw) {
+  if (publicRaw.length !== 32) {
+    throw new Error("LP Position Code auth public key must be 32 bytes");
+  }
+  const [privateKey, publicKey2] = await Promise.all([
+    getCrypto().subtle.importKey("pkcs8", bufferSource(privatePkcs8), { name: "Ed25519" }, false, [
+      "sign"
+    ]),
+    getCrypto().subtle.importKey("raw", bufferSource(publicRaw), { name: "Ed25519" }, false, [
+      "verify"
+    ])
+  ]);
+  const challenge = encoder.encode("invisible-lp-auth-self-test");
+  const signature = await getCrypto().subtle.sign({ name: "Ed25519" }, privateKey, challenge);
+  const ok = await getCrypto().subtle.verify({ name: "Ed25519" }, publicKey2, signature, challenge);
+  if (!ok) {
+    throw new Error("LP Position Code auth key pair is invalid");
+  }
+}
+function bufferSource(bytes) {
+  return new Uint8Array(bytes).buffer;
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let index = 0; index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+}
+function getCrypto() {
+  if (globalThis.crypto === void 0 || globalThis.crypto.subtle === void 0) {
+    throw new Error("Web Crypto is required for LP Position Code handling");
+  }
+  return globalThis.crypto;
+}
+
+// src/lp/withdrawalValidation.ts
+var SINGLE_DESTINATION_WITHDRAWAL_MESSAGE = "single-destination withdrawal is privacy-degrading; pass allowManyToOne: true to acknowledge";
+var DESTINATION_SOURCE_COUNT_MESSAGE = "LP withdrawal requires one destination per withdrawable source unless allowManyToOne is true";
+var SOURCE_COUNT_MESSAGE = "LP withdrawal source count must be a positive integer";
+function validateLpWithdrawalPlan(input) {
+  const {
+    depositPrincipalLamports,
+    earnedFeeLamports,
+    destinationAddresses,
+    allowManyToOne,
+    sourceCount
+  } = input;
+  lamports(depositPrincipalLamports);
+  lamports(earnedFeeLamports);
+  if (depositPrincipalLamports === 0 && earnedFeeLamports === 0) {
+    throw new PolicyValidationError(
+      "INVALID_AMOUNT",
+      "LP withdrawal requires a non-zero principal or earned-fee claim"
+    );
+  }
+  validateDestinationAddresses(destinationAddresses);
+  if (sourceCount !== void 0 && (!Number.isInteger(sourceCount) || sourceCount < 1)) {
+    throw new PolicyValidationError("INVALID_WITHDRAWAL_PLAN", SOURCE_COUNT_MESSAGE);
+  }
+  if (sourceCount !== void 0 && allowManyToOne !== true && destinationAddresses.length !== sourceCount) {
+    throw new PolicyValidationError("INVALID_WITHDRAWAL_PLAN", DESTINATION_SOURCE_COUNT_MESSAGE);
+  }
+  if (destinationAddresses.length === 1 && sourceCount !== 1 && allowManyToOne !== true) {
+    throw new PolicyValidationError(
+      "INVALID_WITHDRAWAL_PLAN",
+      SINGLE_DESTINATION_WITHDRAWAL_MESSAGE
+    );
+  }
+}
+function validateDestinationAddresses(destinationAddresses) {
+  if (destinationAddresses.length === 0) {
+    throw new PolicyValidationError(
+      "INVALID_WITHDRAWAL_PLAN",
+      "at least one destination address is required"
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const address of destinationAddresses) {
+    publicKey(address);
+    if (seen.has(address)) {
+      throw new PolicyValidationError(
+        "INVALID_WITHDRAWAL_PLAN",
+        `duplicate withdrawal destination: ${address}`
+      );
+    }
+    seen.add(address);
+  }
+}
+
+// src/lp/coordinatorClient.ts
+var COMMAND_TTL_MS = 3e4;
+var LP_COMMAND_REQUEST_TIMEOUT_MS = 12e4;
+var encoder2 = new TextEncoder();
+var protocolPromise = null;
+function createLpCoordinatorClient(session) {
+  return {
+    initDkg(input, auth) {
+      return initDkg(session, input, auth);
+    },
+    dkgRound1(input, auth) {
+      return dkgRound1(session, input, auth);
+    },
+    dkgRound2(input, auth) {
+      return dkgRound2(session, input, auth);
+    },
+    openPosition(input, auth) {
+      return openPosition(session, input, auth);
+    },
+    getPosition(lpPositionId, auth) {
+      return getPosition(session, lpPositionId, auth);
+    },
+    finalizeDkgBatch(input, auth) {
+      return finalizeDkgBatch(session, input, auth);
+    },
+    refillPosition(input, auth) {
+      return refillPosition(session, input, auth);
+    },
+    reconcileFunding(lpPositionId, auth) {
+      return reconcileFunding(session, lpPositionId, auth);
+    },
+    planFunding(input, auth) {
+      return planFunding(session, input, auth);
+    },
+    confirmFunding(input, auth) {
+      return confirmFunding(session, input, auth);
+    },
+    prepareTopUp(lpPositionId, auth) {
+      return prepareTopUp(session, lpPositionId, auth);
+    },
+    getTopUpStatus(input, auth) {
+      return getTopUpStatus(session, input, auth);
+    },
+    makeAvailable(input, auth) {
+      return makeAvailable(session, input, auth);
+    },
+    executeWithdrawal(input, auth) {
+      return executeWithdrawal(session, input, auth);
+    }
+  };
+}
+async function initDkg(session, input, auth) {
+  const response = await requestForPosition(session, input.lpPositionId, auth, "dkg_init", {
+    case: "dkgInit",
+    value: { index: input.index }
+  });
+  if (response.case !== "dkgInit") throw new Error("Unexpected LP DKG init response");
+  return { sessionId: response.value.session_id };
+}
+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)
+    }
+  });
+  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)
+    }
+  });
+  if (response.case !== "dkgRound2") throw new Error("Unexpected LP DKG round2 response");
+  return {
+    address: response.value.address,
+    jointPubkey: response.value.joint_pubkey,
+    shardId: response.value.shard_id,
+    index: response.value.index
+  };
+}
+async function openPosition(session, input, auth) {
+  const response = await requestForPosition(session, input.lpPositionId, auth, "position_open", {
+    case: "positionOpen",
+    value: {
+      auth_public_key: Uint8Array.from(input.authPublicKey),
+      refill_public_key: Uint8Array.from(input.refillPublicKey),
+      redemption_commitment: Uint8Array.from(input.withdrawalCommitment),
+      committed_lamports: input.committedLamports,
+      shard_count: input.shardCount,
+      shard_amount_lamports: input.shardAmountLamports,
+      refill_threshold: input.refillThreshold,
+      addresses: input.addresses,
+      created_at_ms: input.createdAtMs
+    }
+  });
+  return expectPosition(response);
+}
+async function getPosition(session, lpPositionId, auth) {
+  let cursor;
+  let position;
+  const seenCursors = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    const response = await requestForPosition(session, lpPositionId, auth, "position_get", {
+      case: "positionGet",
+      value: cursor === void 0 ? {} : { redemption_history_cursor: cursor }
+    });
+    const page = expectPosition(response);
+    const mergedPosition = position === void 0 ? page : mergePositionHistoryPages(position, page);
+    position = mergedPosition;
+    const actorSync = page.actorSync;
+    if (actorSync?.redemptionHistoryHasMore !== true) return mergedPosition;
+    const nextCursor = actorSync.redemptionHistoryNextCursor;
+    if (nextCursor === void 0 || seenCursors.has(nextCursor)) {
+      throw new CommandError(
+        "REJECTED_STATE",
+        "coordinator LP actor sync returned an invalid redemption history cursor"
+      );
+    }
+    seenCursors.add(nextCursor);
+    cursor = nextCursor;
+  }
+}
+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 expectPosition(response);
+}
+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 expectPosition(response);
+}
+async function reconcileFunding(session, lpPositionId, auth) {
+  const response = await requestForPosition(session, lpPositionId, auth, "reconcile_funding", {
+    case: "reconcileFunding",
+    value: {}
+  });
+  return expectPosition(response);
+}
+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
+    }
+  });
+  if (response.case !== "shards") throw new Error("Unexpected LP funding plan response");
+  return response.value.map(mapShard);
+}
+async function confirmFunding(session, input, auth) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "funding_confirmation",
+    {
+      case: "fundingConfirmation",
+      value: {
+        shard_id: input.shardId,
+        amount_lamports: input.amountLamports,
+        funding_tx_signature: input.fundingTxSignature
+      }
+    }
+  );
+  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: {}
+  });
+  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 }
+  });
+  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
+    }
+  });
+  if (response.case !== "shard") throw new Error("Unexpected LP availability response");
+  return mapShard(response.value);
+}
+async function executeWithdrawal(session, input, auth) {
+  validateLpWithdrawalPlan({
+    destinationAddresses: input.destinationAddresses,
+    depositPrincipalLamports: input.depositPrincipalLamports,
+    earnedFeeLamports: input.earnedFeeLamports,
+    allowManyToOne: input.allowManyToOne
+  });
+  const response = await requestForPosition(session, input.lpPositionId, auth, "withdraw_request", {
+    case: "withdrawRequest",
+    value: {
+      destination_addresses: input.destinationAddresses,
+      deposit_principal_lamports: input.depositPrincipalLamports,
+      earned_fee_lamports: input.earnedFeeLamports,
+      requested_at_ms: input.requestedAtMs
+    }
+  });
+  if (response.case !== "withdrawalExecution") {
+    throw new Error("Unexpected LP withdrawal execution response");
+  }
+  return {
+    withdrawalId: response.value.withdrawal_id,
+    txSignatures: [...response.value.tx_signatures]
+  };
+}
+function request(session, auth, action, payload) {
+  return requestForPosition(session, auth.lpPositionId, auth, action, payload);
+}
+async function requestForPosition(session, lpPositionId, auth, action, payload) {
+  assertAuthMatchesPosition(lpPositionId, auth);
+  const protocol = await loadProtocol();
+  const state = getSessionState(session);
+  const attestation = state.channel?.attestation;
+  if (!attestation) throw new Error("LP coordinator attestation is not available");
+  const command = {
+    lp_position_id: lpPositionId,
+    action,
+    nonce: randomBytes(32),
+    expires_at_ms: Date.now() + COMMAND_TTL_MS,
+    coordinator_attestation_hash: await coordinatorAttestationHash(
+      attestation.binaryHash,
+      attestation.pubkeyHex
+    ),
+    payload
+  };
+  const signature = await signLpCommandBytes(auth, protocol.encodeLpCommandForSigning(command));
+  const { type, payload: envelopePayload } = protocol.lpSignedCommandEnvelope(command, signature);
+  const envelope = await requestEnvelope(session, type, envelopePayload, {
+    timeoutMs: LP_COMMAND_REQUEST_TIMEOUT_MS
+  });
+  return protocol.asLpCommandResponsePayload(envelope);
+}
+function assertAuthMatchesPosition(lpPositionId, auth) {
+  if (lpPositionId === auth.lpPositionId) return;
+  throw new PolicyValidationError(
+    "INVALID_POSITION_AUTH",
+    "LP Position Code does not match the target LP position"
+  );
+}
+function expectPosition(response) {
+  if (response.case !== "position") throw new Error("Unexpected LP position response");
+  return mapPosition(response.value);
+}
+function mapPosition(position) {
+  return {
+    id: position.lp_position_id,
+    status: position.status,
+    targetShardCount: position.target_shard_count,
+    authPublicKey: bytesToHex(position.auth_public_key),
+    refillPublicKey: bytesToHex(position.refill_public_key),
+    withdrawalCommitment: bytesToHex(position.redemption_commitment),
+    committedLamports: position.committed_lamports,
+    earnedLamports: position.earned_lamports,
+    refillThreshold: position.refill_threshold,
+    shards: position.shards.map(mapShard),
+    createdAt: position.created_at_ms,
+    ...position.actor_sync === void 0 ? {} : { actorSync: mapLpActorSync(position.actor_sync) }
+  };
+}
+function mapLpActorSync(actorSync) {
+  const redeemableBucketValues = [
+    actorSync.redeemable_principal_lamports,
+    actorSync.redeemable_fee_lamports,
+    actorSync.lifetime_earned_lamports,
+    actorSync.redeemable_principal_source_count,
+    actorSync.redeemable_fee_source_count
+  ];
+  const redeemableBucketCount = redeemableBucketValues.filter(
+    (value) => value !== void 0
+  ).length;
+  if (redeemableBucketCount > 0 && redeemableBucketCount < redeemableBucketValues.length) {
+    throw new CommandError(
+      "REJECTED_STATE",
+      "coordinator LP actor sync redeemable buckets must be all-or-none"
+    );
+  }
+  const redeemableProjectionAvailable = redeemableBucketCount === redeemableBucketValues.length;
+  return {
+    lpPositionId: actorSync.lp_position_id,
+    status: actorSync.status,
+    sourceLiquidityUse: actorSync.source_liquidity_use,
+    redeemableProjectionAvailable,
+    redeemablePrincipalLamports: actorSync.redeemable_principal_lamports ?? 0,
+    redeemableFeeLamports: actorSync.redeemable_fee_lamports ?? 0,
+    lifetimeEarnedLamports: actorSync.lifetime_earned_lamports ?? 0,
+    redeemablePrincipalSourceCount: actorSync.redeemable_principal_source_count ?? 0,
+    redeemableFeeSourceCount: actorSync.redeemable_fee_source_count ?? 0,
+    pendingReservationCount: actorSync.pending_reservation_count,
+    reservedPayoutLamports: actorSync.reserved_payout_lamports,
+    estimatedNetworkFeeLamports: actorSync.estimated_network_fee_lamports,
+    reimbursementDueCount: actorSync.reimbursement_due_count,
+    reimbursementDueSourceCount: actorSync.reimbursement_due_source_count,
+    reimbursementDuePayoutLamports: actorSync.reimbursement_due_payout_lamports,
+    reimbursementDueNetworkFeeLamports: actorSync.reimbursement_due_network_fee_lamports,
+    withdrawalRequestedLamports: actorSync.withdrawal_requested_lamports,
+    withdrawalLandedLamports: actorSync.withdrawal_landed_lamports,
+    withdrawalLandedFeeLamports: actorSync.withdrawal_landed_fee_lamports,
+    withdrawalCanceledLamports: actorSync.withdrawal_canceled_lamports,
+    withdrawalNetworkFeeLossLamports: actorSync.withdrawal_network_fee_loss_lamports,
+    withdrawalTxHashes: [...actorSync.withdrawal_tx_hashes],
+    redemptionHistory: (actorSync.redemption_history ?? []).map(mapLpRedemptionHistory),
+    redemptionHistoryHasMore: actorSync.redemption_history_has_more ?? false,
+    ...actorSync.redemption_history_next_cursor === void 0 ? {} : { redemptionHistoryNextCursor: actorSync.redemption_history_next_cursor },
+    stateVersion: actorSync.state_version,
+    updatedAtMs: actorSync.updated_at_ms
+  };
+}
+function mergePositionHistoryPages(first, next) {
+  if (first.actorSync === void 0) return next;
+  if (next.actorSync === void 0) return first;
+  const historyByRedemptionId = /* @__PURE__ */ new Map();
+  for (const history of first.actorSync.redemptionHistory ?? []) {
+    historyByRedemptionId.set(history.redemptionId, history);
+  }
+  for (const history of next.actorSync.redemptionHistory ?? []) {
+    historyByRedemptionId.set(history.redemptionId, history);
+  }
+  return {
+    ...first,
+    actorSync: {
+      ...first.actorSync,
+      ...next.actorSync,
+      redemptionHistory: [...historyByRedemptionId.values()]
+    }
+  };
+}
+function mapLpRedemptionHistory(history) {
+  return {
+    redemptionId: history.redemption_id,
+    state: history.state,
+    acceptedLamports: history.accepted_lamports,
+    acceptedDepositPrincipalLamports: history.accepted_deposit_principal_lamports,
+    acceptedEarnedFeeLamports: history.accepted_earned_fee_lamports,
+    landedLamports: history.landed_lamports,
+    landedDepositPrincipalLamports: history.landed_deposit_principal_lamports,
+    landedEarnedFeeLamports: history.landed_earned_fee_lamports,
+    canceledLamports: history.canceled_lamports,
+    canceledDepositPrincipalLamports: history.canceled_deposit_principal_lamports,
+    canceledEarnedFeeLamports: history.canceled_earned_fee_lamports,
+    networkFeeLamports: history.network_fee_lamports,
+    networkFeeLossLamports: history.network_fee_loss_lamports,
+    failedAttempts: history.failed_attempts,
+    destinationAddresses: [...history.destination_addresses],
+    destinationCount: history.destination_count,
+    txSignatures: [...history.tx_signatures],
+    txSignatureCount: history.tx_signature_count,
+    detailsTruncated: history.details_truncated,
+    stateVersion: history.state_version,
+    createdAtMs: history.created_at_ms,
+    updatedAtMs: history.updated_at_ms
+  };
+}
+function mapShard(shard) {
+  return {
+    kind: "lp",
+    lpPositionId: shard.lp_position_id,
+    shardId: shard.shard_id,
+    index: shard.index,
+    address: shard.address,
+    amountLamports: shard.amount_lamports,
+    ...shard.required_lamports === void 0 ? {} : { requiredLamports: shard.required_lamports },
+    status: mapStatus(shard.status),
+    fundingTxSignature: shard.funding_tx_signature,
+    payoutTxSignature: shard.payout_tx_signature,
+    coolingUntilMs: shard.cooling_until_ms
+  };
+}
+function mapTopUpRequest(request2) {
+  return {
+    topUpId: request2.top_up_id,
+    positionId: request2.lp_position_id,
+    depositAddress: request2.deposit_address,
+    expiresAtMs: request2.expires_at_ms,
+    status: request2.status
+  };
+}
+function mapStatus(status) {
+  switch (status) {
+    case "pregenerated":
+      return "PREGENERATED";
+    case "funding_queued":
+      return "FUNDING_QUEUED";
+    case "funded":
+      return "FUNDED";
+    case "cooling":
+      return "COOLING";
+    case "available":
+      return "AVAILABLE";
+    case "reserved":
+      return "RESERVED";
+    case "retired":
+      return "RETIRED";
+    case "redeemed":
+      return "REDEEMED";
+  }
+}
+async function coordinatorAttestationHash(binaryHash, pubkeyHex) {
+  const material = encoder2.encode(
+    `invisible-lp-attestation-v1\0${binaryHash.toLowerCase()}\0${pubkeyHex.toLowerCase()}`
+  );
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", material));
+}
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  return bytes;
+}
+function loadProtocol() {
+  protocolPromise ??= import('./coordinator-7Y45MCCZ.js');
+  return protocolPromise;
+}
+
+// src/lp/dkgBatch.ts
+var MAX_LP_DKG_CONCURRENCY = 8;
+var DEFAULT_LP_DKG_CONCURRENCY = MAX_LP_DKG_CONCURRENCY;
+var LP_DKG_COMPLETED_SHARD_POLL_INTERVAL_MS = 500;
+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) {
+  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.onProgress?.({
+        completed: offset + 1,
+        total: input.count,
+        address
+      });
+    }
+    return addresses2;
+  }
+  const workerCount = resolveConcurrency(input.count, input.concurrency);
+  const workers = Array.from({ length: workerCount }, () => createWorker(input.workerFactory));
+  const addresses = new Array(input.count);
+  let completed = 0;
+  let nextOffset = 0;
+  try {
+    await Promise.all(
+      workers.map(async (worker) => {
+        for (; ; ) {
+          const offset = nextOffset;
+          nextOffset += 1;
+          if (offset >= input.count) return;
+          const index = input.startIndex + offset;
+          const address = await createLpDkgShard(input, worker, index);
+          addresses[offset] = address;
+          completed += 1;
+          input.onProgress?.({
+            completed,
+            total: input.count,
+            address
+          });
+        }
+      })
+    );
+    return addresses;
+  } finally {
+    workers.forEach((worker) => worker.terminate());
+  }
+}
+async function createLpDkgShard(input, worker, index) {
+  const deadline = Date.now() + LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS;
+  let sawActiveSession = false;
+  for (; ; ) {
+    if (sawActiveSession) {
+      const completedAddress = await getCompletedShardAddress(input, index);
+      if (completedAddress !== null) return completedAddress;
+    }
+    try {
+      return await runLpDkgShard(input, worker, index);
+    } catch (error) {
+      if (isLpDkgCompletedOrVisibleError(error)) {
+        return waitForCompletedShardAddress(input, index);
+      }
+      if (!isLpDkgActiveSessionError(error)) throw error;
+      sawActiveSession = true;
+      const completedAddress = await getCompletedShardAddress(input, index);
+      if (completedAddress !== null) return completedAddress;
+      if (Date.now() >= deadline) throw error;
+      await sleep(LP_DKG_ACTIVE_SESSION_RETRY_INTERVAL_MS);
+    }
+  }
+}
+async function runLpDkgShard(input, worker, index) {
+  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
+  );
+  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(
+    {
+      sessionId: initResponse.sessionId,
+      package: round1.package
+    },
+    input.auth
+  );
+  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(
+    {
+      sessionId: initResponse.sessionId,
+      package: round2.package,
+      delegatedShare: round2.delegatedShare
+    },
+    input.auth
+  );
+  if (!bytesEqual(Uint8Array.from(round2.jointPubkey), round2Response.jointPubkey)) {
+    throw new Error(`LP DKG joint pubkey mismatch at index ${index}`);
+  }
+  if (round2Response.index !== index) {
+    throw new Error(`LP DKG index mismatch: expected ${index}, got ${round2Response.index}`);
+  }
+  return round2Response.address;
+}
+async function waitForCompletedShardAddress(input, index) {
+  const deadline = Date.now() + LP_DKG_COMPLETED_SHARD_POLL_TIMEOUT_MS;
+  for (; ; ) {
+    const address = await getCompletedShardAddress(input, index);
+    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);
+  }
+}
+async function getCompletedShardAddress(input, index) {
+  const position = await input.client.getPosition(input.lpPositionId, input.auth);
+  return position.shards.find((candidate) => candidate.index === index)?.address ?? null;
+}
+function workerRequest(worker, request2) {
+  return new Promise((resolve, reject) => {
+    const onMessage = (event) => {
+      const message = event.data;
+      if (message.id !== request2.id) return;
+      cleanup();
+      if (message.type === "error") {
+        reject(new Error(message.error));
+      } else {
+        resolve(message);
+      }
+    };
+    const onError = (event) => {
+      cleanup();
+      reject(new Error(event.message));
+    };
+    const cleanup = () => {
+      worker.removeEventListener("message", onMessage);
+      worker.removeEventListener("error", onError);
+    };
+    worker.addEventListener("message", onMessage);
+    worker.addEventListener("error", onError);
+    worker.postMessage(request2);
+  });
+}
+function createWorker(workerFactory) {
+  if (workerFactory !== void 0) return workerFactory();
+  return new Worker(new URL("./dkgWorker.js", import.meta.url), { type: "module" });
+}
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  let diff = 0;
+  for (let index = 0; index < a.byteLength; index += 1) {
+    diff |= a[index] ^ b[index];
+  }
+  return diff === 0;
+}
+function isLpDkgCompletedOrVisibleError(error) {
+  if (!(error instanceof Error) || !error.message.includes("LP DKG index")) return false;
+  return error.message.includes("already completed for position") || error.message.includes("already exists for position");
+}
+function isLpDkgActiveSessionError(error) {
+  return error instanceof Error && error.message.includes("LP DKG session already active for position index");
+}
+function resolveConcurrency(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 sleep(delayMs) {
+  return new Promise((resolve) => {
+    globalThis.setTimeout(resolve, delayMs);
+  });
+}
+function testAddress(lpPositionId, index) {
+  return `${lpPositionId}Shard${String(index).padStart(5, "0")}11111111111111111111`;
+}
+
+// src/lp/lifecycle.ts
+var LP_ID_PREFIX = "lp";
+var DEFAULT_SHARD_FUNDING_LAMPORTS = 101e6;
+var DEFAULT_REFILL_THRESHOLD_RATIO = 0.2;
+var LP_DKG_ACTIVE_SESSION_RETRY_DELAY_MS = 2e3;
+var LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS2 = 5 * 6e4 + 15e3;
+var LP_WITHDRAWAL_CONFIRMATION_POLL_INTERVAL_MS = 3e3;
+var LP_WITHDRAWAL_CONFIRMATION_TIMEOUT_MS = 15 * 6e4;
+var LP_TOP_UP_WAIT_POLL_INTERVAL_MS = 1e3;
+var LP_REDEMPTION_HISTORY_OPEN_STATES = /* @__PURE__ */ new Set([
+  "requested",
+  "match_requested",
+  "reserved",
+  "pending"
+]);
+var LP_REDEMPTION_RECONCILING_MESSAGE = "LP redemption is still settling on the coordinator; it will reconcile from sync";
+var LP_MISSING_POSITION_CODE_MESSAGE = "Save or recover the LP Position Code before using LP funds";
+var POSITION_CODE_MISMATCH_MESSAGE = "LP Position Code does not match this TEE position";
+var FUNDING_PLAN_EMPTY_MESSAGE = "TEE returned an empty LP funding plan";
+var WITHDRAWAL_MISSING_RECORD_MESSAGE = "LP withdrawal record is missing";
+var WITHDRAWAL_RECORD_MISMATCH_MESSAGE = "LP withdrawal record does not match this confirmation request";
+var WITHDRAWAL_NO_LAMPORTS_MESSAGE = "LP redemption did not land any lamports on-chain";
+var WITHDRAWAL_HISTORY_MISMATCH_MESSAGE = "LP redemption history does not match this request";
+var UNSUPPORTED_FEE_POLICY_MESSAGE = "LP fee policy overrides are not advertised by the coordinator";
+var FEE_SOURCE_COUNT_UNAVAILABLE_MESSAGE = "LP earned-fee source count is not available; pass allowManyToOne: true to acknowledge many-to-one withdrawal risk";
+var LpRedemptionReconcilingError = class extends LpLifecycleError {
+  constructor() {
+    super("LP_REDEMPTION_RECONCILING", LP_REDEMPTION_RECONCILING_MESSAGE);
+    this.name = "LpRedemptionReconcilingError";
+  }
+};
+var LpPositionAuthMissingError = class extends LpLifecycleError {
+  constructor() {
+    super("LP_POSITION_AUTH_MISSING", LP_MISSING_POSITION_CODE_MESSAGE);
+    this.name = "LpPositionAuthMissingError";
+  }
+};
+function isLpRedemptionReconcilingError(error) {
+  return error instanceof LpRedemptionReconcilingError || error instanceof Error && error.message === LP_REDEMPTION_RECONCILING_MESSAGE;
+}
+function isLpPositionAuthMissingError(error) {
+  return error instanceof LpPositionAuthMissingError || error instanceof Error && error.message === LP_MISSING_POSITION_CODE_MESSAGE;
+}
+var lifecycleClients = /* @__PURE__ */ new WeakMap();
+function createLpLifecycleClient(session, runtime = {}) {
+  const state = {
+    authByPosition: /* @__PURE__ */ new Map(),
+    positions: /* @__PURE__ */ new Map(),
+    redemptions: /* @__PURE__ */ new Map(),
+    topUps: /* @__PURE__ */ new Map()
+  };
+  const client = runtime.coordinatorClient ?? createLpCoordinatorClient(session);
+  const nowMs = runtime.nowMs ?? Date.now;
+  const sleep2 = runtime.sleep ?? defaultSleep;
+  const requireAuth = (positionId) => {
+    const auth = state.authByPosition.get(positionId);
+    if (auth === void 0) throw new LpPositionAuthMissingError();
+    return auth;
+  };
+  const rememberPosition = (position) => {
+    const snapshot = clonePosition(position);
+    state.positions.set(snapshot.id, snapshot);
+    hydrateLpRedemptionsFromPosition(state, snapshot);
+    return position;
+  };
+  const rememberAuth = (auth) => {
+    state.authByPosition.set(auth.lpPositionId, auth);
+  };
+  const refreshPosition2 = async (positionId) => {
+    const auth = requireAuth(positionId);
+    return rememberPosition(await client.getPosition(positionId, auth));
+  };
+  const completeDkgBatch2 = async (positionId, options = {}) => {
+    assertAttested(session);
+    const auth = requireAuth(positionId);
+    let activeSessionRetryStartedAtMs = null;
+    for (; ; ) {
+      const current = rememberPosition(await client.getPosition(positionId, auth));
+      options.onPosition?.(current);
+      const startIndex = current.shards.length;
+      const remaining = current.targetShardCount - startIndex;
+      if (remaining <= 0) return current;
+      emitDkgProgress(options, current, startIndex, remaining, 0);
+      let expectedAddresses = null;
+      try {
+        const addresses = await createLpDkgBatch({
+          lpPositionId: positionId,
+          startIndex,
+          count: remaining,
+          auth,
+          client,
+          concurrency: options.concurrency ?? runtime.dkgConcurrency,
+          workerFactory: options.workerFactory ?? runtime.workerFactory,
+          useDeterministicTestAddresses: runtime.useDeterministicTestAddresses,
+          onProgress: (progress) => {
+            emitDkgProgress(options, current, startIndex, remaining, progress.completed);
+          }
+        });
+        expectedAddresses = addresses;
+        const position = await client.finalizeDkgBatch(
+          {
+            lpPositionId: positionId,
+            startIndex,
+            addresses,
+            finalizedAtMs: nowMs()
+          },
+          auth
+        );
+        options.onPosition?.(position);
+        emitDkgProgress(options, position, startIndex, remaining, remaining);
+        return rememberPosition(position);
+      } catch (error) {
+        const reconciled = await tryRefreshCompletedDkgWindow({
+          client,
+          positionId,
+          auth,
+          startIndex,
+          total: remaining,
+          expectedAddresses,
+          state
+        });
+        if (reconciled !== null) return reconciled;
+        if (isLpDkgIndexDriftError(error)) {
+          activeSessionRetryStartedAtMs = null;
+          continue;
+        }
+        if (!isLpDkgActiveSessionError2(error)) throw error;
+        const currentTime = nowMs();
+        activeSessionRetryStartedAtMs ??= currentTime;
+        if (currentTime - activeSessionRetryStartedAtMs >= LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS2) {
+          throw error;
+        }
+        await sleep2(LP_DKG_ACTIVE_SESSION_RETRY_DELAY_MS);
+      }
+    }
+  };
+  return {
+    async createPosition(args = {}) {
+      assertNoUnsupportedFeePolicy(args.feePolicy);
+      const shardCount = args.shardCount ?? LP_DEFAULT_TARGET_SHARDS;
+      assertShardCount(shardCount, LP_MAX_TARGET_SHARDS, "shardCount");
+      assertAttested(session);
+      const positionId = runtime.idFactory?.() ?? generateId(LP_ID_PREFIX);
+      const auth = await generateLpPositionCode(positionId);
+      rememberAuth(auth);
+      args.onPositionCode?.({ positionId, lpPositionCode: auth.code });
+      const committedLamports = args.committedLamports ?? DEFAULT_SHARD_FUNDING_LAMPORTS;
+      const position = rememberPosition(
+        await client.openPosition(
+          {
+            lpPositionId: positionId,
+            authPublicKey: Array.from(auth.authPublicKey),
+            refillPublicKey: Array.from(auth.refillPublicKey),
+            withdrawalCommitment: Array.from(auth.withdrawalCommitment),
+            committedLamports,
+            shardCount,
+            shardAmountLamports: DEFAULT_SHARD_FUNDING_LAMPORTS,
+            refillThreshold: args.refillThreshold ?? Math.ceil(shardCount * DEFAULT_REFILL_THRESHOLD_RATIO),
+            addresses: [],
+            createdAtMs: nowMs()
+          },
+          auth
+        )
+      );
+      return { positionId, lpPositionCode: auth.code, position };
+    },
+    async recoverPosition(args) {
+      const auth = await deriveLpPositionCodeAuth(args.code);
+      rememberAuth(auth);
+      const position = rememberPosition(await client.getPosition(auth.lpPositionId, auth));
+      assertPositionMatchesAuth(position, auth);
+      return position;
+    },
+    confirmPositionCodeSaved(_positionId) {
+      return;
+    },
+    completeDkgBatch: completeDkgBatch2,
+    refreshPosition: refreshPosition2,
+    async refill(positionId, args = {}) {
+      const requestedShardCount = args.shardCount ?? LP_DEFAULT_REFILL_BATCH_SIZE;
+      assertShardCount(requestedShardCount, LP_MAX_REFILL_BATCH_SIZE, "shardCount");
+      assertAttested(session);
+      const auth = requireAuth(positionId);
+      const current = await refreshPosition2(positionId);
+      args.onPosition?.(current);
+      const refillShardCount = resolveLpRefillShardCount(
+        current,
+        requestedShardCount,
+        args.shardCount === void 0
+      );
+      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 completeDkgBatch2(positionId, {
+        onProgress: args.onProgress,
+        onPosition: args.onPosition,
+        workerFactory: args.workerFactory
+      });
+    },
+    async prepareInitialFunding(positionId) {
+      assertAttested(session);
+      const auth = requireAuth(positionId);
+      const currentPosition = rememberPosition(await client.getPosition(positionId, auth));
+      if (!isLpPositionReadyForInitialFunding(currentPosition)) return null;
+      const initialShard = currentPosition.shards.find((shard) => shard.index === 0);
+      if (initialShard === void 0) return null;
+      if (initialShard.status === "FUNDING_QUEUED") {
+        return fundingPlanFromShard(currentPosition, initialShard);
+      }
+      if (initialShard.status !== "PREGENERATED") return null;
+      const existingQueuedShard = currentPosition.shards.find(
+        (shard) => shard.status === "FUNDING_QUEUED"
+      );
+      if (existingQueuedShard !== void 0) return null;
+      const [plannedShard] = await client.planFunding(
+        { lpPositionId: positionId, shardCount: 1, nowMs: nowMs() },
+        auth
+      );
+      if (plannedShard === void 0) throw new Error(FUNDING_PLAN_EMPTY_MESSAGE);
+      if (plannedShard.index !== 0) {
+        throw new PolicyValidationError(
+          "INVALID_POSITION_AUTH",
+          "Coordinator funding plan did not select LP_DKG_0"
+        );
+      }
+      const position = rememberPosition(await client.getPosition(positionId, auth));
+      return fundingPlanFromShard(position, plannedShard);
+    },
+    async prepareTopUp(positionId) {
+      assertAttested(session);
+      const auth = requireAuth(positionId);
+      const request2 = await client.prepareTopUp(positionId, auth);
+      state.topUps.set(request2.topUpId, request2);
+      return request2;
+    },
+    async waitForTopUp(topUpId, options = {}) {
+      const cached = state.topUps.get(topUpId);
+      if (cached !== void 0 && options.positionId !== void 0 && cached.positionId !== options.positionId) {
+        throw new PolicyValidationError(
+          "INVALID_POSITION_AUTH",
+          "Top-up request does not belong to the requested LP position"
+        );
+      }
+      const initial = cached ?? (options.positionId === void 0 ? void 0 : await client.getTopUpStatus(
+        { lpPositionId: options.positionId, topUpId },
+        requireAuth(options.positionId)
+      ));
+      if (initial === void 0) {
+        throw new PolicyValidationError(
+          "INVALID_POSITION_AUTH",
+          "Top-up request is not known to this LP session"
+        );
+      }
+      const pollIntervalMs = options.pollIntervalMs ?? LP_TOP_UP_WAIT_POLL_INTERVAL_MS;
+      let current = initial;
+      for (; ; ) {
+        throwIfTopUpWaitAborted(options.signal);
+        if (current.status !== "watching") return current;
+        const auth = requireAuth(current.positionId);
+        current = await client.getTopUpStatus({ lpPositionId: current.positionId, topUpId }, auth);
+        state.topUps.set(topUpId, current);
+        if (current.status !== "watching") return current;
+        if (nowMs() >= current.expiresAtMs) {
+          current = await client.getTopUpStatus(
+            { lpPositionId: current.positionId, topUpId },
+            auth
+          );
+          state.topUps.set(topUpId, current);
+          if (current.status !== "watching") return current;
+          current = { ...current, status: "expired" };
+          state.topUps.set(topUpId, current);
+          return current;
+        }
+        await sleep2(pollIntervalMs);
+      }
+    },
+    async reconcileFunding(positionId) {
+      assertAttested(session);
+      const auth = requireAuth(positionId);
+      return rememberPosition(await client.reconcileFunding(positionId, auth));
+    },
+    async withdrawPosition(positionId, args) {
+      validateExplicitWithdrawalInput(args);
+      validateWithdrawalDestinations(args);
+      assertAttested(session);
+      const auth = requireAuth(positionId);
+      const before = rememberPosition(await client.reconcileFunding(positionId, auth));
+      const existingRedemption = findOpenRedemptionHistory(before, args);
+      if (existingRedemption !== void 0) {
+        const execution2 = {
+          withdrawalId: existingRedemption.redemptionId,
+          txSignatures: [...existingRedemption.txSignatures]
+        };
+        const redemption2 = {
+          ...buildLpRedemptionRecord({
+            execution: execution2,
+            position: before,
+            destinationAddresses: existingRedemption.destinationAddresses,
+            acceptedLamports: existingRedemption.acceptedLamports,
+            requestedTargetLamports: existingRedemption.acceptedLamports,
+            landedBaselineLamports: 0,
+            landedFeeBaselineLamports: 0,
+            txSignatureBaseline: [],
+            nowMs: existingRedemption.createdAtMs
+          }),
+          redeemedLamports: existingRedemption.landedLamports,
+          coordinatorStateVersion: existingRedemption.stateVersion
+        };
+        state.redemptions.set(execution2.withdrawalId, redemption2);
+        return { execution: execution2, position: before, redemption: redemption2 };
+      }
+      const claim = resolveWithdrawalClaim(before, args);
+      const sourceCount = lpWithdrawalSourceCountForClaim(before, {
+        ...claim,
+        allowManyToOne: args.allowManyToOne
+      });
+      const validationInput = {
+        lpPositionId: positionId,
+        destinationAddresses: args.destinationAddresses,
+        depositPrincipalLamports: claim.depositPrincipalLamports,
+        earnedFeeLamports: claim.earnedFeeLamports,
+        requestedAtMs: nowMs(),
+        allowManyToOne: args.allowManyToOne ?? false,
+        sourceCount
+      };
+      validateLpWithdrawalPlan(validationInput);
+      const execution = await client.executeWithdrawal(
+        {
+          lpPositionId: validationInput.lpPositionId,
+          destinationAddresses: validationInput.destinationAddresses,
+          depositPrincipalLamports: validationInput.depositPrincipalLamports,
+          earnedFeeLamports: validationInput.earnedFeeLamports,
+          requestedAtMs: validationInput.requestedAtMs,
+          allowManyToOne: args.allowManyToOne === true || sourceCount === 1
+        },
+        auth
+      );
+      const pendingRedemption = buildLpRedemptionRecord({
+        execution,
+        position: before,
+        destinationAddresses: args.destinationAddresses,
+        acceptedLamports: claim.depositPrincipalLamports + claim.earnedFeeLamports,
+        requestedTargetLamports: (before.actorSync?.withdrawalRequestedLamports ?? 0) + claim.depositPrincipalLamports + claim.earnedFeeLamports,
+        landedBaselineLamports: before.actorSync?.withdrawalLandedLamports ?? 0,
+        landedFeeBaselineLamports: before.actorSync?.withdrawalLandedFeeLamports ?? 0,
+        txSignatureBaseline: before.actorSync?.withdrawalTxHashes ?? [],
+        nowMs: nowMs()
+      });
+      state.redemptions.set(execution.withdrawalId, pendingRedemption);
+      const position = await client.getPosition(positionId, auth).then((refreshed) => rememberPosition(refreshed)).catch(() => before);
+      const redemption = { ...pendingRedemption, lpPositionId: position.id };
+      state.redemptions.set(execution.withdrawalId, redemption);
+      return { execution, position, redemption };
+    },
+    async waitForWithdrawalConfirmation(positionId, execution, options = {}) {
+      const auth = requireAuth(positionId);
+      let record = resolveWithdrawalRecord({
+        state,
+        positionId,
+        execution,
+        options
+      });
+      state.redemptions.set(record.redemptionId, record);
+      const deadlineMs = nowMs() + (runtime.withdrawalConfirmationTimeoutMs ?? LP_WITHDRAWAL_CONFIRMATION_TIMEOUT_MS);
+      const pollIntervalMs = runtime.withdrawalConfirmationPollIntervalMs ?? LP_WITHDRAWAL_CONFIRMATION_POLL_INTERVAL_MS;
+      for (; ; ) {
+        const position = rememberPosition(await client.getPosition(positionId, auth));
+        options.onPosition?.(position);
+        const reconciled = reconcileLpRedemptionFromActorSync(record, position);
+        record = reconciled;
+        state.redemptions.set(record.redemptionId, reconciled);
+        options.onRedemptionUpdate?.(reconciled);
+        if (reconciled.status === "confirmed") {
+          return {
+            withdrawalId: execution.withdrawalId,
+            txSignatures: reconciled.txSignatures,
+            redeemedLamports: reconciled.redeemedLamports
+          };
+        }
+        if (reconciled.status === "failed") {
+          throw new Error(reconciled.error ?? WITHDRAWAL_NO_LAMPORTS_MESSAGE);
+        }
+        if (nowMs() > deadlineMs) {
+          state.redemptions.set(record.redemptionId, { ...reconciled, status: "reconciling" });
+          options.onRedemptionUpdate?.({ ...reconciled, status: "reconciling" });
+          throw new LpRedemptionReconcilingError();
+        }
+        await sleep2(pollIntervalMs);
+      }
+    },
+    async withdrawFees(_positionId, args) {
+      publicKey(args.destination);
+      assertAttested(session);
+      throw new RoutingError(
+        "VERSION_NOT_SUPPORTED",
+        "LP fee withdrawal is not advertised by the coordinator"
+      );
+    },
+    async listPositions() {
+      return [...state.positions.values()].map(clonePosition);
+    }
+  };
+}
+function defaultLpLifecycleClient(session) {
+  let client = lifecycleClients.get(session);
+  if (client === void 0) {
+    client = createLpLifecycleClient(session);
+    lifecycleClients.set(session, client);
+  }
+  return client;
+}
+function emitDkgProgress(options, position, startIndex, total, completed) {
+  options.onProgress?.({
+    phase: "dkg",
+    lpPositionId: position.id,
+    startIndex,
+    targetShardCount: startIndex + total,
+    completed: Math.min(completed, total),
+    total
+  });
+}
+async function tryRefreshCompletedDkgWindow({
+  client,
+  positionId,
+  auth,
+  startIndex,
+  total,
+  expectedAddresses,
+  state
+}) {
+  const position = await client.getPosition(positionId, auth).catch(() => null);
+  if (position === null) return null;
+  if (!hasCompletedDkgWindow(position, startIndex, total, expectedAddresses)) return null;
+  state.positions.set(position.id, clonePosition(position));
+  return position;
+}
+function hasCompletedDkgWindow(position, startIndex, total, expectedAddresses) {
+  for (let offset = 0; offset < total; offset += 1) {
+    const shard = position.shards.find((candidate) => candidate.index === startIndex + offset);
+    if (shard === void 0) {
+      return false;
+    }
+    if (expectedAddresses !== null && shard.address !== expectedAddresses[offset]) {
+      return false;
+    }
+  }
+  return true;
+}
+function assertNoUnsupportedFeePolicy(feePolicy) {
+  if (feePolicy === void 0) return;
+  throw new RoutingError("VERSION_NOT_SUPPORTED", UNSUPPORTED_FEE_POLICY_MESSAGE);
+}
+function fundingPlanFromShard(position, shard) {
+  if (shard.requiredLamports === void 0 || shard.requiredLamports <= 0) return null;
+  return {
+    address: shard.address,
+    requiredLamports: shard.requiredLamports,
+    qrPayload: `solana:${shard.address}`,
+    position
+  };
+}
+function assertPositionMatchesAuth(position, auth) {
+  if (position.authPublicKey !== bytesToHex(auth.authPublicKey) || position.refillPublicKey !== bytesToHex(auth.refillPublicKey) || position.withdrawalCommitment !== bytesToHex(auth.withdrawalCommitment)) {
+    throw new Error(POSITION_CODE_MISMATCH_MESSAGE);
+  }
+}
+function assertShardCount(value, max, field) {
+  if (!Number.isInteger(value) || value < 1 || value > max) {
+    throw new PolicyValidationError(
+      "INVALID_AMOUNT",
+      `${field} must be an integer in 1..${max}, received ${String(value)}`
+    );
+  }
+}
+function resolveLpRefillShardCount(position, requestedShardCount, capDefaultBatch) {
+  const remainingShardCapacity = LP_MAX_TARGET_SHARDS - position.shards.length;
+  if (remainingShardCapacity <= 0) {
+    throw new PolicyValidationError(
+      "INVALID_AMOUNT",
+      `LP refill target_shard_count is already at ${LP_MAX_TARGET_SHARDS}`
+    );
+  }
+  const refillShardCount = capDefaultBatch ? Math.min(requestedShardCount, remainingShardCapacity) : requestedShardCount;
+  if (position.shards.length + refillShardCount > LP_MAX_TARGET_SHARDS) {
+    throw new PolicyValidationError(
+      "INVALID_AMOUNT",
+      `LP refill target_shard_count must be <= ${LP_MAX_TARGET_SHARDS}`
+    );
+  }
+  return refillShardCount;
+}
+function isLpPositionReadyForInitialFunding(position) {
+  return position.status === "active" && position.shards.length >= position.targetShardCount;
+}
+function resolveWithdrawalClaim(position, args) {
+  if (args.depositPrincipalLamports !== void 0 || args.earnedFeeLamports !== void 0) {
+    return {
+      depositPrincipalLamports: args.depositPrincipalLamports ?? 0,
+      earnedFeeLamports: args.earnedFeeLamports ?? 0
+    };
+  }
+  const legacyDepositPrincipalLamports = position.shards.filter((shard) => shard.status === "AVAILABLE" && shard.amountLamports > 0).reduce((sum, shard) => sum + shard.amountLamports, 0);
+  const actorRedeemablePrincipalLamports = Math.max(
+    0,
+    position.actorSync?.redeemablePrincipalLamports ?? 0
+  );
+  const actorRedeemableFeeLamports = Math.max(0, position.actorSync?.redeemableFeeLamports ?? 0);
+  const hasActorProjection = hasActorRedeemableProjection(position.actorSync);
+  const depositPrincipalLamports = resolveRedeemablePrincipalLamports(
+    position.actorSync,
+    legacyDepositPrincipalLamports,
+    actorRedeemablePrincipalLamports,
+    actorRedeemableFeeLamports
+  );
+  const earnedFeeLamports = hasActorProjection ? actorRedeemableFeeLamports : Math.max(0, position.earnedLamports);
+  const totalLamports = depositPrincipalLamports + earnedFeeLamports;
+  if (!Number.isSafeInteger(totalLamports) || totalLamports <= 0) {
+    throw new PolicyValidationError(
+      "INVALID_AMOUNT",
+      "LP withdrawal requires available principal or earned fees"
+    );
+  }
+  return { depositPrincipalLamports, earnedFeeLamports };
+}
+function findOpenRedemptionHistory(position, args) {
+  const hasExplicitClaim = args.depositPrincipalLamports !== void 0 || args.earnedFeeLamports !== void 0;
+  const requestedPrincipalLamports = args.depositPrincipalLamports ?? 0;
+  const requestedFeeLamports = args.earnedFeeLamports ?? 0;
+  return position.actorSync?.redemptionHistory?.find(
+    (history) => LP_REDEMPTION_HISTORY_OPEN_STATES.has(history.state) && history.detailsTruncated !== true && sameStringList(history.destinationAddresses, args.destinationAddresses) && (!hasExplicitClaim || history.acceptedDepositPrincipalLamports === requestedPrincipalLamports && history.acceptedEarnedFeeLamports === requestedFeeLamports)
+  );
+}
+function hasActorSyncLpActivity(sync) {
+  if (sync === void 0) return false;
+  return sync.status !== "idle" || sync.pendingReservationCount > 0 || sync.reservedPayoutLamports > 0 || sync.reimbursementDueCount > 0 || sync.reimbursementDueSourceCount > 0 || sync.reimbursementDuePayoutLamports > 0 || sync.reimbursementDueNetworkFeeLamports > 0 || sync.withdrawalRequestedLamports > 0 || sync.withdrawalLandedLamports > 0 || sync.withdrawalLandedFeeLamports > 0 || sync.withdrawalCanceledLamports > 0 || sync.withdrawalNetworkFeeLossLamports > 0 || sync.withdrawalTxHashes.length > 0;
+}
+function resolveRedeemablePrincipalLamports(sync, legacyAvailableLamports, actorRedeemablePrincipalLamports, actorRedeemableFeeLamports) {
+  if (sync?.redeemableProjectionAvailable !== true) return legacyAvailableLamports;
+  if (legacyAvailableLamports <= 0) return actorRedeemablePrincipalLamports;
+  if (actorRedeemablePrincipalLamports >= legacyAvailableLamports || hasActorSyncLpActivity(sync)) {
+    return actorRedeemablePrincipalLamports;
+  }
+  return Math.max(
+    actorRedeemablePrincipalLamports,
+    legacyAvailableLamports - actorRedeemableFeeLamports
+  );
+}
+function hasActorRedeemableProjection(sync) {
+  return sync?.redeemableProjectionAvailable === true;
+}
+function validateExplicitWithdrawalInput(args) {
+  if (args.depositPrincipalLamports === void 0 && args.earnedFeeLamports === void 0) return;
+  validateLpWithdrawalPlan({
+    destinationAddresses: args.destinationAddresses,
+    depositPrincipalLamports: args.depositPrincipalLamports ?? 0,
+    earnedFeeLamports: args.earnedFeeLamports ?? 0,
+    allowManyToOne: args.allowManyToOne,
+    sourceCount: args.destinationAddresses.length
+  });
+}
+function validateWithdrawalDestinations(args) {
+  validateLpWithdrawalPlan({
+    destinationAddresses: args.destinationAddresses,
+    depositPrincipalLamports: 1,
+    earnedFeeLamports: 0,
+    allowManyToOne: true
+  });
+}
+function resolveWithdrawalRecord({
+  state,
+  positionId,
+  execution,
+  options
+}) {
+  const record = state.redemptions.get(execution.withdrawalId) ?? options.redemptionRecord;
+  if (record === void 0) throw new Error(WITHDRAWAL_MISSING_RECORD_MESSAGE);
+  if (record.lpPositionId !== positionId || record.redemptionId !== execution.withdrawalId) {
+    throw new PolicyValidationError("INVALID_REDEMPTION_PLAN", WITHDRAWAL_RECORD_MISMATCH_MESSAGE);
+  }
+  return {
+    ...record,
+    destinationAddresses: [...record.destinationAddresses],
+    txSignatures: [...record.txSignatures],
+    txSignatureBaseline: [...record.txSignatureBaseline],
+    landedFeeBaselineLamports: record.landedFeeBaselineLamports ?? 0
+  };
+}
+function lpWithdrawalSourceCountForClaim(position, claim) {
+  let remainingPrincipalLamports = claim.depositPrincipalLamports;
+  let principalSourceCount = 0;
+  const principalCandidates = [...position.shards].filter((shard) => shard.status === "AVAILABLE" && shard.amountLamports > 0).sort((left, right) => left.shardId.localeCompare(right.shardId));
+  for (const shard of principalCandidates) {
+    if (remainingPrincipalLamports <= 0) break;
+    principalSourceCount += 1;
+    remainingPrincipalLamports -= shard.amountLamports;
+  }
+  const actorRedeemablePrincipalLamports = position.actorSync?.redeemablePrincipalLamports ?? 0;
+  const actorRedeemablePrincipalSourceCount = position.actorSync?.redeemablePrincipalSourceCount ?? 0;
+  if (claim.depositPrincipalLamports > 0 && position.actorSync?.redeemableProjectionAvailable === true && actorRedeemablePrincipalLamports >= claim.depositPrincipalLamports && actorRedeemablePrincipalSourceCount > 0) {
+    principalSourceCount = actorRedeemablePrincipalSourceCount;
+  }
+  const observedEarnedFeeSourceCount = position.actorSync?.redeemableProjectionAvailable === true ? position.actorSync.redeemableFeeSourceCount ?? 0 : position.actorSync?.redeemableFeeSourceCount || position.actorSync?.reimbursementDueSourceCount || 0;
+  if (claim.earnedFeeLamports > 0 && observedEarnedFeeSourceCount < 1 && claim.allowManyToOne !== true) {
+    throw new PolicyValidationError(
+      "INVALID_WITHDRAWAL_PLAN",
+      FEE_SOURCE_COUNT_UNAVAILABLE_MESSAGE
+    );
+  }
+  const earnedFeeSourceCount = claim.earnedFeeLamports > 0 ? Math.max(1, observedEarnedFeeSourceCount) : 0;
+  return principalSourceCount + earnedFeeSourceCount;
+}
+function buildLpRedemptionRecord({
+  execution,
+  position,
+  destinationAddresses,
+  acceptedLamports,
+  requestedTargetLamports,
+  landedBaselineLamports,
+  landedFeeBaselineLamports,
+  txSignatureBaseline,
+  nowMs
+}) {
+  return {
+    redemptionId: execution.withdrawalId,
+    lpPositionId: position.id,
+    requestedAt: nowMs,
+    status: "pending",
+    destinationAddresses: [...destinationAddresses],
+    acceptedLamports,
+    requestedTargetLamports,
+    landedBaselineLamports,
+    landedFeeBaselineLamports,
+    redeemedLamports: 0,
+    txSignatures: [...execution.txSignatures],
+    txSignatureBaseline: [...txSignatureBaseline]
+  };
+}
+function reconcileLpRedemptionFromActorSync(record, position) {
+  const sync = position.actorSync;
+  if (sync === void 0) return record;
+  const history = sync.redemptionHistory?.find(
+    (candidate) => candidate.redemptionId === record.redemptionId
+  );
+  if (history !== void 0) {
+    return reconcileLpRedemptionFromHistory(record, history);
+  }
+  const resolvedLamports = sync.withdrawalLandedLamports + sync.withdrawalLandedFeeLamports + sync.withdrawalCanceledLamports + sync.withdrawalNetworkFeeLossLamports;
+  const settled = sync.withdrawalRequestedLamports >= record.requestedTargetLamports && sync.withdrawalRequestedLamports <= resolvedLamports;
+  const redeemedLamports = Math.max(
+    sync.withdrawalLandedLamports - record.landedBaselineLamports + sync.withdrawalLandedFeeLamports - (record.landedFeeBaselineLamports ?? 0),
+    0
+  );
+  const baselineSignatures = new Set(record.txSignatureBaseline);
+  const txSignatures = sync.withdrawalTxHashes.filter(
+    (signature) => !baselineSignatures.has(signature)
+  );
+  if (!settled) return { ...record, redeemedLamports, txSignatures };
+  if (redeemedLamports <= 0) {
+    return {
+      ...record,
+      status: "failed",
+      redeemedLamports,
+      txSignatures,
+      error: WITHDRAWAL_NO_LAMPORTS_MESSAGE
+    };
+  }
+  return { ...record, status: "confirmed", redeemedLamports, txSignatures };
+}
+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)) {
+    return {
+      ...record,
+      status: "failed",
+      coordinatorStateVersion: Math.max(observedStateVersion, history.stateVersion),
+      error: WITHDRAWAL_HISTORY_MISMATCH_MESSAGE
+    };
+  }
+  const txSignatures = uniqueStrings([...record.txSignatures, ...history.txSignatures]);
+  const base = {
+    ...record,
+    coordinatorStateVersion: history.stateVersion,
+    redeemedLamports: history.landedLamports,
+    txSignatures,
+    destinationCount: history.destinationCount,
+    txSignatureCount: history.txSignatureCount,
+    detailsTruncated: history.detailsTruncated,
+    error: void 0
+  };
+  if (history.state === "confirmed") {
+    return history.landedLamports > 0 ? { ...base, status: "confirmed" } : { ...base, status: "failed", error: WITHDRAWAL_NO_LAMPORTS_MESSAGE };
+  }
+  if (history.state === "rejected") {
+    return {
+      ...base,
+      status: "failed",
+      error: WITHDRAWAL_NO_LAMPORTS_MESSAGE
+    };
+  }
+  return {
+    ...base,
+    status: record.status === "reconciling" ? "reconciling" : "pending"
+  };
+}
+function hydrateLpRedemptionsFromPosition(state, position) {
+  for (const history of position.actorSync?.redemptionHistory ?? []) {
+    const existing = state.redemptions.get(history.redemptionId);
+    if (existing === void 0) {
+      state.redemptions.set(history.redemptionId, lpWithdrawalRecordFromHistory(position, history));
+      continue;
+    }
+    state.redemptions.set(
+      history.redemptionId,
+      reconcileLpRedemptionFromHistory(existing, history)
+    );
+  }
+}
+function lpWithdrawalRecordFromHistory(position, history) {
+  const record = {
+    redemptionId: history.redemptionId,
+    lpPositionId: position.id,
+    requestedAt: history.createdAtMs,
+    status: "pending",
+    destinationAddresses: [...history.destinationAddresses],
+    acceptedLamports: history.acceptedLamports,
+    requestedTargetLamports: history.acceptedLamports,
+    landedBaselineLamports: 0,
+    landedFeeBaselineLamports: 0,
+    redeemedLamports: history.landedLamports,
+    txSignatures: [...history.txSignatures],
+    txSignatureBaseline: [],
+    coordinatorStateVersion: history.stateVersion,
+    destinationCount: history.destinationCount,
+    txSignatureCount: history.txSignatureCount,
+    detailsTruncated: history.detailsTruncated
+  };
+  return reconcileLpRedemptionFromHistory(record, history);
+}
+function sameStringList(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values));
+}
+function isLpDkgActiveSessionError2(error) {
+  return error instanceof Error && error.message.includes("LP DKG session already active for position index");
+}
+function isLpDkgIndexDriftError(error) {
+  if (!(error instanceof Error)) return false;
+  return error.message.includes("LP DKG index") && error.message.includes("already exists for position") || error.message.includes("LP DKG expected index");
+}
+function clonePosition(position) {
+  return {
+    ...position,
+    shards: position.shards.map((shard) => ({ ...shard })),
+    actorSync: position.actorSync === void 0 ? void 0 : {
+      ...position.actorSync,
+      redemptionHistory: position.actorSync.redemptionHistory?.map((history) => ({
+        ...history,
+        destinationAddresses: [...history.destinationAddresses],
+        txSignatures: [...history.txSignatures]
+      }))
+    }
+  };
+}
+function generateId(prefix) {
+  return `${prefix}_${Array.from(randomBytes2(8)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function randomBytes2(length) {
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  return bytes;
+}
+function throwIfTopUpWaitAborted(signal) {
+  if (signal?.aborted !== true) return;
+  throw new DOMException("LP top-up wait aborted", "AbortError");
+}
+function defaultSleep(delayMs) {
+  return new Promise((resolve) => {
+    globalThis.setTimeout(resolve, delayMs);
+  });
+}
+
+// src/lp/index.ts
+function createPosition(session, args = {}) {
+  return defaultLpLifecycleClient(session).createPosition(args);
+}
+function recoverPosition(session, args) {
+  return defaultLpLifecycleClient(session).recoverPosition(args);
+}
+function confirmPositionCodeSaved(session, positionId) {
+  defaultLpLifecycleClient(session).confirmPositionCodeSaved(positionId);
+}
+async function completeDkgBatch(session, positionId, opts = {}) {
+  return await defaultLpLifecycleClient(session).completeDkgBatch(positionId, opts);
+}
+function refreshPosition(session, positionId) {
+  return defaultLpLifecycleClient(session).refreshPosition(positionId);
+}
+function refill(session, positionId, args = {}) {
+  return defaultLpLifecycleClient(session).refill(positionId, args);
+}
+function prepareInitialFunding(session, positionId) {
+  return defaultLpLifecycleClient(session).prepareInitialFunding(positionId);
+}
+function prepareTopUp2(session, positionId) {
+  return defaultLpLifecycleClient(session).prepareTopUp(positionId);
+}
+function waitForTopUp(session, topUpId, options = {}) {
+  return defaultLpLifecycleClient(session).waitForTopUp(topUpId, options);
+}
+function reconcileFunding2(session, positionId) {
+  return defaultLpLifecycleClient(session).reconcileFunding(positionId);
+}
+function withdrawPosition(session, positionId, args) {
+  return defaultLpLifecycleClient(session).withdrawPosition(positionId, args);
+}
+function waitForWithdrawalConfirmation(session, positionId, execution, options = {}) {
+  return defaultLpLifecycleClient(session).waitForWithdrawalConfirmation(
+    positionId,
+    execution,
+    options
+  );
+}
+async function withdrawFees(session, positionId, args) {
+  publicKey(args.destination);
+  assertAttested(session);
+  return await defaultLpLifecycleClient(session).withdrawFees(positionId, args);
+}
+function listPositions(session) {
+  return defaultLpLifecycleClient(session).listPositions();
+}
+
+export { LP_COMMAND_REQUEST_TIMEOUT_MS, LP_MISSING_POSITION_CODE_MESSAGE, LP_REDEMPTION_RECONCILING_MESSAGE, bytesToHex, completeDkgBatch, confirmPositionCodeSaved, createLpCoordinatorClient, createLpDkgBatch, createLpLifecycleClient, createPosition, defaultLpLifecycleClient, deriveLpPositionCodeAuth, generateLpPositionCode, isLpPositionAuthMissingError, isLpRedemptionReconcilingError, listPositions, normalizeLpPositionCode, prepareInitialFunding, prepareTopUp2 as prepareTopUp, reconcileFunding2 as reconcileFunding, recoverPosition, refill, refreshPosition, signLpCommandBytes, waitForTopUp, waitForWithdrawalConfirmation, withdrawFees, withdrawPosition };
+//# sourceMappingURL=lp.js.map
+//# sourceMappingURL=lp.js.map