@coinlist-co/react 0.12.2-rc.7b430dd → 0.12.2-rc.9fb6364

package/dist/server/index.cjs

@@ -20,7 +20,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/server/index.ts
 var server_exports = {};
 __export(server_exports, {
-  ServerAuthNamespaceImpl: () => ServerAuthNamespaceImpl,
   ServerOffersNamespaceImpl: () => ServerOffersNamespaceImpl,
   ServerRequirementsNamespaceImpl: () => ServerRequirementsNamespaceImpl,
   WritableSessionStoreRequiredError: () => WritableSessionStoreRequiredError,
@@ -30,6 +29,30 @@ __export(server_exports, {
 });
 module.exports = __toCommonJS(server_exports);
 
+// src/universal/api/internal-access-token-source.ts
+var SentWith = {
+  userToken: (token) => ({
+    type: "user-token",
+    token
+  }),
+  noUserToken: { type: "no-user-token" }
+};
+var TokenTrigger = {
+  beforeRequest: { type: "before-request" },
+  after401: (rejected) => ({
+    type: "after-401",
+    rejected
+  })
+};
+function isRejectedToken(token, rejected) {
+  switch (rejected.type) {
+    case "user-token":
+      return rejected.token.value === token.value;
+    case "no-user-token":
+      return false;
+  }
+}
+
 // src/universal/api/http-attributes.ts
 var empty = {};
 var concat = (left, right) => ({
@@ -57,6 +80,10 @@ var retryAttempt = (attempt) => ({
 var renewAttempted = (value) => ({
   renewAttempted: value
 });
+var notRetryable = () => ({ retryable: false });
+var sentWith = (token) => ({
+  sentWith: token
+});
 var requestId = (id) => ({ requestId: id });
 var getRequestId = (attrs) => attrs?.requestId ?? null;
 var isProtected = (attrs) => attrs?.protected === true;
@@ -64,6 +91,8 @@ var needUserAgent = (attrs) => attrs?.userAgent === true;
 var isIdempotent = (attrs) => attrs?.idempotencyKey === true;
 var getRetryAttempt = (attrs) => attrs?.retryAttempt ?? 0;
 var wasRenewAttempted = (attrs) => attrs?.renewAttempted === true;
+var isRetryable = (attrs) => attrs?.retryable !== false;
+var getSentWith = (attrs) => attrs?.sentWith === void 0 ? SentWith.noUserToken : SentWith.userToken(attrs.sentWith);
 var getClientCredentials = (attrs) => attrs?.clientCredentials;
 var Attributes = {
   empty,
@@ -79,6 +108,10 @@ var Attributes = {
   getRetryAttempt,
   renewAttempted,
   wasRenewAttempted,
+  notRetryable,
+  isRetryable,
+  sentWith,
+  getSentWith,
   clientCredentials,
   getClientCredentials,
   requestId,
@@ -448,11 +481,18 @@ var HttpClient = class {
     );
     let response = await this.executeRequest(preparedRequest);
     for (const middleware of this.middleware.afterRequest ?? []) {
+      let retried = false;
       response = await middleware({
         request: preparedRequest,
         response,
-        retry: (nextRequest = preparedRequest) => this.runRequestWithAfterMiddleware(nextRequest)
+        retry: (nextRequest = preparedRequest) => {
+          retried = true;
+          return this.runRequestWithAfterMiddleware(nextRequest);
+        }
       });
+      if (retried) {
+        return response;
+      }
     }
     return response;
   }
@@ -585,23 +625,33 @@ function attachSessionMiddleware(fetchAccessToken) {
     if (!Attributes.isProtected(request.attributes)) {
       return request;
     }
-    let accessToken = await fetchAccessToken(false);
-    if (!accessToken) {
-      const clientCreds = Attributes.getClientCredentials(request.attributes);
-      if (clientCreds) {
-        accessToken = clientCreds;
-      }
+    const userToken = await fetchAccessToken(TokenTrigger.beforeRequest);
+    if (userToken !== null) {
+      return withBearer(
+        {
+          ...request,
+          attributes: Attributes.concat(
+            request.attributes ?? Attributes.empty,
+            Attributes.sentWith(userToken)
+          )
+        },
+        userToken.value
+      );
     }
-    if (accessToken === null) {
-      return request;
+    const clientCreds = Attributes.getClientCredentials(request.attributes);
+    if (clientCreds) {
+      return withBearer(request, clientCreds.value);
+    }
+    return request;
+  };
+}
+function withBearer(request, token) {
+  return {
+    ...request,
+    headers: {
+      ...request.headers ?? {},
+      Authorization: `Bearer ${token}`
     }
-    return {
-      ...request,
-      headers: {
-        ...request.headers ?? {},
-        Authorization: `Bearer ${accessToken.value}`
-      }
-    };
   };
 }
 
@@ -660,7 +710,7 @@ function getRetryDelayMs(attempt) {
 function createRequestRetryMiddleware(options = {}) {
   const delayFn = options.delayFn ?? defaultDelay;
   return async ({ request, response, retry }) => {
-    if (!isRetryableStatus(response.status)) {
+    if (!isRetryableStatus(response.status) || !Attributes.isRetryable(request.attributes)) {
       return response;
     }
     const currentAttempt = Attributes.getRetryAttempt(request.attributes);
@@ -693,7 +743,9 @@ function renewSessionMiddleware(fetchAccessToken) {
     if (Attributes.wasRenewAttempted(request.attributes)) {
       return response;
     }
-    const newToken = await fetchAccessToken(true);
+    const newToken = await fetchAccessToken(
+      TokenTrigger.after401(Attributes.getSentWith(request.attributes))
+    );
     if (newToken) {
       const nextRequest = Request.concatAttributes(
         request,
@@ -750,6 +802,158 @@ var ApiClient = class {
   }
 };
 
+// src/universal/types/time.ts
+var MAX_EPOCH_MILLIS = 864e13;
+var EpochMillis = {
+  /**
+   * @throws {@link ValidationError} unless `value` is an integer a `Date` can
+   * represent: at most {@link MAX_EPOCH_MILLIS} either side of the epoch.
+   */
+  of: (value) => {
+    if (!Number.isInteger(value) || Math.abs(value) > MAX_EPOCH_MILLIS) {
+      throw new ValidationError(
+        `EpochMillis must be an integer within \xB1${MAX_EPOCH_MILLIS}, got ${value}`
+      );
+    }
+    return value;
+  },
+  /** The wall clock. Code that needs the time takes a `TimeEff` instead. */
+  now: () => EpochMillis.of(Date.now()),
+  /** @throws {@link ValidationError} for an invalid `Date`. */
+  fromDate: (date) => EpochMillis.of(date.getTime()),
+  /** How long after `from` the instant `to` is; negative if it is before. */
+  elapsed: (from, to) => Millis.of(to - from),
+  plus: (at, duration) => EpochMillis.of(at + duration)
+};
+var Millis = {
+  of: (value) => value
+};
+var Seconds = {
+  /**
+   * @throws {@link ValidationError} unless `value` is a non-negative integer.
+   */
+  of: (value) => {
+    if (!Number.isInteger(value) || value < 0) {
+      throw new ValidationError(
+        `Seconds must be a non-negative integer, got ${value}`
+      );
+    }
+    return value;
+  },
+  toMillis: (value) => Millis.of(value * 1e3)
+};
+function isExpired({
+  expiresAt,
+  now,
+  buffer = Millis.of(0)
+}) {
+  return now >= expiresAt - buffer;
+}
+
+// src/universal/core/shared/effects.ts
+var systemTime = { time: { now: EpochMillis.now } };
+
+// src/server/core/session-refresh.ts
+var VERDICT_MIN_GAP = Millis.of(5e3);
+var REJECTION_MEMORY = Millis.of(6e4);
+var RefreshKey = {
+  of: ({
+    clientId,
+    session
+  }) => {
+    const identity = session.refreshToken === void 0 ? ["access", session.accessToken.value] : ["refresh", session.refreshToken];
+    return JSON.stringify([clientId, ...identity]);
+  }
+};
+var RefreshCoordinator = class {
+  constructor(env = systemTime) {
+    this.env = env;
+    this.inFlight = /* @__PURE__ */ new Map();
+    this.rejections = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Runs `exchange` for `key` unless one is already in flight, in which case
+   * the caller joins it. `joined` tells the caller whether it led: only the
+   * leader reports the outcome, so a burst of N produces one verdict, one log
+   * line and one `onSessionExpired`.
+   */
+  refresh(key, exchange) {
+    const existing = this.inFlight.get(key);
+    if (existing !== void 0) {
+      return { outcome: existing, joined: true };
+    }
+    const outcome = this.run(key, exchange).finally(() => {
+      this.inFlight.delete(key);
+    });
+    this.inFlight.set(key, outcome);
+    return { outcome, joined: false };
+  }
+  async run(key, exchange) {
+    this.forgetStale(this.env.time.now());
+    if (this.rejections.get(key)?.type === "expired") {
+      return { type: "already-expired" };
+    }
+    const result = await exchange();
+    switch (result.type) {
+      case "renewed":
+      case "unknown":
+        return result;
+      case "rejected":
+      case "unrenewable": {
+        const judged = judge({
+          result: result.type,
+          prior: this.rejections.get(key),
+          now: this.env.time.now()
+        });
+        this.rejections.set(key, judged.memory);
+        return { type: judged.outcome };
+      }
+    }
+  }
+  forgetStale(now) {
+    for (const [key, rejection] of this.rejections) {
+      if (EpochMillis.elapsed(rejectedAt(rejection), now) > REJECTION_MEMORY) {
+        this.rejections.delete(key);
+      }
+    }
+  }
+};
+function judge({
+  result,
+  prior,
+  now
+}) {
+  const verdict = {
+    outcome: "expired",
+    memory: { type: "expired", at: now }
+  };
+  switch (result) {
+    case "unrenewable":
+      return verdict;
+    case "rejected":
+      switch (prior?.type) {
+        case void 0:
+          return {
+            outcome: "suspected",
+            memory: { type: "suspected", since: now }
+          };
+        case "suspected":
+          return EpochMillis.elapsed(prior.since, now) >= VERDICT_MIN_GAP ? verdict : { outcome: "suspected", memory: prior };
+        case "expired":
+          return { outcome: "expired", memory: prior };
+      }
+  }
+}
+function rejectedAt(rejection) {
+  switch (rejection.type) {
+    case "suspected":
+      return rejection.since;
+    case "expired":
+      return rejection.at;
+  }
+}
+var processRefreshCoordinator = new RefreshCoordinator();
+
 // src/server/shared/errors.ts
 var WritableSessionStoreRequiredError = class extends Error {
   constructor(message = "This operation requires a writable SessionStore. Provide a `setSession` implementation in your SessionStore to persist or clear OAuth sessions.") {
@@ -758,6 +962,16 @@ var WritableSessionStoreRequiredError = class extends Error {
   }
 };
 
+// src/universal/core/auth/session-expired.ts
+function notifySessionExpired(onSessionExpired, log) {
+  if (onSessionExpired === void 0) {
+    return;
+  }
+  Promise.resolve().then(onSessionExpired).catch(
+    (error) => log.failure(() => ({ msg: "onSessionExpired threw" }), error)
+  );
+}
+
 // src/universal/types/oauth-session.ts
 var ClientCredentialsOAuth = (value) => value;
 var OAuthRefreshToken = (value) => value;
@@ -774,10 +988,7 @@ var OAuthSession = {
   }
 };
 
-// src/server/core/server-auth-namespace.ts
-function emptySessionStore() {
-  return { getSession: async () => null };
-}
+// src/server/core/server-auth-namespace-impl.ts
 var ServerAuthNamespaceImpl = class {
   constructor(api, config) {
     this.api = api;
@@ -797,7 +1008,8 @@ var ServerAuthNamespaceImpl = class {
           client_id: this.config.clientId,
           client_secret: this.config.clientSecret,
           code_verifier: params.codeVerifier
-        }
+        },
+        attributes: Attributes.notRetryable()
       });
       const session = OAuthSession.fromDto(sessionDto);
       await setSession(session);
@@ -805,39 +1017,118 @@ var ServerAuthNamespaceImpl = class {
     });
   }
   async getAccessToken() {
+    return this.tokenFor(TokenTrigger.beforeRequest);
+  }
+  /**
+   * {@link getAccessToken} with the reason the SDK is asking, which is what
+   * the authenticated HTTP pipeline calls: after a 401 the token's own expiry
+   * no longer matters, because the API has answered for it.
+   */
+  async tokenFor(trigger) {
     return this.log.wrap(
       "getAccessToken",
       void 0,
-      () => this.readAccessToken()
+      () => this.readAccessToken(trigger)
     );
   }
-  async readAccessToken() {
+  async readAccessToken(trigger) {
     const sessionStore = this.config.sessionStore;
-    const session = await sessionStore.getSession();
-    if (session == null) return null;
-    const now = Date.now();
-    const expiresAt = session.accessToken.expiresAt.getTime();
-    const bufferMs = this.config.accessTokenExpiryBufferSeconds * 1e3;
-    if (expiresAt > now + bufferMs) {
-      return session.accessToken;
-    }
-    const setSession = sessionStore.setSession?.bind(sessionStore);
-    if (!setSession) {
-      this.log.child({ op: "getAccessToken" }).warn(() => ({
-        msg: "serving an expired token: the session store is read-only, so it cannot be refreshed"
-      }));
-      return session.accessToken;
+    const classification = classifyAccessToken({
+      session: await sessionStore.getSession(),
+      store: sessionStoreAccess(sessionStore),
+      trigger,
+      now: this.config.time.now(),
+      buffer: Seconds.toMillis(this.config.accessTokenExpiryBufferSeconds)
+    });
+    switch (classification.type) {
+      case "no-session":
+      case "refuse":
+        return null;
+      case "serve":
+        return classification.token;
+      case "serve-stale":
+        this.log.child({ op: "getAccessToken" }).warn(() => ({
+          msg: "serving an expired token: the session store is read-only, so it cannot be refreshed"
+        }));
+        return classification.token;
+      case "refresh":
+        return this.refresh(classification);
     }
-    return this.refreshSession(session.refreshToken, setSession);
   }
-  async refreshSession(refreshToken, setSession) {
+  /**
+   * Refreshes through the process-wide coordinator, then acts on the outcome
+   * for this caller's own store. The store is written before anything is
+   * logged or the host is notified, so `onSessionExpired` always finds it
+   * cleared.
+   */
+  async refresh({
+    session,
+    setSession,
+    fallback
+  }) {
     const log = this.log.child({ op: "refresh" });
-    if (!refreshToken) {
-      log.warn(() => ({
-        msg: "clearing the session: it carries no refresh token"
-      }));
-      await setSession(null);
-      return null;
+    const key = RefreshKey.of({ clientId: this.config.clientId, session });
+    const { outcome, joined } = this.config.refreshes.refresh(
+      key,
+      () => this.exchange(session.refreshToken)
+    );
+    if (joined) {
+      log.debug(() => ({ msg: "joined a refresh already in flight" }));
+    }
+    const result = await outcome;
+    switch (result.type) {
+      case "renewed":
+        await setSession(result.session);
+        if (!joined) {
+          log.info(() => ({ msg: "session renewed" }));
+        }
+        return result.session.accessToken;
+      case "suspected":
+        if (!joined) {
+          log.warn(() => ({
+            msg: "refresh rejected; not clearing until it is confirmed"
+          }));
+        }
+        return fallback;
+      case "expired":
+        await setSession(null);
+        if (!joined) {
+          log.info(() => ({
+            msg: "session expired",
+            fields: {
+              reason: session.refreshToken === void 0 ? "no-refresh-token" : "refresh-rejected"
+            }
+          }));
+          notifySessionExpired(this.config.onSessionExpired, log);
+        }
+        return null;
+      case "already-expired":
+        await setSession(null);
+        return null;
+      case "unknown":
+        if (fallback === null) {
+          throw result.error;
+        }
+        if (!joined) {
+          log.warning(
+            () => ({ msg: "refresh failed; serving the current token" }),
+            result.error
+          );
+        }
+        return fallback;
+    }
+  }
+  /**
+   * One `POST /oauth/token`, total: every failure comes back as a value, so
+   * the coordinator can judge it once for everyone who joined.
+   *
+   * Never retried. The refresh token is single-use, so a retry of an attempt
+   * that reached the server would present a token already rotated away, and
+   * its `invalid_grant` would be judged as a rejection of the session.
+   */
+  async exchange(refreshToken) {
+    if (refreshToken === void 0) {
+      return { type: "unrenewable" };
     }
     try {
       const sessionDto = await this.api.send({
@@ -848,19 +1139,12 @@ var ServerAuthNamespaceImpl = class {
           refresh_token: refreshToken,
           client_id: this.config.clientId,
           client_secret: this.config.clientSecret
-        }
+        },
+        attributes: Attributes.notRetryable()
       });
-      const newSession = OAuthSession.fromDto(sessionDto);
-      await setSession(newSession);
-      log.info(() => ({ msg: "session renewed" }));
-      return newSession.accessToken;
+      return { type: "renewed", session: OAuthSession.fromDto(sessionDto) };
     } catch (error) {
-      log.failure(
-        () => ({ msg: "refresh failed; clearing the session" }),
-        error
-      );
-      await setSession(null);
-      return null;
+      return isInvalidGrant(error) ? { type: "rejected" } : { type: "unknown", error };
     }
   }
   async clientCredentials() {
@@ -906,18 +1190,91 @@ var ServerAuthNamespaceImpl = class {
     await setSession(null);
   }
   /**
-   * Returns the store's `setSession`, or throws — the guard every
+   * Returns the store's `setSession`, or throws - the guard every
    * session-writing operation shares.
    */
   writableSessionStore() {
-    const sessionStore = this.config.sessionStore;
-    const setSession = sessionStore.setSession?.bind(sessionStore);
-    if (!setSession) {
-      throw new WritableSessionStoreRequiredError();
+    const store = sessionStoreAccess(this.config.sessionStore);
+    switch (store.type) {
+      case "writable":
+        return store.setSession;
+      case "read-only":
+        throw new WritableSessionStoreRequiredError();
     }
-    return setSession;
   }
 };
+function classifyAccessToken({
+  session,
+  store,
+  trigger,
+  now,
+  buffer
+}) {
+  if (session === null) {
+    return { type: "no-session" };
+  }
+  const token = session.accessToken;
+  const stale = isExpired({
+    expiresAt: EpochMillis.fromDate(token.expiresAt),
+    now,
+    buffer
+  });
+  switch (store.type) {
+    case "read-only":
+      return classifyReadOnly(token, trigger, stale);
+    case "writable": {
+      if (!needsRefresh(token, trigger, stale)) {
+        return { type: "serve", token };
+      }
+      const fallback = fallbackToken(token, trigger, now);
+      return session.refreshToken === void 0 && fallback !== null ? { type: "serve", token: fallback } : {
+        type: "refresh",
+        session,
+        setSession: store.setSession,
+        fallback
+      };
+    }
+  }
+}
+function classifyReadOnly(token, trigger, stale) {
+  switch (trigger.type) {
+    case "after-401":
+      return isRejectedToken(token, trigger.rejected) ? { type: "refuse" } : { type: "serve", token };
+    case "before-request":
+      return stale ? { type: "serve-stale", token } : { type: "serve", token };
+  }
+}
+function sessionStoreAccess(sessionStore) {
+  const setSession = sessionStore.setSession?.bind(sessionStore);
+  return setSession === void 0 ? { type: "read-only" } : { type: "writable", setSession };
+}
+function needsRefresh(token, trigger, stale) {
+  switch (trigger.type) {
+    case "before-request":
+      return stale;
+    case "after-401":
+      return trigger.rejected.type === "no-user-token" || isRejectedToken(token, trigger.rejected) || stale;
+  }
+}
+function fallbackToken(token, trigger, now) {
+  const unexpired = !isExpired({
+    expiresAt: EpochMillis.fromDate(token.expiresAt),
+    now
+  });
+  switch (trigger.type) {
+    case "after-401":
+      return unexpired && !isRejectedToken(token, trigger.rejected) ? token : null;
+    case "before-request":
+      return unexpired ? token : null;
+  }
+}
+function isInvalidGrant(error) {
+  if (!(error instanceof HttpError) || error.response.status !== 400) {
+    return false;
+  }
+  const body = error.response.body;
+  return typeof body === "object" && body !== null && "error" in body && body.error === "invalid_grant";
+}
 
 // src/universal/api/pagination.ts
 async function fetchAllPages(fetchPage, baseParams) {
@@ -1821,6 +2178,8 @@ function formatRawAmount(amount) {
   return (0, import_viem4.formatUnits)(amount.raw, amount.decimals);
 }
 var NA_AMOUNT_ASSET_UI = FormattedAmountAssetUi("-");
+var SHARE_MAX_FRACTION_DIGITS = AssetDecimals(6);
+var SHARE_MIN_FRACTION_DIGITS = AssetDecimals(2);
 var USD_FRACTION_DIGITS = AssetDecimals(2);
 
 // src/universal/core/shared/blockchain/math.ts
@@ -3666,28 +4025,26 @@ var WalletsNamespaceImpl = class {
 };
 
 // src/server/core/coinlist-server.ts
-var ACCESS_TOKEN_EXPIRY_BUFFER_SECONDS = 60;
+var ACCESS_TOKEN_EXPIRY_BUFFER = Seconds.of(60);
 var CoinListServerImpl = class {
   constructor(_config) {
-    this._config = _config;
     const logger = _config.logger ?? null;
     this.api = new ApiClient(
       {
         baseUrl: _config.baseUrl ?? PUBLIC_API_BASE_URL,
         xApiVersion: API_VERSION
       },
-      // When refresh=true the renewal middleware has received a 401 and wants a
-      // fresh token. A read-only store cannot persist a new session, so return
-      // null immediately — this tells the middleware to skip the retry rather
-      // than re-sending with the same expired token and wasting a round-trip.
-      (refresh) => refresh && !this._config.sessionStore.setSession ? Promise.resolve(null) : this.auth.getAccessToken(),
+      (trigger) => auth.tokenFor(trigger),
       logger
     );
-    this.auth = new ServerAuthNamespaceImpl(this.api, {
+    const auth = new ServerAuthNamespaceImpl(this.api, {
       ..._config,
-      accessTokenExpiryBufferSeconds: _config.accessTokenExpiryBufferSeconds ?? ACCESS_TOKEN_EXPIRY_BUFFER_SECONDS,
-      strict: _config.strict ?? false
+      accessTokenExpiryBufferSeconds: _config.accessTokenExpiryBufferSeconds ?? ACCESS_TOKEN_EXPIRY_BUFFER,
+      strict: _config.strict ?? false,
+      refreshes: processRefreshCoordinator,
+      ...systemTime
     });
+    this.auth = auth;
     const ctx = {
       api: this.api,
       rpc: publicClients(this.api, _config.rpc, _config.logger ?? null),
@@ -3865,9 +4222,13 @@ function pinoServerLogger(options) {
     options.level
   );
 }
+
+// src/server/core/server-auth-namespace.ts
+function emptySessionStore() {
+  return { getSession: async () => null };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ServerAuthNamespaceImpl,
   ServerOffersNamespaceImpl,
   ServerRequirementsNamespaceImpl,
   WritableSessionStoreRequiredError,