@invisible-labs/sdk 0.6.0-devnet.4 → 0.6.0-devnet.5

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-4X5OCCQW.js';
-import { publicKey, assertAttested, lamports } from './chunk-NHEHCUS5.js';
-import { requestEnvelope } from './chunk-UADJCUPK.js';
-import { getSessionState } from './chunk-V5HXJRBW.js';
-import { CommandError, PolicyValidationError, TransportError, RoutingError, LpLifecycleError } from './chunk-GHBQF3A7.js';
+import { publicKey, assertAttested, lamports } from './chunk-EBWTAXNT.js';
+import { requestEnvelope, CoordinatorMessageType } from './chunk-3MDHAS4D.js';
+import { getSessionState } from './chunk-HJFMDMPY.js';
+import { CommandError, WalletError, TransportError, PolicyValidationError, RoutingError, LpLifecycleError } from './chunk-QRN46R3F.js';
 import './chunk-VR6T6OJS.js';
 
 // src/lp/positionCode.ts
@@ -228,59 +228,206 @@ function validateDestinationAddresses(destinationAddresses) {
 
 // src/lp/coordinatorClient.ts
 var COMMAND_TTL_MS = 3e4;
-var LP_COMMAND_REQUEST_TIMEOUT_MS = 12e4;
+var LP_POSITION_OPEN_COMMAND_TTL_MS = 55e3;
+var LP_POSITION_OPEN_REQUEST_TIMEOUT_MS = 2e4;
+var LP_COMMAND_REQUEST_TIMEOUT_MS = COMMAND_TTL_MS;
+var LP_CREATION_CHALLENGE_REQUEST_TIMEOUT_MS = 3e4;
+var LP_CREATION_WALLET_SIGNATURE_TIMEOUT_MS = 45e3;
+var LP_CREATION_PROOF_REQUEST_TIMEOUT_MS = 15e3;
+var LP_CREATION_PROOF_RETRY_TIMEOUT_MS = 15e3;
+var LP_CREATION_AUTHORIZATION_MARGIN_MS = 15e3;
+var LP_CREATION_MIN_STEP_TIMEOUT_MS = 1;
 var LP_DKG_ABORT_REQUEST_TIMEOUT_MS = 1e4;
 var encoder2 = new TextEncoder();
 var protocolPromise = null;
-function createLpCoordinatorClient(session) {
+function createLpCoordinatorClient(session, options = {}) {
+  const sessionRef = { current: session };
+  const reconnectSession = options.reconnectSession === void 0 ? void 0 : async () => {
+    const nextSession = await options.reconnectSession();
+    sessionRef.current = nextSession;
+    return nextSession;
+  };
   return {
+    authorizePositionCreation(intent, signer) {
+      return authorizePositionCreation(sessionRef.current, intent, signer);
+    },
     initDkg(input, auth) {
-      return initDkg(session, input, auth);
+      return initDkg(sessionRef.current, input, auth);
     },
     abortDkgSessions(lpPositionId, auth) {
-      return abortDkgSessions(session, lpPositionId, auth);
+      return abortDkgSessions(sessionRef.current, lpPositionId, auth);
     },
     dkgRound1(input, auth) {
-      return dkgRound1(session, input, auth);
+      return dkgRound1(sessionRef.current, input, auth);
     },
     dkgRound2(input, auth) {
-      return dkgRound2(session, input, auth);
+      return dkgRound2(sessionRef.current, input, auth);
     },
     openPosition(input, auth) {
-      return openPosition(session, input, auth);
+      return openPosition(sessionRef.current, input, auth, reconnectSession);
     },
-    getPosition(lpPositionId, auth, options) {
-      return getPosition(session, lpPositionId, auth, options);
+    getPosition(lpPositionId, auth, options2) {
+      return getPosition(sessionRef.current, lpPositionId, auth, options2);
     },
     finalizeDkgBatch(input, auth) {
-      return finalizeDkgBatch(session, input, auth);
+      return finalizeDkgBatch(sessionRef.current, input, auth);
     },
     refillPosition(input, auth) {
-      return refillPosition(session, input, auth);
+      return refillPosition(sessionRef.current, input, auth);
     },
     reconcileFunding(lpPositionId, auth) {
-      return reconcileFunding(session, lpPositionId, auth);
+      return reconcileFunding(sessionRef.current, lpPositionId, auth);
     },
     planFunding(input, auth) {
-      return planFunding(session, input, auth);
+      return planFunding(sessionRef.current, input, auth);
     },
     confirmFunding(input, auth) {
-      return confirmFunding(session, input, auth);
+      return confirmFunding(sessionRef.current, input, auth);
     },
     prepareTopUp(lpPositionId, auth) {
-      return prepareTopUp(session, lpPositionId, auth);
+      return prepareTopUp(sessionRef.current, lpPositionId, auth);
     },
     getTopUpStatus(input, auth) {
-      return getTopUpStatus(session, input, auth);
+      return getTopUpStatus(sessionRef.current, input, auth);
     },
     makeAvailable(input, auth) {
-      return makeAvailable(session, input, auth);
+      return makeAvailable(sessionRef.current, input, auth);
     },
     executeWithdrawal(input, auth) {
-      return executeWithdrawal(session, input, auth);
+      return executeWithdrawal(sessionRef.current, input, auth);
     }
   };
 }
+async function authorizePositionCreation(session, intent, signer) {
+  const signerPublicKey = publicKey(signer.publicKey);
+  const challengeRequestStartedAtMs = Date.now();
+  const challengeEnvelope = await requestEnvelope(
+    session,
+    CoordinatorMessageType.LpCreateAuthorization,
+    {
+      case: "challenge",
+      value: {
+        public_key: signerPublicKey,
+        intent: {
+          committed_lamports: intent.committedLamports,
+          shard_count: intent.shardCount,
+          shard_amount_lamports: intent.shardAmountLamports,
+          refill_threshold: intent.refillThreshold
+        }
+      }
+    },
+    { timeoutMs: LP_CREATION_CHALLENGE_REQUEST_TIMEOUT_MS }
+  );
+  const challenge = challengeEnvelope.payload;
+  if (challenge.case !== "challenge") {
+    throw new CommandError(
+      "REJECTED_STATE",
+      "Coordinator returned an unexpected LP creation authorization response"
+    );
+  }
+  const localAuthorizationDeadlineMs = challengeRequestStartedAtMs + challenge.value.valid_for_ms;
+  const walletTimeoutMs = lpCreationAuthorizationStepTimeout(
+    localAuthorizationDeadlineMs,
+    LP_CREATION_PROOF_REQUEST_TIMEOUT_MS + LP_CREATION_PROOF_RETRY_TIMEOUT_MS + LP_CREATION_AUTHORIZATION_MARGIN_MS,
+    LP_CREATION_WALLET_SIGNATURE_TIMEOUT_MS
+  );
+  const signature = await signLpCreationMessageWithTimeout(
+    signer,
+    encoder2.encode(challenge.value.message),
+    walletTimeoutMs
+  );
+  if (!(signature instanceof Uint8Array) || signature.length !== 64) {
+    throw new WalletError(
+      "WALLET_INVALID_SIGNATURE",
+      "Solana wallet returned an invalid LP creation signature"
+    );
+  }
+  const proofPayload = {
+    case: "proof",
+    value: {
+      authorization_id: challenge.value.authorization_id,
+      public_key: signerPublicKey,
+      message: challenge.value.message,
+      signature
+    }
+  };
+  let proofEnvelope;
+  try {
+    const proofTimeoutMs = lpCreationAuthorizationStepTimeout(
+      localAuthorizationDeadlineMs,
+      LP_CREATION_PROOF_RETRY_TIMEOUT_MS + LP_CREATION_AUTHORIZATION_MARGIN_MS,
+      LP_CREATION_PROOF_REQUEST_TIMEOUT_MS
+    );
+    proofEnvelope = await requestEnvelope(
+      session,
+      CoordinatorMessageType.LpCreateAuthorization,
+      proofPayload,
+      { timeoutMs: proofTimeoutMs }
+    );
+  } catch (error) {
+    if (!isAmbiguousCoordinatorRequestFailure(error)) throw error;
+    const proofRetryTimeoutMs = lpCreationAuthorizationStepTimeout(
+      localAuthorizationDeadlineMs,
+      LP_CREATION_AUTHORIZATION_MARGIN_MS,
+      LP_CREATION_PROOF_RETRY_TIMEOUT_MS
+    );
+    proofEnvelope = await requestEnvelope(
+      session,
+      CoordinatorMessageType.LpCreateAuthorization,
+      proofPayload,
+      { timeoutMs: proofRetryTimeoutMs }
+    );
+  }
+  const authorization = proofEnvelope.payload;
+  if (authorization.case !== "authorized") {
+    throw new CommandError(
+      "REJECTED_STATE",
+      "Coordinator returned an unexpected LP creation authorization proof response"
+    );
+  }
+  if (authorization.value.authorization_id !== challenge.value.authorization_id) {
+    throw new CommandError(
+      "REJECTED_STATE",
+      "Coordinator returned an LP creation authorization for a different challenge"
+    );
+  }
+  lpCreationAuthorizationStepTimeout(
+    localAuthorizationDeadlineMs,
+    LP_CREATION_AUTHORIZATION_MARGIN_MS,
+    LP_CREATION_MIN_STEP_TIMEOUT_MS
+  );
+  return { authorizationId: authorization.value.authorization_id };
+}
+function lpCreationAuthorizationStepTimeout(localDeadlineMs, reservedMs, maximumTimeoutMs) {
+  const availableMs = localDeadlineMs - Date.now() - reservedMs;
+  if (availableMs < LP_CREATION_MIN_STEP_TIMEOUT_MS) {
+    throw new CommandError(
+      "REJECTED_EXPIRED",
+      "LP creation authorization expired; request a fresh coordinator challenge"
+    );
+  }
+  return Math.min(availableMs, maximumTimeoutMs);
+}
+async function signLpCreationMessageWithTimeout(signer, message, timeoutMs) {
+  let timeoutId;
+  try {
+    return await Promise.race([
+      signer.signMessage(message),
+      new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(
+            new WalletError(
+              "WALLET_USER_REJECTED",
+              "Solana wallet did not sign the LP creation challenge before it expired"
+            )
+          );
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeoutId !== void 0) clearTimeout(timeoutId);
+  }
+}
 async function initDkg(session, input, auth) {
   const response = await requestForPosition(session, input.lpPositionId, auth, "dkg_init", {
     case: "dkgInit",
@@ -335,10 +482,11 @@ async function dkgRound2(session, input, auth) {
     index: response.value.index
   };
 }
-async function openPosition(session, input, auth) {
-  const response = await requestForPosition(session, input.lpPositionId, auth, "position_open", {
+async function openPosition(session, input, auth, reconnectSession) {
+  const payload = {
     case: "positionOpen",
     value: {
+      creation_authorization_id: input.creationAuthorizationId,
       auth_public_key: Uint8Array.from(input.authPublicKey),
       refill_public_key: Uint8Array.from(input.refillPublicKey),
       redemption_commitment: Uint8Array.from(input.withdrawalCommitment),
@@ -349,9 +497,69 @@ async function openPosition(session, input, auth) {
       addresses: input.addresses,
       created_at_ms: input.createdAtMs
     }
-  });
+  };
+  const commandDeadlineMs = Date.now() + LP_POSITION_OPEN_COMMAND_TTL_MS;
+  const commandOptions = {
+    commandNonce: randomBytes(32),
+    commandExpiresAtMs: commandDeadlineMs,
+    deadlineMs: commandDeadlineMs,
+    timeoutMs: LP_POSITION_OPEN_REQUEST_TIMEOUT_MS
+  };
+  let response;
+  try {
+    response = await requestForPosition(
+      session,
+      input.lpPositionId,
+      auth,
+      "position_open",
+      payload,
+      commandOptions
+    );
+  } catch (error) {
+    if (!isAmbiguousLpPositionOpenFailure(error)) throw error;
+    const replaySession = reconnectSession === void 0 ? session : await reconnectSessionWithinDeadline(reconnectSession, commandDeadlineMs);
+    response = await requestForPosition(
+      replaySession,
+      input.lpPositionId,
+      auth,
+      "position_open",
+      payload,
+      commandOptions
+    );
+  }
   return expectPosition(response);
 }
+async function reconnectSessionWithinDeadline(reconnectSession, deadlineMs) {
+  const remainingMs = deadlineMs - Date.now();
+  if (remainingMs <= 0) {
+    throw new CommandError(
+      "REJECTED_EXPIRED",
+      "LP position-open command expired before coordinator reconnect"
+    );
+  }
+  let timer;
+  try {
+    return await new Promise((resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new CommandError(
+            "REJECTED_EXPIRED",
+            "LP position-open command expired during coordinator reconnect"
+          )
+        );
+      }, remainingMs);
+      Promise.resolve().then(reconnectSession).then(resolve, reject);
+    });
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function isAmbiguousLpPositionOpenFailure(error) {
+  return isAmbiguousCoordinatorRequestFailure(error);
+}
+function isAmbiguousCoordinatorRequestFailure(error) {
+  return error instanceof TransportError || error instanceof CommandError && error.code === "REJECTED_STALE_JOB";
+}
 async function getPosition(session, lpPositionId, auth, options = {}) {
   let cursor;
   let position;
@@ -541,8 +749,8 @@ async function requestForPosition(session, lpPositionId, auth, action, payload,
   const command = {
     lp_position_id: lpPositionId,
     action,
-    nonce: randomBytes(32),
-    expires_at_ms: Date.now() + Math.min(COMMAND_TTL_MS, timeoutMs),
+    nonce: options.commandNonce === void 0 ? randomBytes(32) : new Uint8Array(options.commandNonce),
+    expires_at_ms: options.commandExpiresAtMs ?? Date.now() + Math.min(COMMAND_TTL_MS, timeoutMs),
     coordinator_attestation_hash: await coordinatorAttestationHash(
       attestation.binaryHash,
       attestation.pubkeyHex
@@ -582,9 +790,20 @@ function mapPosition(position) {
     refillThreshold: position.refill_threshold,
     shards: position.shards.map(mapShard),
     createdAt: position.created_at_ms,
+    redemptionPermission: mapLpRedemptionPermission(position.redemption_permission),
     ...position.actor_sync === void 0 ? {} : { actorSync: mapLpActorSync(position.actor_sync) }
   };
 }
+function mapLpRedemptionPermission(permission) {
+  if (permission === void 0) {
+    return { state: "unknown", grantRevision: 0, observedAtMs: 0 };
+  }
+  return {
+    state: permission.state,
+    grantRevision: permission.grant_revision,
+    observedAtMs: permission.observed_at_ms
+  };
+}
 function mapLpActorSync(actorSync) {
   const redeemableBucketValues = [
     actorSync.redeemable_principal_lamports,
@@ -736,7 +955,7 @@ function randomBytes(length) {
   return bytes;
 }
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-ZNLGAYXD.js');
+  protocolPromise ??= import('./coordinator-PEWHNZ7I.js');
   return protocolPromise;
 }
 
@@ -1011,6 +1230,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_REDEMPTION_PERMISSION_UNAVAILABLE_MESSAGE = "LP redemption is unavailable until the coordinator confirms permission";
 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 LP_FEE_SOURCE_COUNT_UNAVAILABLE_MESSAGE = "LP earned-fee source count is not available; pass allowManyToOne: true to acknowledge many-to-one withdrawal risk";
@@ -1050,7 +1270,13 @@ function createLpLifecycleClient(session, runtime = {}) {
     redemptions: /* @__PURE__ */ new Map(),
     topUps: /* @__PURE__ */ new Map()
   };
-  const client = runtime.coordinatorClient ?? createLpCoordinatorClient(session);
+  let currentSession = session;
+  const reconnectSession = runtime.reconnectSession === void 0 ? void 0 : async () => {
+    const nextSession = await runtime.reconnectSession();
+    currentSession = nextSession;
+    return nextSession;
+  };
+  const client = runtime.coordinatorClient ?? createLpCoordinatorClient(session, { reconnectSession });
   const nowMs = runtime.nowMs ?? Date.now;
   const sleep2 = runtime.sleep ?? defaultSleep;
   const requireAuth = (positionId) => {
@@ -1060,9 +1286,17 @@ function createLpLifecycleClient(session, runtime = {}) {
   };
   const rememberPosition = (position) => {
     const snapshot = clonePosition(position);
-    state.positions.set(snapshot.id, snapshot);
-    hydrateLpRedemptionsFromPosition(state, snapshot);
-    return position;
+    const previous = state.positions.get(snapshot.id);
+    const merged = previous === void 0 ? snapshot : {
+      ...snapshot,
+      redemptionPermission: mergeLpRedemptionPermission(
+        previous.redemptionPermission,
+        snapshot.redemptionPermission
+      )
+    };
+    state.positions.set(merged.id, merged);
+    hydrateLpRedemptionsFromPosition(state, merged);
+    return merged;
   };
   const rememberAuth = (auth) => {
     state.authByPosition.set(auth.lpPositionId, auth);
@@ -1086,7 +1320,7 @@ function createLpLifecycleClient(session, runtime = {}) {
     }
   };
   const completeDkgBatch2 = async (positionId, options = {}) => {
-    assertAttested(session);
+    assertAttested(currentSession);
     const auth = requireAuth(positionId);
     let activeSessionRetryStartedAtMs = null;
     for (; ; ) {
@@ -1150,33 +1384,44 @@ function createLpLifecycleClient(session, runtime = {}) {
     }
   };
   return {
-    async createPosition(args = {}) {
+    async createPosition(args) {
       assertNoUnsupportedFeePolicy(args.feePolicy);
       const shardCount = args.shardCount ?? LP_DEFAULT_TARGET_SHARDS;
       assertShardCount(shardCount, LP_MAX_TARGET_SHARDS, "shardCount");
-      assertAttested(session);
+      assertAttested(currentSession);
+      const committedLamports = args.committedLamports ?? DEFAULT_SHARD_FUNDING_LAMPORTS;
+      const refillThreshold = args.refillThreshold ?? Math.ceil(shardCount * DEFAULT_REFILL_THRESHOLD_RATIO);
+      const creationAuthorization = await client.authorizePositionCreation(
+        {
+          committedLamports,
+          shardCount,
+          shardAmountLamports: DEFAULT_SHARD_FUNDING_LAMPORTS,
+          refillThreshold
+        },
+        args.wallet
+      );
       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,
+            creationAuthorizationId: creationAuthorization.authorizationId,
             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),
+            refillThreshold,
             addresses: [],
             createdAtMs: nowMs()
           },
           auth
         )
       );
+      args.onPositionCode?.({ positionId, lpPositionCode: auth.code });
       return { positionId, lpPositionCode: auth.code, position };
     },
     async recoverPosition(args) {
@@ -1199,7 +1444,7 @@ function createLpLifecycleClient(session, runtime = {}) {
     async refill(positionId, args = {}) {
       const requestedShardCount = args.shardCount ?? LP_DEFAULT_REFILL_BATCH_SIZE;
       assertShardCount(requestedShardCount, LP_MAX_REFILL_BATCH_SIZE, "shardCount");
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const current = await refreshPosition2(positionId);
       args.onPosition?.(current);
@@ -1231,7 +1476,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       });
     },
     async prepareInitialFunding(positionId) {
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const currentPosition = rememberPosition(await client.getPosition(positionId, auth));
       if (!isLpPositionReadyForInitialFunding(currentPosition)) return null;
@@ -1260,7 +1505,7 @@ function createLpLifecycleClient(session, runtime = {}) {
       return fundingPlanFromShard(position, plannedShard);
     },
     async prepareTopUp(positionId) {
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const request2 = await client.prepareTopUp(positionId, auth);
       state.topUps.set(request2.topUpId, request2);
@@ -1308,16 +1553,22 @@ function createLpLifecycleClient(session, runtime = {}) {
       }
     },
     async reconcileFunding(positionId) {
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       return rememberPosition(await client.reconcileFunding(positionId, auth));
     },
     async withdrawPosition(positionId, args) {
       validateExplicitWithdrawalInput(args);
       validateWithdrawalDestinations(args);
-      assertAttested(session);
+      assertAttested(currentSession);
       const auth = requireAuth(positionId);
       const before = rememberPosition(await client.reconcileFunding(positionId, auth));
+      if (before.redemptionPermission?.state !== "enabled") {
+        throw new PolicyValidationError(
+          "INVALID_REDEMPTION_PLAN",
+          LP_REDEMPTION_PERMISSION_UNAVAILABLE_MESSAGE
+        );
+      }
       const existingRedemption = findOpenRedemptionHistory(before, args);
       if (existingRedemption !== void 0) {
         const execution2 = {
@@ -1452,7 +1703,7 @@ function createLpLifecycleClient(session, runtime = {}) {
     },
     async withdrawFees(_positionId, args) {
       publicKey(args.destination);
-      assertAttested(session);
+      assertAttested(currentSession);
       throw new RoutingError(
         "VERSION_NOT_SUPPORTED",
         "LP fee withdrawal is not advertised by the coordinator"
@@ -1841,6 +2092,15 @@ function clonePosition(position) {
     }
   };
 }
+function mergeLpRedemptionPermission(existing, next) {
+  const current = existing ?? { state: "unknown", grantRevision: 0, observedAtMs: 0 };
+  const incoming = next ?? { state: "unknown", grantRevision: 0, observedAtMs: 0 };
+  if (incoming.state === "unknown") return incoming;
+  if (current.state === "enabled" && incoming.state !== "enabled") return current;
+  if (incoming.grantRevision > current.grantRevision) return incoming;
+  if (incoming.grantRevision < current.grantRevision) return current;
+  return incoming.observedAtMs > current.observedAtMs ? incoming : current;
+}
 function generateId(prefix) {
   return `${prefix}_${Array.from(randomBytes2(8)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
@@ -1884,7 +2144,7 @@ function defaultSleep(delayMs) {
 }
 
 // src/lp/index.ts
-function createPosition(session, args = {}) {
+function createPosition(session, args) {
   return defaultLpLifecycleClient(session).createPosition(args);
 }
 function recoverPosition(session, args) {