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

package/dist/lp.js

@@ -1,8 +1,8 @@
-import { isValidLpPositionId, LP_MAX_TOTAL_SHARDS, LP_MAX_INITIAL_SHARDS, LP_MAX_REFILL_BATCH_SIZE, LP_SHARD_PAGE_SIZE, LP_DEFAULT_REFILL_BATCH_SIZE, LP_DEFAULT_TARGET_SHARDS } from './chunk-HWRMSK7E.js';
-import { publicKey, assertAttested, lamports } from './chunk-EPWTRF5U.js';
-import { requestEnvelope, CoordinatorMessageType } from './chunk-6AGC3IOB.js';
-import { getSessionState } from './chunk-6AKBRYKO.js';
-import { CommandError, WalletError, TransportError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-RWKG7N7I.js';
+import { isValidLpPositionId, LP_MAX_TOTAL_SHARDS, LP_MAX_INITIAL_SHARDS, LP_MAX_REFILL_BATCH_SIZE, LP_SHARD_PAGE_SIZE, LP_DEFAULT_REFILL_BATCH_SIZE, LP_DEFAULT_TARGET_SHARDS } from './chunk-TNLSUQGJ.js';
+import { publicKey, assertAttested, lamports } from './chunk-TYTVF3A4.js';
+import { requestEnvelope, CoordinatorMessageType } from './chunk-NOKBFHDP.js';
+import { getSessionState } from './chunk-DOTYDYVB.js';
+import { CommandError, TransportError, PolicyValidationError, LpLifecycleError, RoutingError, WalletError } from './chunk-A4R3DHKN.js';
 import './chunk-VR6T6OJS.js';
 
 // src/lp/actorSync.ts
@@ -343,62 +343,108 @@ var protocolPromise = null;
 function createLpCoordinatorClient(session, options = {}) {
   const sessionRef = { current: session };
   const reconnectSession = options.reconnectSession === void 0 ? void 0 : async () => {
+    options.signal?.throwIfAborted();
     const nextSession = await options.reconnectSession();
+    options.signal?.throwIfAborted();
     sessionRef.current = nextSession;
     return nextSession;
   };
+  const run = (operation, signal) => withLpClientSignal(options.signal, signal, operation);
   return {
     authorizePositionCreation(intent, signer) {
-      return authorizePositionCreation(sessionRef.current, intent, signer);
+      return run((signal) => authorizePositionCreation(sessionRef.current, intent, signer, signal));
     },
-    initDkg(input, auth) {
-      return initDkg(sessionRef.current, input, auth);
+    initDkg(input, auth, options2) {
+      return run((signal) => initDkg(sessionRef.current, input, auth, { signal }), options2?.signal);
     },
     abortDkgSessions(lpPositionId, auth) {
       return abortDkgSessions(sessionRef.current, lpPositionId, auth);
     },
-    dkgRound1(input, auth) {
-      return dkgRound1(sessionRef.current, input, auth);
+    dkgRound1(input, auth, options2) {
+      return run(
+        (signal) => dkgRound1(sessionRef.current, input, auth, { signal }),
+        options2?.signal
+      );
     },
-    dkgRound2(input, auth) {
-      return dkgRound2(sessionRef.current, input, auth);
+    dkgRound2(input, auth, options2) {
+      return run(
+        (signal) => dkgRound2(sessionRef.current, input, auth, { signal }),
+        options2?.signal
+      );
     },
     openPosition(input, auth) {
-      return openPosition(sessionRef.current, input, auth, reconnectSession);
+      return run(
+        (signal) => openPosition(sessionRef.current, input, auth, reconnectSession, signal)
+      );
     },
     getPosition(lpPositionId, auth, options2) {
-      return getPosition(sessionRef.current, lpPositionId, auth, options2);
+      return run(
+        (signal) => getPosition(sessionRef.current, lpPositionId, auth, { ...options2, signal }),
+        options2?.signal
+      );
     },
     finalizeDkgBatch(input, auth) {
-      return finalizeDkgBatch(sessionRef.current, input, auth);
+      return run((signal) => finalizeDkgBatch(sessionRef.current, input, auth, { signal }));
     },
     refillPosition(input, auth) {
-      return refillPosition(sessionRef.current, input, auth);
+      return run((signal) => refillPosition(sessionRef.current, input, auth, { signal }));
     },
     reconcileFunding(lpPositionId, auth) {
-      return reconcileFunding(sessionRef.current, lpPositionId, auth);
+      return run((signal) => reconcileFunding(sessionRef.current, lpPositionId, auth, { signal }));
     },
     planFunding(input, auth) {
-      return planFunding(sessionRef.current, input, auth);
+      return run((signal) => planFunding(sessionRef.current, input, auth, { signal }));
     },
     confirmFunding(input, auth) {
-      return confirmFunding(sessionRef.current, input, auth);
+      return run((signal) => confirmFunding(sessionRef.current, input, auth, { signal }));
     },
     prepareTopUp(lpPositionId, auth) {
-      return prepareTopUp(sessionRef.current, lpPositionId, auth);
+      return run((signal) => prepareTopUp(sessionRef.current, lpPositionId, auth, { signal }));
     },
     getTopUpStatus(input, auth) {
-      return getTopUpStatus(sessionRef.current, input, auth);
+      return run((signal) => getTopUpStatus(sessionRef.current, input, auth, { signal }));
     },
     makeAvailable(input, auth) {
-      return makeAvailable(sessionRef.current, input, auth);
+      return run((signal) => makeAvailable(sessionRef.current, input, auth, { signal }));
     },
     executeWithdrawal(input, auth) {
-      return executeWithdrawal(sessionRef.current, input, auth);
+      return run((signal) => executeWithdrawal(sessionRef.current, input, auth, { signal }));
     }
   };
 }
-async function authorizePositionCreation(session, intent, signer) {
+async function withLpClientSignal(clientSignal, requestSignal, operation) {
+  const perform = async (signal) => {
+    try {
+      signal?.throwIfAborted();
+      return await operation(signal);
+    } catch (error) {
+      if (clientSignal?.aborted && signal?.reason === clientSignal.reason && error instanceof Error && error.name === "AbortError") {
+        throw clientSignal.reason;
+      }
+      throw error;
+    }
+  };
+  if (clientSignal === void 0) return perform(requestSignal);
+  if (requestSignal === void 0 || requestSignal === clientSignal) {
+    clientSignal.throwIfAborted();
+    return perform(clientSignal);
+  }
+  const controller = new AbortController();
+  const abortClient = () => controller.abort(clientSignal.reason);
+  const abortRequest = () => controller.abort(requestSignal.reason);
+  clientSignal.addEventListener("abort", abortClient, { once: true });
+  requestSignal.addEventListener("abort", abortRequest, { once: true });
+  try {
+    if (clientSignal.aborted) abortClient();
+    if (requestSignal.aborted) abortRequest();
+    controller.signal.throwIfAborted();
+    return await perform(controller.signal);
+  } finally {
+    clientSignal.removeEventListener("abort", abortClient);
+    requestSignal.removeEventListener("abort", abortRequest);
+  }
+}
+async function authorizePositionCreation(session, intent, signer, signal) {
   const signerPublicKey = publicKey(signer.publicKey);
   const challengeRequestStartedAtMs = Date.now();
   const challengeEnvelope = await requestEnvelope(
@@ -416,7 +462,7 @@ async function authorizePositionCreation(session, intent, signer) {
         }
       }
     },
-    { timeoutMs: LP_CREATION_CHALLENGE_REQUEST_TIMEOUT_MS }
+    { timeoutMs: LP_CREATION_CHALLENGE_REQUEST_TIMEOUT_MS, signal }
   );
   const challenge = challengeEnvelope.payload;
   if (challenge.case !== "challenge") {
@@ -472,7 +518,7 @@ async function authorizePositionCreation(session, intent, signer) {
       session,
       CoordinatorMessageType.LpCreateAuthorization,
       proofPayload,
-      { timeoutMs: proofTimeoutMs }
+      { timeoutMs: proofTimeoutMs, signal }
     );
   } catch (error) {
     if (!isAmbiguousCoordinatorRequestFailure(error)) throw error;
@@ -485,7 +531,7 @@ async function authorizePositionCreation(session, intent, signer) {
       session,
       CoordinatorMessageType.LpCreateAuthorization,
       proofPayload,
-      { timeoutMs: proofRetryTimeoutMs }
+      { timeoutMs: proofRetryTimeoutMs, signal }
     );
   }
   const authorization = proofEnvelope.payload;
@@ -542,15 +588,22 @@ async function signLpCreationMessageWithTimeout(signer, message, timeoutMs) {
     if (timeoutId !== void 0) clearTimeout(timeoutId);
   }
 }
-async function initDkg(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "dkg_init", {
-    case: "dkgInit",
-    value: { index: input.index }
-  });
+async function initDkg(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "dkg_init",
+    {
+      case: "dkgInit",
+      value: { index: input.index }
+    },
+    options
+  );
   if (response.case !== "dkgInit") throw new Error("Unexpected LP DKG init response");
   return { sessionId: response.value.session_id };
 }
-async function abortDkgSessions(session, lpPositionId, auth) {
+async function abortDkgSessions(session, lpPositionId, auth, signal) {
   const response = await requestForPosition(
     session,
     lpPositionId,
@@ -560,34 +613,46 @@ async function abortDkgSessions(session, lpPositionId, auth) {
       case: "dkgAbort",
       value: {}
     },
-    { timeoutMs: LP_DKG_ABORT_REQUEST_TIMEOUT_MS }
+    { timeoutMs: LP_DKG_ABORT_REQUEST_TIMEOUT_MS, signal }
   );
   if (response.case !== "dkgAbort") throw new Error("Unexpected LP DKG abort response");
   return { abortedSessionCount: response.value.aborted_session_count };
 }
-async function dkgRound1(session, input, auth) {
-  const response = await request(session, auth, "dkg_round1", {
-    case: "dkgRound1",
-    value: {
-      session_id: input.sessionId,
-      package: Uint8Array.from(input.package)
-    }
-  });
+async function dkgRound1(session, input, auth, options = {}) {
+  const response = await request(
+    session,
+    auth,
+    "dkg_round1",
+    {
+      case: "dkgRound1",
+      value: {
+        session_id: input.sessionId,
+        package: Uint8Array.from(input.package)
+      }
+    },
+    options
+  );
   if (response.case !== "dkgRound1") throw new Error("Unexpected LP DKG round1 response");
   return {
     package: response.value.package,
     round2ForLp: response.value.round2_for_lp
   };
 }
-async function dkgRound2(session, input, auth) {
-  const response = await request(session, auth, "dkg_round2", {
-    case: "dkgRound2",
-    value: {
-      session_id: input.sessionId,
-      package: Uint8Array.from(input.package),
-      delegated_share: Uint8Array.from(input.delegatedShare)
-    }
-  });
+async function dkgRound2(session, input, auth, options = {}) {
+  const response = await request(
+    session,
+    auth,
+    "dkg_round2",
+    {
+      case: "dkgRound2",
+      value: {
+        session_id: input.sessionId,
+        package: Uint8Array.from(input.package),
+        delegated_share: Uint8Array.from(input.delegatedShare)
+      }
+    },
+    options
+  );
   if (response.case !== "dkgRound2") throw new Error("Unexpected LP DKG round2 response");
   return {
     address: response.value.address,
@@ -596,7 +661,7 @@ async function dkgRound2(session, input, auth) {
     index: response.value.index
   };
 }
-async function openPosition(session, input, auth, reconnectSession) {
+async function openPosition(session, input, auth, reconnectSession, signal) {
   const payload = {
     case: "positionOpen",
     value: {
@@ -615,6 +680,7 @@ async function openPosition(session, input, auth, reconnectSession) {
   };
   const commandDeadlineMs = Date.now() + LP_POSITION_OPEN_COMMAND_TTL_MS;
   const commandOptions = {
+    signal,
     commandNonce: randomBytes(32),
     commandExpiresAtMs: commandDeadlineMs,
     deadlineMs: commandDeadlineMs,
@@ -633,7 +699,7 @@ async function openPosition(session, input, auth, reconnectSession) {
     );
   } catch (error) {
     if (!isAmbiguousLpPositionOpenFailure(error)) throw error;
-    responseSession = reconnectSession === void 0 ? session : await reconnectSessionWithinDeadline(reconnectSession, commandDeadlineMs);
+    responseSession = reconnectSession === void 0 ? session : await reconnectSessionWithinDeadline(reconnectSession, commandDeadlineMs, signal);
   }
   const position = await hydratePositionResponse(
     responseSession,
@@ -641,7 +707,8 @@ async function openPosition(session, input, auth, reconnectSession) {
     auth,
     response,
     {
-      deadlineMs: commandDeadlineMs
+      deadlineMs: commandDeadlineMs,
+      signal
     }
   );
   if (position.authPublicKey !== bytesToHex(Uint8Array.from(input.authPublicKey)) || position.refillPublicKey !== bytesToHex(Uint8Array.from(input.refillPublicKey)) || position.withdrawalCommitment !== bytesToHex(Uint8Array.from(input.withdrawalCommitment)) || position.committedLamports !== input.committedLamports || position.targetShardCount !== input.shardCount || position.refillThreshold !== input.refillThreshold || position.createdAt !== input.createdAtMs) {
@@ -655,7 +722,8 @@ async function openPosition(session, input, auth, reconnectSession) {
   }
   return position;
 }
-async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
+async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs, signal) {
+  signal?.throwIfAborted();
   const remainingMs = deadlineMs - Date.now();
   if (remainingMs <= 0) {
     throw new CommandError(
@@ -664,8 +732,12 @@ async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
     );
   }
   let timer;
+  let removeAbort;
   try {
     return await new Promise((resolve, reject) => {
+      const onAbort = () => reject(signal?.reason);
+      signal?.addEventListener("abort", onAbort, { once: true });
+      removeAbort = () => signal?.removeEventListener("abort", onAbort);
       timer = setTimeout(() => {
         reject(
           new CommandError(
@@ -674,10 +746,14 @@ async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
           )
         );
       }, remainingMs);
-      Promise.resolve().then(reconnectSession).then(resolve, reject);
+      Promise.resolve().then(() => {
+        signal?.throwIfAborted();
+        return reconnectSession();
+      }).then(resolve, reject);
     });
   } finally {
     if (timer !== void 0) clearTimeout(timer);
+    removeAbort?.();
   }
 }
 function isAmbiguousLpPositionOpenFailure(error) {
@@ -825,48 +901,76 @@ function lpPositionPageRequestOptions(options) {
     timeoutMs: Math.min(options.timeoutMs ?? LP_COMMAND_REQUEST_TIMEOUT_MS, remainingMs)
   };
 }
-async function finalizeDkgBatch(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "dkg_finalize", {
-    case: "dkgFinalize",
-    value: {
-      start_index: input.startIndex,
-      addresses: input.addresses,
-      finalized_at_ms: input.finalizedAtMs
-    }
-  });
-  return hydratePositionResponse(session, auth.lpPositionId, auth, response);
+async function finalizeDkgBatch(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "dkg_finalize",
+    {
+      case: "dkgFinalize",
+      value: {
+        start_index: input.startIndex,
+        addresses: input.addresses,
+        finalized_at_ms: input.finalizedAtMs
+      }
+    },
+    options
+  );
+  return hydratePositionResponse(session, auth.lpPositionId, auth, response, options);
 }
-async function refillPosition(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "refill", {
-    case: "refill",
-    value: {
-      shard_count: input.shardCount,
-      shard_amount_lamports: input.shardAmountLamports,
-      addresses: input.addresses,
-      authorized_at_ms: input.authorizedAtMs
-    }
-  });
-  return hydratePositionResponse(session, auth.lpPositionId, auth, response);
+async function refillPosition(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "refill",
+    {
+      case: "refill",
+      value: {
+        shard_count: input.shardCount,
+        shard_amount_lamports: input.shardAmountLamports,
+        addresses: input.addresses,
+        authorized_at_ms: input.authorizedAtMs
+      }
+    },
+    options
+  );
+  return hydratePositionResponse(session, auth.lpPositionId, auth, response, options);
 }
-async function reconcileFunding(session, lpPositionId, auth) {
-  const response = await requestForPosition(session, lpPositionId, auth, "reconcile_funding", {
-    case: "reconcileFunding",
-    value: {}
-  });
-  return hydratePositionResponse(session, auth.lpPositionId, auth, response);
+async function reconcileFunding(session, lpPositionId, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    lpPositionId,
+    auth,
+    "reconcile_funding",
+    {
+      case: "reconcileFunding",
+      value: {}
+    },
+    options
+  );
+  return hydratePositionResponse(session, auth.lpPositionId, auth, response, options);
 }
-async function planFunding(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "funding_plan", {
-    case: "fundingPlan",
-    value: {
-      shard_count: input.shardCount,
-      planned_at_ms: input.nowMs
-    }
-  });
+async function planFunding(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "funding_plan",
+    {
+      case: "fundingPlan",
+      value: {
+        shard_count: input.shardCount,
+        planned_at_ms: input.nowMs
+      }
+    },
+    options
+  );
   if (response.case !== "shards") throw new Error("Unexpected LP funding plan response");
   return response.value.map(mapShard);
 }
-async function confirmFunding(session, input, auth) {
+async function confirmFunding(session, input, auth, options = {}) {
   const response = await requestForPosition(
     session,
     input.lpPositionId,
@@ -879,38 +983,60 @@ async function confirmFunding(session, input, auth) {
         amount_lamports: input.amountLamports,
         funding_tx_signature: input.fundingTxSignature
       }
-    }
+    },
+    options
   );
   if (response.case !== "shard") throw new Error("Unexpected LP funding confirmation response");
   return mapShard(response.value);
 }
-async function prepareTopUp(session, lpPositionId, auth) {
-  const response = await requestForPosition(session, lpPositionId, auth, "prepare_top_up", {
-    case: "prepareTopUp",
-    value: {}
-  });
+async function prepareTopUp(session, lpPositionId, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    lpPositionId,
+    auth,
+    "prepare_top_up",
+    {
+      case: "prepareTopUp",
+      value: {}
+    },
+    options
+  );
   if (response.case !== "topUpRequest") throw new Error("Unexpected LP top-up response");
   return mapTopUpRequest(response.value);
 }
-async function getTopUpStatus(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "top_up_status", {
-    case: "topUpStatus",
-    value: { top_up_id: input.topUpId }
-  });
+async function getTopUpStatus(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "top_up_status",
+    {
+      case: "topUpStatus",
+      value: { top_up_id: input.topUpId }
+    },
+    options
+  );
   if (response.case !== "topUpRequest") throw new Error("Unexpected LP top-up response");
   return mapTopUpRequest(response.value);
 }
-async function makeAvailable(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "make_available", {
-    case: "makeAvailable",
-    value: {
-      shard_id: input.shardId
-    }
-  });
+async function makeAvailable(session, input, auth, options = {}) {
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "make_available",
+    {
+      case: "makeAvailable",
+      value: {
+        shard_id: input.shardId
+      }
+    },
+    options
+  );
   if (response.case !== "shard") throw new Error("Unexpected LP availability response");
   return mapShard(response.value);
 }
-async function executeWithdrawal(session, input, auth) {
+async function executeWithdrawal(session, input, auth, options = {}) {
   validateLpWithdrawalPlan({
     destinationAddresses: input.destinationAddresses,
     depositPrincipalLamports: input.withdrawalMode === "max_available" ? 1 : input.depositPrincipalLamports,
@@ -920,18 +1046,25 @@ async function executeWithdrawal(session, input, auth) {
     // a one-destination request based on an unknown current source count.
     allowManyToOne: input.withdrawalMode === "max_available" || input.allowManyToOne
   });
-  const response = await requestForPosition(session, input.lpPositionId, auth, "withdraw_request", {
-    case: "withdrawRequest",
-    value: {
-      destination_addresses: input.destinationAddresses,
-      deposit_principal_lamports: input.withdrawalMode === "max_available" ? 0 : input.depositPrincipalLamports,
-      earned_fee_lamports: input.withdrawalMode === "max_available" ? 0 : input.earnedFeeLamports,
-      withdrawal_mode: input.withdrawalMode,
-      requested_at_ms: input.requestedAtMs,
-      fee_policy_hash: input.feePolicyHash,
-      fee_basis_revision: input.feeBasisRevision
-    }
-  });
+  const response = await requestForPosition(
+    session,
+    input.lpPositionId,
+    auth,
+    "withdraw_request",
+    {
+      case: "withdrawRequest",
+      value: {
+        destination_addresses: input.destinationAddresses,
+        deposit_principal_lamports: input.withdrawalMode === "max_available" ? 0 : input.depositPrincipalLamports,
+        earned_fee_lamports: input.withdrawalMode === "max_available" ? 0 : input.earnedFeeLamports,
+        withdrawal_mode: input.withdrawalMode,
+        requested_at_ms: input.requestedAtMs,
+        fee_policy_hash: input.feePolicyHash,
+        fee_basis_revision: input.feeBasisRevision
+      }
+    },
+    options
+  );
   if (response.case !== "withdrawalExecution") {
     throw new Error("Unexpected LP withdrawal execution response");
   }
@@ -964,13 +1097,15 @@ async function executeWithdrawal(session, input, auth) {
     acceptedEarnedFeeLamports: execution.accepted_earned_fee_lamports
   };
 }
-function request(session, auth, action, payload) {
-  return requestForPosition(session, auth.lpPositionId, auth, action, payload);
+function request(session, auth, action, payload, options = {}) {
+  return requestForPosition(session, auth.lpPositionId, auth, action, payload, options);
 }
 async function requestForPosition(session, lpPositionId, auth, action, payload, options = {}) {
+  options.signal?.throwIfAborted();
   const timeoutMs = lpPositionPageRequestOptions(options).timeoutMs ?? LP_COMMAND_REQUEST_TIMEOUT_MS;
   assertAuthMatchesPosition(lpPositionId, auth);
   const protocol = await loadProtocol();
+  options.signal?.throwIfAborted();
   const state = getSessionState(session);
   const attestation = state.channel?.attestation;
   if (!attestation) {
@@ -987,7 +1122,9 @@ async function requestForPosition(session, lpPositionId, auth, action, payload,
     ),
     payload
   };
+  options.signal?.throwIfAborted();
   const signature = await signLpCommandBytes(auth, protocol.encodeLpCommandForSigning(command));
+  options.signal?.throwIfAborted();
   const { type, payload: envelopePayload } = protocol.lpSignedCommandEnvelope(command, signature);
   const requestOptions = lpPositionPageRequestOptions(options);
   const envelope = await requestEnvelope(session, type, envelopePayload, {
@@ -1226,13 +1363,14 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-T2B7253V.js');
+  protocolPromise ??= import('./coordinator-EQEL23A3.js');
   return protocolPromise;
 }
 
 // src/lp/dkgBatch.ts
-var MAX_LP_DKG_CONCURRENCY = 8;
+var MAX_LP_DKG_CONCURRENCY = 16;
 var DEFAULT_LP_DKG_CONCURRENCY = MAX_LP_DKG_CONCURRENCY;
+var LP_DKG_WORKER_FAILURE_MESSAGE = "LP DKG worker failed";
 var LP_DKG_WORKER_REQUEST_TIMEOUT_MS = 3e4;
 var LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE = "LP DKG worker request timed out";
 var LP_DKG_ABORT_CLEANUP_TIMEOUT_MS = 1e4;
@@ -1242,21 +1380,28 @@ var LP_DKG_COMPLETED_SHARD_POLL_TIMEOUT_MS = 5 * 6e4 + 15e3;
 var LP_DKG_ACTIVE_SESSION_RETRY_INTERVAL_MS = 2e3;
 var LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS = LP_DKG_COMPLETED_SHARD_POLL_TIMEOUT_MS;
 async function createLpDkgBatch(input) {
+  input.signal?.throwIfAborted();
   if (input.useDeterministicTestAddresses === true) {
     const addresses2 = Array.from(
       { length: input.count },
       (_, offset) => testAddress(input.lpPositionId, input.startIndex + offset)
     );
     for (const [offset, address] of addresses2.entries()) {
+      input.signal?.throwIfAborted();
       input.onProgress?.({
         completed: offset + 1,
         total: input.count,
         address
       });
     }
+    input.signal?.throwIfAborted();
     return addresses2;
   }
-  const workerCount = resolveConcurrency(input.count, input.concurrency);
+  const workerCount = resolveLpDkgConcurrency(input.count, input.concurrency);
+  const cancellation = new AbortController();
+  const cancel = () => cancellation.abort(input.signal?.reason);
+  input.signal?.addEventListener("abort", cancel, { once: true });
+  if (input.signal?.aborted) cancel();
   const workers = [];
   let workersTerminated = false;
   const terminateWorkers = () => {
@@ -1269,16 +1414,19 @@ async function createLpDkgBatch(input) {
   let nextOffset = 0;
   try {
     for (let index = 0; index < workerCount; index += 1) {
+      cancellation.signal.throwIfAborted();
       workers.push(createWorker(input.workerFactory));
     }
     await Promise.all(
       workers.map(async (worker) => {
         for (; ; ) {
+          cancellation.signal.throwIfAborted();
           const offset = nextOffset;
           nextOffset += 1;
           if (offset >= input.count) return;
           const index = input.startIndex + offset;
-          const address = await createLpDkgShard(input, worker, index);
+          const address = await createLpDkgShard(input, worker, index, cancellation.signal);
+          cancellation.signal.throwIfAborted();
           addresses[offset] = address;
           completed += 1;
           input.onProgress?.({
@@ -1291,12 +1439,14 @@ async function createLpDkgBatch(input) {
     );
     return addresses;
   } catch (error) {
+    cancellation.abort(error);
     terminateWorkers();
     if (!isLpDkgSessionCoordinationError(error)) {
       await abortDkgSessionsAfterFailure(input);
     }
     throw error;
   } finally {
+    input.signal?.removeEventListener("abort", cancel);
     terminateWorkers();
   }
 }
@@ -1320,61 +1470,82 @@ async function abortDkgSessionsAfterFailure(input) {
     if (timeoutId !== void 0) globalThis.clearTimeout(timeoutId);
   }
 }
-async function createLpDkgShard(input, worker, index) {
+async function createLpDkgShard(input, worker, index, signal) {
   const deadline = Date.now() + LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS;
   let sawActiveSession = false;
   for (; ; ) {
     if (sawActiveSession) {
-      const completedAddress = await getCompletedShardAddress(input, index);
+      const completedAddress = await getCompletedShardAddress(input, index, signal);
       if (completedAddress !== null) return completedAddress;
     }
     try {
-      return await runLpDkgShard(input, worker, index);
+      return await runLpDkgShard(input, worker, index, signal);
     } catch (error) {
       if (isLpDkgCompletedOrVisibleError(error)) {
-        return waitForCompletedShardAddress(input, index);
+        return waitForCompletedShardAddress(input, index, signal);
       }
       if (!isLpDkgActiveSessionError(error)) throw error;
       sawActiveSession = true;
-      const completedAddress = await getCompletedShardAddress(input, index);
+      const completedAddress = await getCompletedShardAddress(input, index, signal);
       if (completedAddress !== null) return completedAddress;
       if (Date.now() >= deadline) throw error;
-      await sleep(LP_DKG_ACTIVE_SESSION_RETRY_INTERVAL_MS);
+      await abortable(sleep(LP_DKG_ACTIVE_SESSION_RETRY_INTERVAL_MS), signal);
     }
   }
 }
-async function runLpDkgShard(input, worker, index) {
+async function runLpDkgShard(input, worker, index, signal) {
   const roundId = `lp_dkg_${Date.now()}_${index}_${Math.random().toString(16).slice(2)}`;
-  const initResponse = await input.client.initDkg(
-    { lpPositionId: input.lpPositionId, index },
-    input.auth
+  signal.throwIfAborted();
+  const initResponse = await abortable(
+    input.client.initDkg({ lpPositionId: input.lpPositionId, index }, input.auth, { signal }),
+    signal
   );
-  const round1 = await workerRequest(worker, {
-    id: roundId,
-    type: "round1"
-  });
-  if (round1.type !== "round1") throw new Error("LP DKG worker returned wrong round1 type");
-  const round1Response = await input.client.dkgRound1(
+  const round1 = await workerRequest(
+    worker,
     {
-      sessionId: initResponse.sessionId,
-      package: round1.package
+      id: roundId,
+      type: "round1"
     },
-    input.auth
+    signal
   );
-  const round2 = await workerRequest(worker, {
-    id: roundId,
-    type: "round2",
-    teeRound1: Array.from(round1Response.package),
-    teeRound2ForLp: Array.from(round1Response.round2ForLp)
-  });
-  if (round2.type !== "round2") throw new Error("LP DKG worker returned wrong round2 type");
-  const round2Response = await input.client.dkgRound2(
+  if (round1.type !== "round1")
+    throw lpDkgWorkerFailure(new Error("LP DKG worker returned wrong round1 type"));
+  signal.throwIfAborted();
+  const round1Response = await abortable(
+    input.client.dkgRound1(
+      {
+        sessionId: initResponse.sessionId,
+        package: round1.package
+      },
+      input.auth,
+      { signal }
+    ),
+    signal
+  );
+  const round2 = await workerRequest(
+    worker,
     {
-      sessionId: initResponse.sessionId,
-      package: round2.package,
-      delegatedShare: round2.delegatedShare
+      id: roundId,
+      type: "round2",
+      teeRound1: Array.from(round1Response.package),
+      teeRound2ForLp: Array.from(round1Response.round2ForLp)
     },
-    input.auth
+    signal
+  );
+  if (round2.type !== "round2")
+    throw lpDkgWorkerFailure(new Error("LP DKG worker returned wrong round2 type"));
+  signal.throwIfAborted();
+  const round2Response = await abortable(
+    input.client.dkgRound2(
+      {
+        sessionId: initResponse.sessionId,
+        package: round2.package,
+        delegatedShare: round2.delegatedShare
+      },
+      input.auth,
+      { signal }
+    ),
+    signal
   );
   if (!bytesEqual(Uint8Array.from(round2.jointPubkey), round2Response.jointPubkey)) {
     throw new Error(`LP DKG joint pubkey mismatch at index ${index}`);
@@ -1384,22 +1555,27 @@ async function runLpDkgShard(input, worker, index) {
   }
   return round2Response.address;
 }
-async function waitForCompletedShardAddress(input, index) {
+async function waitForCompletedShardAddress(input, index, signal) {
   const deadline = Date.now() + LP_DKG_COMPLETED_SHARD_POLL_TIMEOUT_MS;
   for (; ; ) {
-    const address = await getCompletedShardAddress(input, index);
+    const address = await getCompletedShardAddress(input, index, signal);
     if (address !== null) return address;
     if (Date.now() >= deadline) {
       throw new Error(`LP DKG completed shard ${index} did not become visible`);
     }
-    await sleep(LP_DKG_COMPLETED_SHARD_POLL_INTERVAL_MS);
+    await abortable(sleep(LP_DKG_COMPLETED_SHARD_POLL_INTERVAL_MS), signal);
   }
 }
-async function getCompletedShardAddress(input, index) {
-  const position = await input.client.getPosition(input.lpPositionId, input.auth);
+async function getCompletedShardAddress(input, index, signal) {
+  signal.throwIfAborted();
+  const position = await abortable(
+    input.client.getPosition(input.lpPositionId, input.auth, { signal }),
+    signal
+  );
   return position.shards.find((candidate) => candidate.index === index)?.address ?? null;
 }
-function workerRequest(worker, request2) {
+function workerRequest(worker, request2, signal) {
+  signal.throwIfAborted();
   return new Promise((resolve, reject) => {
     let timeoutId;
     const onMessage = (event) => {
@@ -1407,37 +1583,54 @@ function workerRequest(worker, request2) {
       if (message.id !== request2.id) return;
       cleanup();
       if (message.type === "error") {
-        reject(new Error(message.error));
+        reject(lpDkgWorkerFailure(message.error));
       } else {
         resolve(message);
       }
     };
     const onError = (event) => {
       cleanup();
-      reject(new Error(event.message));
+      reject(lpDkgWorkerFailure(new Error(event.message)));
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason);
     };
     const cleanup = () => {
+      signal.removeEventListener("abort", onAbort);
       if (timeoutId !== void 0) globalThis.clearTimeout(timeoutId);
       worker.removeEventListener("message", onMessage);
       worker.removeEventListener("error", onError);
     };
+    signal.addEventListener("abort", onAbort, { once: true });
     worker.addEventListener("message", onMessage);
     worker.addEventListener("error", onError);
     timeoutId = globalThis.setTimeout(() => {
       cleanup();
-      reject(new Error(LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE));
+      reject(lpDkgWorkerFailure(new Error(LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE)));
     }, LP_DKG_WORKER_REQUEST_TIMEOUT_MS);
     try {
       worker.postMessage(request2);
     } catch (error) {
       cleanup();
-      reject(error instanceof Error ? error : new Error(String(error)));
+      reject(lpDkgWorkerFailure(error));
     }
   });
 }
 function createWorker(workerFactory) {
-  if (workerFactory !== void 0) return workerFactory();
-  return new Worker(new URL("./dkgWorker.js", import.meta.url), { type: "module" });
+  try {
+    if (workerFactory !== void 0) return workerFactory();
+    return new Worker(new URL("./dkgWorker.js", import.meta.url), { type: "module" });
+  } catch (error) {
+    throw lpDkgWorkerFailure(error);
+  }
+}
+function lpDkgWorkerFailure(cause) {
+  return new LpLifecycleError(
+    "LP_DKG_WORKER_FAILED",
+    cause instanceof Error ? cause.message : typeof cause === "string" ? cause : LP_DKG_WORKER_FAILURE_MESSAGE,
+    { cause }
+  );
 }
 function bytesEqual(a, b) {
   if (a.byteLength !== b.byteLength) return false;
@@ -1461,12 +1654,20 @@ function isLpDkgIndexDriftError(error) {
 function isLpDkgSessionCoordinationError(error) {
   return isLpDkgActiveSessionError(error) || isLpDkgIndexDriftError(error);
 }
-function resolveConcurrency(count, requested) {
+function resolveLpDkgConcurrency(count, requested) {
   if (count <= 0) return 0;
   const concurrency = requested ?? DEFAULT_LP_DKG_CONCURRENCY;
   if (!Number.isFinite(concurrency)) return Math.min(count, DEFAULT_LP_DKG_CONCURRENCY);
   return Math.max(1, Math.min(count, MAX_LP_DKG_CONCURRENCY, Math.floor(concurrency)));
 }
+function abortable(promise, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    void promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
 function sleep(delayMs) {
   return new Promise((resolve) => {
     globalThis.setTimeout(resolve, delayMs);
@@ -1534,6 +1735,46 @@ function previewLpWithdrawalPlan(position, args = {}) {
     })
   };
 }
+var dkgAdmissions = /* @__PURE__ */ new WeakMap();
+var LP_DKG_BUSY_MESSAGE = "LP DKG session capacity is busy; wait for the active batch to finish";
+var LP_CLIENT_INVALIDATED_MESSAGE = "LP client invalidated by a reconnect capacity conflict; create a new LP lifecycle client and recover positions using their saved Position Codes";
+function getDkgAdmission(session) {
+  let admission = dkgAdmissions.get(session);
+  if (admission === void 0) {
+    admission = { reservations: /* @__PURE__ */ new Set() };
+    dkgAdmissions.set(session, admission);
+  }
+  while (admission.parent !== void 0) admission = admission.parent;
+  dkgAdmissions.set(session, admission);
+  return admission;
+}
+function assertDkgCapacity(reservations) {
+  let workerCount = 0;
+  const positions = /* @__PURE__ */ new Set();
+  for (const reservation of reservations) {
+    workerCount += reservation.workerCount;
+    if (positions.has(reservation.positionId) || workerCount > MAX_LP_DKG_CONCURRENCY) {
+      throw new LpLifecycleError("LP_DKG_BUSY", LP_DKG_BUSY_MESSAGE);
+    }
+    positions.add(reservation.positionId);
+  }
+}
+function reserveDkg(session, positionId, workerCount) {
+  const admission = getDkgAdmission(session);
+  const reservation = { positionId, workerCount };
+  assertDkgCapacity([...admission.reservations, reservation]);
+  admission.reservations.add(reservation);
+  return () => getDkgAdmission(session).reservations.delete(reservation);
+}
+function transferDkgAdmission(previousSession, nextSession) {
+  const previous = getDkgAdmission(previousSession);
+  const next = getDkgAdmission(nextSession);
+  if (previous === next) return;
+  assertDkgCapacity([...previous.reservations, ...next.reservations]);
+  for (const reservation of previous.reservations) next.reservations.add(reservation);
+  previous.reservations.clear();
+  previous.parent = next;
+}
 var lifecycleClients = /* @__PURE__ */ new WeakMap();
 function createLpLifecycleClient(session, runtime = {}) {
   const state = {
@@ -1542,21 +1783,40 @@ function createLpLifecycleClient(session, runtime = {}) {
     redemptions: /* @__PURE__ */ new Map(),
     topUps: /* @__PURE__ */ new Map()
   };
+  const cancellation = new AbortController();
+  const assertUsable = () => cancellation.signal.throwIfAborted();
   let currentSession = session;
   const reconnectSession = runtime.reconnectSession === void 0 ? void 0 : async () => {
     const nextSession = await runtime.reconnectSession();
+    assertUsable();
+    try {
+      transferDkgAdmission(currentSession, nextSession);
+    } catch (error) {
+      if (error instanceof LpLifecycleError && error.code === "LP_DKG_BUSY") {
+        const invalidated = new LpLifecycleError(
+          "LP_CLIENT_INVALIDATED",
+          LP_CLIENT_INVALIDATED_MESSAGE,
+          { cause: error }
+        );
+        cancellation.abort(invalidated);
+        throw invalidated;
+      }
+      throw error;
+    }
     currentSession = nextSession;
     return nextSession;
   };
-  const client = runtime.coordinatorClient ?? createLpCoordinatorClient(session, { reconnectSession });
+  const client = runtime.coordinatorClient ?? createLpCoordinatorClient(session, { reconnectSession, signal: cancellation.signal });
   const nowMs = runtime.nowMs ?? Date.now;
   const sleep2 = runtime.sleep ?? defaultSleep;
   const requireAuth = (positionId) => {
+    assertUsable();
     const auth = state.authByPosition.get(positionId);
     if (auth === void 0) throw new LpPositionAuthMissingError();
     return auth;
   };
   const rememberPosition = (position) => {
+    assertUsable();
     validateLpPositionFeePolicy(position, state.positions.get(position.id));
     const snapshot = clonePosition(position);
     const previous = state.positions.get(snapshot.id);
@@ -1573,6 +1833,7 @@ function createLpLifecycleClient(session, runtime = {}) {
     return merged;
   };
   const rememberAuth = (auth) => {
+    assertUsable();
     state.authByPosition.set(auth.lpPositionId, auth);
   };
   const refreshPosition2 = async (positionId) => {
@@ -1593,7 +1854,8 @@ function createLpLifecycleClient(session, runtime = {}) {
       }
     }
   };
-  const completeDkgBatch2 = async (positionId, options = {}) => {
+  const completeDkgBatch2 = async (positionId, options = {}, hasReservation = false) => {
+    assertUsable();
     assertAttested(currentSession);
     const auth = requireAuth(positionId);
     let activeSessionRetryStartedAtMs = null;
@@ -1603,10 +1865,16 @@ function createLpLifecycleClient(session, runtime = {}) {
       const startIndex = current.shards.length;
       const remaining = Math.min(current.targetShardCount - startIndex, LP_MAX_INITIAL_SHARDS);
       if (remaining <= 0) return current;
-      emitDkgProgress(options, current, startIndex, remaining, 0);
+      const release = hasReservation ? () => void 0 : reserveDkg(
+        currentSession,
+        positionId,
+        runtime.useDeterministicTestAddresses === true ? 0 : resolveLpDkgConcurrency(remaining, options.concurrency ?? runtime.dkgConcurrency)
+      );
       let expectedAddresses = null;
       try {
+        emitDkgProgress(options, current, startIndex, remaining, 0);
         const addresses = await createLpDkgBatch({
+          signal: cancellation.signal,
           lpPositionId: positionId,
           startIndex,
           count: remaining,
@@ -1619,6 +1887,7 @@ function createLpLifecycleClient(session, runtime = {}) {
             emitDkgProgress(options, current, startIndex, remaining, progress.completed);
           }
         });
+        assertUsable();
         expectedAddresses = addresses;
         const position = await client.finalizeDkgBatch(
           {
@@ -1635,6 +1904,7 @@ function createLpLifecycleClient(session, runtime = {}) {
         if (position.shards.length < position.targetShardCount) continue;
         return position;
       } catch (error) {
+        assertUsable();
         const reconciled = await tryRefreshCompletedDkgWindow({
           client,
           positionId,
@@ -1656,11 +1926,14 @@ function createLpLifecycleClient(session, runtime = {}) {
           throw error;
         }
         await sleep2(LP_DKG_ACTIVE_SESSION_RETRY_DELAY_MS);
+      } finally {
+        release();
       }
     }
   };
   return {
     async createPosition(args) {
+      assertUsable();
       assertNoUnsupportedFeePolicy(args.feePolicy);
       const shardCount = args.shardCount ?? LP_DEFAULT_TARGET_SHARDS;
       assertShardCount(shardCount, LP_MAX_INITIAL_SHARDS, "shardCount");
@@ -1702,6 +1975,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return { positionId, lpPositionCode: auth.code, position };
     },
     async recoverPosition(args) {
+      assertUsable();
       const auth = await deriveLpPositionCodeAuth(args.code);
       rememberAuth(auth);
       const position = rememberPosition(
@@ -1714,11 +1988,13 @@ function createLpLifecycleClient(session, runtime = {}) {
       return position;
     },
     confirmPositionCodeSaved(_positionId) {
+      assertUsable();
       return;
     },
     completeDkgBatch: completeDkgBatch2,
     refreshPosition: refreshPosition2,
     async refill(positionId, args = {}) {
+      assertUsable();
       const requestedShardCount = args.shardCount ?? LP_DEFAULT_REFILL_BATCH_SIZE;
       assertShardCount(requestedShardCount, LP_MAX_REFILL_BATCH_SIZE, "shardCount");
       assertAttested(currentSession);
@@ -1726,29 +2002,44 @@ function createLpLifecycleClient(session, runtime = {}) {
       const current = await refreshPosition2(positionId);
       args.onPosition?.(current);
       const refillShardCount = resolveLpRefillShardCount(current, requestedShardCount);
-      const authorizedPosition = rememberPosition(
-        await client.refillPosition(
+      const release = reserveDkg(
+        currentSession,
+        positionId,
+        runtime.useDeterministicTestAddresses === true ? 0 : resolveLpDkgConcurrency(refillShardCount, runtime.dkgConcurrency)
+      );
+      try {
+        const authorizedPosition = rememberPosition(
+          await client.refillPosition(
+            {
+              lpPositionId: positionId,
+              shardCount: refillShardCount,
+              shardAmountLamports: DEFAULT_SHARD_FUNDING_LAMPORTS,
+              addresses: [],
+              authorizedAtMs: nowMs()
+            },
+            auth
+          )
+        );
+        args.onPosition?.(authorizedPosition);
+        if (authorizedPosition.shards.length >= authorizedPosition.targetShardCount) {
+          return authorizedPosition;
+        }
+        return await completeDkgBatch2(
+          positionId,
           {
-            lpPositionId: positionId,
-            shardCount: refillShardCount,
-            shardAmountLamports: DEFAULT_SHARD_FUNDING_LAMPORTS,
-            addresses: [],
-            authorizedAtMs: nowMs()
+            onProgress: args.onProgress,
+            onPosition: args.onPosition,
+            workerFactory: args.workerFactory,
+            concurrency: resolveLpDkgConcurrency(refillShardCount, runtime.dkgConcurrency)
           },
-          auth
-        )
-      );
-      args.onPosition?.(authorizedPosition);
-      if (authorizedPosition.shards.length >= authorizedPosition.targetShardCount) {
-        return authorizedPosition;
+          true
+        );
+      } finally {
+        release();
       }
-      return completeDkgBatch2(positionId, {
-        onProgress: args.onProgress,
-        onPosition: args.onPosition,
-        workerFactory: args.workerFactory
-      });
     },
     async prepareInitialFunding(positionId) {
+      assertUsable();
       assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const currentPosition = rememberPosition(await client.getPosition(positionId, auth));
@@ -1778,6 +2069,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return fundingPlanFromShard(position, plannedShard);
     },
     async prepareTopUp(positionId) {
+      assertUsable();
       assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const request2 = await client.prepareTopUp(positionId, auth);
@@ -1785,6 +2077,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return request2;
     },
     async waitForTopUp(topUpId, options = {}) {
+      assertUsable();
       const cached = state.topUps.get(topUpId);
       if (cached !== void 0 && options.positionId !== void 0 && cached.positionId !== options.positionId) {
         throw new PolicyValidationError(
@@ -1826,11 +2119,13 @@ function createLpLifecycleClient(session, runtime = {}) {
       }
     },
     async reconcileFunding(positionId) {
+      assertUsable();
       assertAttested(currentSession);
       const auth = requireAuth(positionId);
       return rememberPosition(await client.reconcileFunding(positionId, auth));
     },
     async withdrawPosition(positionId, args) {
+      assertUsable();
       validateExplicitWithdrawalInput(args);
       validateWithdrawalDestinations(args);
       assertAttested(currentSession);
@@ -1923,6 +2218,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return { execution, position, redemption };
     },
     async waitForWithdrawalConfirmation(positionId, execution, options = {}) {
+      assertUsable();
       const auth = requireAuth(positionId);
       let record = resolveWithdrawalRecord({
         state,
@@ -1979,6 +2275,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       }
     },
     async withdrawFees(_positionId, args) {
+      assertUsable();
       publicKey(args.destination);
       assertAttested(currentSession);
       throw new RoutingError(
@@ -1987,6 +2284,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       );
     },
     async listPositions() {
+      assertUsable();
       return [...state.positions.values()].map(clonePosition);
     }
   };