@invisible-labs/sdk 0.6.0-devnet.1 → 0.6.0-devnet.3

package/dist/lp.js

@@ -1,8 +1,8 @@
-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 { isValidLpPositionId, LP_DEFAULT_REFILL_BATCH_SIZE, LP_DEFAULT_TARGET_SHARDS, LP_MAX_TARGET_SHARDS, LP_MAX_REFILL_BATCH_SIZE } from './chunk-4X5OCCQW.js';
+import { publicKey, assertAttested, lamports } from './chunk-NHEHCUS5.js';
+import { requestEnvelope } from './chunk-QQSI3ZD7.js';
+import { getSessionState } from './chunk-V5HXJRBW.js';
+import { CommandError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-GHBQF3A7.js';
 import './chunk-VR6T6OJS.js';
 
 // src/lp/positionCode.ts
@@ -225,6 +225,7 @@ function validateDestinationAddresses(destinationAddresses) {
 // src/lp/coordinatorClient.ts
 var COMMAND_TTL_MS = 3e4;
 var LP_COMMAND_REQUEST_TIMEOUT_MS = 12e4;
+var LP_DKG_ABORT_REQUEST_TIMEOUT_MS = 1e4;
 var encoder2 = new TextEncoder();
 var protocolPromise = null;
 function createLpCoordinatorClient(session) {
@@ -232,6 +233,9 @@ function createLpCoordinatorClient(session) {
     initDkg(input, auth) {
       return initDkg(session, input, auth);
     },
+    abortDkgSessions(lpPositionId, auth) {
+      return abortDkgSessions(session, lpPositionId, auth);
+    },
     dkgRound1(input, auth) {
       return dkgRound1(session, input, auth);
     },
@@ -281,6 +285,21 @@ async function initDkg(session, input, auth) {
   if (response.case !== "dkgInit") throw new Error("Unexpected LP DKG init response");
   return { sessionId: response.value.session_id };
 }
+async function abortDkgSessions(session, lpPositionId, auth) {
+  const response = await requestForPosition(
+    session,
+    lpPositionId,
+    auth,
+    "dkg_abort",
+    {
+      case: "dkgAbort",
+      value: {}
+    },
+    LP_DKG_ABORT_REQUEST_TIMEOUT_MS
+  );
+  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",
@@ -466,7 +485,7 @@ async function executeWithdrawal(session, input, auth) {
 function request(session, auth, action, payload) {
   return requestForPosition(session, auth.lpPositionId, auth, action, payload);
 }
-async function requestForPosition(session, lpPositionId, auth, action, payload) {
+async function requestForPosition(session, lpPositionId, auth, action, payload, timeoutMs = LP_COMMAND_REQUEST_TIMEOUT_MS) {
   assertAuthMatchesPosition(lpPositionId, auth);
   const protocol = await loadProtocol();
   const state = getSessionState(session);
@@ -476,7 +495,7 @@ async function requestForPosition(session, lpPositionId, auth, action, payload)
     lp_position_id: lpPositionId,
     action,
     nonce: randomBytes(32),
-    expires_at_ms: Date.now() + COMMAND_TTL_MS,
+    expires_at_ms: Date.now() + Math.min(COMMAND_TTL_MS, timeoutMs),
     coordinator_attestation_hash: await coordinatorAttestationHash(
       attestation.binaryHash,
       attestation.pubkeyHex
@@ -486,7 +505,7 @@ async function requestForPosition(session, lpPositionId, auth, action, 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
+    timeoutMs
   });
   return protocol.asLpCommandResponsePayload(envelope);
 }
@@ -666,13 +685,17 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-7Y45MCCZ.js');
+  protocolPromise ??= import('./coordinator-VVJ33WF2.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_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;
+var LP_DKG_ABORT_CLEANUP_TIMEOUT_MESSAGE = "LP DKG session cleanup timed out";
 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;
@@ -693,11 +716,20 @@ async function createLpDkgBatch(input) {
     return addresses2;
   }
   const workerCount = resolveConcurrency(input.count, input.concurrency);
-  const workers = Array.from({ length: workerCount }, () => createWorker(input.workerFactory));
+  const workers = [];
+  let workersTerminated = false;
+  const terminateWorkers = () => {
+    if (workersTerminated) return;
+    workersTerminated = true;
+    workers.forEach((worker) => worker.terminate());
+  };
   const addresses = new Array(input.count);
   let completed = 0;
   let nextOffset = 0;
   try {
+    for (let index = 0; index < workerCount; index += 1) {
+      workers.push(createWorker(input.workerFactory));
+    }
     await Promise.all(
       workers.map(async (worker) => {
         for (; ; ) {
@@ -717,8 +749,34 @@ async function createLpDkgBatch(input) {
       })
     );
     return addresses;
+  } catch (error) {
+    terminateWorkers();
+    if (!isLpDkgSessionCoordinationError(error)) {
+      await abortDkgSessionsAfterFailure(input);
+    }
+    throw error;
   } finally {
-    workers.forEach((worker) => worker.terminate());
+    terminateWorkers();
+  }
+}
+async function abortDkgSessionsAfterFailure(input) {
+  const abortDkgSessions2 = input.client.abortDkgSessions;
+  if (typeof abortDkgSessions2 !== "function") return;
+  let timeoutId;
+  try {
+    const cleanupTimeout = new Promise((_, reject) => {
+      timeoutId = globalThis.setTimeout(
+        () => reject(new Error(LP_DKG_ABORT_CLEANUP_TIMEOUT_MESSAGE)),
+        LP_DKG_ABORT_CLEANUP_TIMEOUT_MS
+      );
+    });
+    await Promise.race([
+      abortDkgSessions2.call(input.client, input.lpPositionId, input.auth),
+      cleanupTimeout
+    ]);
+  } catch {
+  } finally {
+    if (timeoutId !== void 0) globalThis.clearTimeout(timeoutId);
   }
 }
 async function createLpDkgShard(input, worker, index) {
@@ -802,6 +860,7 @@ async function getCompletedShardAddress(input, index) {
 }
 function workerRequest(worker, request2) {
   return new Promise((resolve, reject) => {
+    let timeoutId;
     const onMessage = (event) => {
       const message = event.data;
       if (message.id !== request2.id) return;
@@ -817,12 +876,22 @@ function workerRequest(worker, request2) {
       reject(new Error(event.message));
     };
     const cleanup = () => {
+      if (timeoutId !== void 0) globalThis.clearTimeout(timeoutId);
       worker.removeEventListener("message", onMessage);
       worker.removeEventListener("error", onError);
     };
     worker.addEventListener("message", onMessage);
     worker.addEventListener("error", onError);
-    worker.postMessage(request2);
+    timeoutId = globalThis.setTimeout(() => {
+      cleanup();
+      reject(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)));
+    }
   });
 }
 function createWorker(workerFactory) {
@@ -844,6 +913,13 @@ function isLpDkgCompletedOrVisibleError(error) {
 function isLpDkgActiveSessionError(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 isLpDkgSessionCoordinationError(error) {
+  return isLpDkgActiveSessionError(error) || isLpDkgIndexDriftError(error);
+}
 function resolveConcurrency(count, requested) {
   if (count <= 0) return 0;
   const concurrency = requested ?? DEFAULT_LP_DKG_CONCURRENCY;
@@ -867,6 +943,8 @@ 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_WITHDRAWAL_READINESS_RETRY_DELAY_MS = 1e3;
+var LP_WITHDRAWAL_READINESS_RETRY_ATTEMPTS = 30;
 var LP_TOP_UP_WAIT_POLL_INTERVAL_MS = 1e3;
 var LP_REDEMPTION_HISTORY_OPEN_STATES = /* @__PURE__ */ new Set([
   "requested",
@@ -882,6 +960,7 @@ 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 LP_WITHDRAWAL_UNRESOLVED_FUNDING_MESSAGE = "LP position has unresolved funding shards before redemption";
 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 {
@@ -931,6 +1010,20 @@ function createLpLifecycleClient(session, runtime = {}) {
     const auth = requireAuth(positionId);
     return rememberPosition(await client.getPosition(positionId, auth));
   };
+  const executeWithdrawalAfterFundingReadiness = async (positionId, input, auth) => {
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await client.executeWithdrawal(input, auth);
+      } catch (error) {
+        const retryable = error instanceof CommandError && error.message.includes(LP_WITHDRAWAL_UNRESOLVED_FUNDING_MESSAGE);
+        if (!retryable || attempt >= LP_WITHDRAWAL_READINESS_RETRY_ATTEMPTS - 1) {
+          throw error;
+        }
+        await sleep2(LP_WITHDRAWAL_READINESS_RETRY_DELAY_MS);
+        await client.reconcileFunding(positionId, auth).catch(() => void 0);
+      }
+    }
+  };
   const completeDkgBatch2 = async (positionId, options = {}) => {
     assertAttested(session);
     const auth = requireAuth(positionId);
@@ -985,7 +1078,7 @@ function createLpLifecycleClient(session, runtime = {}) {
           activeSessionRetryStartedAtMs = null;
           continue;
         }
-        if (!isLpDkgActiveSessionError2(error)) throw error;
+        if (!isLpDkgActiveSessionError(error)) throw error;
         const currentTime = nowMs();
         activeSessionRetryStartedAtMs ??= currentTime;
         if (currentTime - activeSessionRetryStartedAtMs >= LP_DKG_ACTIVE_SESSION_RETRY_TIMEOUT_MS2) {
@@ -1198,7 +1291,8 @@ function createLpLifecycleClient(session, runtime = {}) {
         sourceCount
       };
       validateLpWithdrawalPlan(validationInput);
-      const execution = await client.executeWithdrawal(
+      const execution = await executeWithdrawalAfterFundingReadiness(
+        positionId,
         {
           lpPositionId: validationInput.lpPositionId,
           destinationAddresses: validationInput.destinationAddresses,
@@ -1617,13 +1711,6 @@ function sameStringList(left, right) {
 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,
@@ -1706,6 +1793,6 @@ 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 };
+export { LP_COMMAND_REQUEST_TIMEOUT_MS, LP_DKG_ABORT_CLEANUP_TIMEOUT_MS, LP_DKG_ABORT_REQUEST_TIMEOUT_MS, LP_DKG_WORKER_REQUEST_TIMEOUT_MESSAGE, LP_DKG_WORKER_REQUEST_TIMEOUT_MS, LP_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