@coinlist-co/react 0.12.2-rc.7b430dd → 0.12.2-rc.8a0d02a

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() {
@@ -896,28 +1180,102 @@ var ServerAuthNamespaceImpl = class {
         }
       });
     } catch (err) {
-      if (!(err instanceof HttpError) || this.config.strict) {
+      if (this.config.strict) {
         throw err;
       }
-      this.log.child({ op: "logout" }).warn(() => ({
-        msg: "the token was not revoked upstream; the local session is cleared regardless"
-      }));
+      this.log.child({ op: "logout" }).warning(
+        () => ({ msg: "revoke failed; local session cleared regardless" }),
+        err
+      );
     }
     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) {
@@ -935,40 +1293,6 @@ async function fetchAllPages(fetchPage, baseParams) {
   return items;
 }
 
-// src/universal/core/shared/utils/wire.ts
-function unknownTypeError(dto, model) {
-  const type = dto.type;
-  throw new ValidationError(
-    `${model}.type: unknown type ${JSON.stringify(type)}`
-  );
-}
-function requiredString(value, field) {
-  const text = notBlankStringOrNull(value);
-  if (text === null) {
-    throw new ValidationError(
-      `${field}: expected a non-blank string, got ${typeof value === "string" ? "a blank string" : String(value)}`
-    );
-  }
-  return text;
-}
-function requiredDate(value, field) {
-  const date = typeof value === "string" ? new Date(value) : null;
-  if (date === null || Number.isNaN(date.getTime())) {
-    throw new ValidationError(
-      `${field}: expected a date, got ${JSON.stringify(value)}`
-    );
-  }
-  return date;
-}
-function requiredArray(value, field) {
-  if (!Array.isArray(value)) {
-    throw new ValidationError(
-      `${field}: expected an array, got ${typeof value}`
-    );
-  }
-  return value;
-}
-
 // src/universal/types/blockchain/core.ts
 var ETHEREUM_CHAINS = {
   ethereum_mainnet: true,
@@ -1057,13 +1381,54 @@ function combineAmounts(a, b, op) {
 }
 var AssetSymbol = (value) => value;
 
+// src/universal/core/shared/utils/wire.ts
+function unknownTypeError(dto, model) {
+  const type = dto.type;
+  throw new ValidationError(
+    `${model}.type: unknown type ${JSON.stringify(type)}`
+  );
+}
+function requiredString(value, field) {
+  const text = notBlankStringOrNull(value);
+  if (text === null) {
+    throw new ValidationError(
+      `${field}: expected a non-blank string, got ${typeof value === "string" ? "a blank string" : String(value)}`
+    );
+  }
+  return text;
+}
+function requiredDate(value, field) {
+  const date = typeof value === "string" ? new Date(value) : null;
+  if (date === null || Number.isNaN(date.getTime())) {
+    throw new ValidationError(
+      `${field}: expected a date, got ${JSON.stringify(value)}`
+    );
+  }
+  return date;
+}
+function dateOrNull(value, field) {
+  return value === null ? null : requiredDate(value, field);
+}
+function decimalOrNull(value) {
+  return value === null ? null : DecimalString(value);
+}
+function requiredArray(value, field) {
+  if (!Array.isArray(value)) {
+    throw new ValidationError(
+      `${field}: expected an array, got ${typeof value}`
+    );
+  }
+  return value;
+}
+
 // src/universal/types/offer.ts
 var OfferId = (value) => value;
 var OfferSlug = (value) => value;
 var OFFER_TYPES = {
   "coinlist::token_sale": true,
   "superstate::swap": true,
-  "ondo::swap": true
+  "ondo::swap": true,
+  "centrifuge::vault": true
 };
 var isOfferType = (value) => Object.keys(OFFER_TYPES).includes(value);
 var OfferEditorial = {
@@ -1105,6 +1470,7 @@ var Offer = {
       // on the wire: copying them would hand every consumer a `startsAt` that
       // is 1970 for one variant and a date for the others.
       case "ondo::swap":
+      case "centrifuge::vault":
         return {
           ...base2,
           type: dto.type,
@@ -1169,6 +1535,19 @@ var OfferSwapContract = {
     address: EvmContractAddress(dto.address)
   })
 };
+var OfferVaultContract = {
+  fromDto: (dto) => ({
+    chain: Chain(dto.chain),
+    address: EvmContractAddress(dto.address)
+  }),
+  /**
+   * Drops every proxy on a chain this SDK does not name, as
+   * `OfferToken.listFromDto` does: frontline publishes the full offer-token
+   * chain list, which runs ahead of {@link Chain}, and one unmodelled chain
+   * should not throw away the proxies the SDK can use.
+   */
+  listFromDto: (dtos) => dtos.filter((dto) => isChain(dto.chain)).map(OfferVaultContract.fromDto)
+};
 var OfferDetail = {
   fromDto: (dto) => {
     const fundingAssets = requiredArray(
@@ -1231,6 +1610,18 @@ var OfferDetail = {
             "OfferDetail.swap_contracts"
           ).map(OfferSwapContract.fromDto)
         };
+      // No editorial, as for Ondo. `[]` is fine and a missing key is not, for
+      // the same reason as `swap_contracts`: this is the spender a user
+      // approves.
+      case "centrifuge::vault":
+        return {
+          ...base2,
+          type: dto.type,
+          logoUrl: notBlankStringOrNull(dto.logo_url),
+          vaultContracts: OfferVaultContract.listFromDto(
+            requiredArray(dto.vault_contracts, "OfferDetail.vault_contracts")
+          )
+        };
       default:
         return unknownTypeError(dto, "OfferDetail");
     }
@@ -1702,6 +2093,282 @@ function transportFor(api, override, chain, logger) {
   return typeof override === "string" ? (0, import_viem3.http)(override) : override;
 }
 
+// src/universal/core/shared/blockchain/math.ts
+var import_viem4 = require("viem");
+function blockchainAmountFromRawOrThrow({
+  label,
+  raw,
+  decimals
+}) {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
+  }
+  let value;
+  try {
+    value = BigInt(trimmed);
+  } catch {
+    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
+  }
+  try {
+    return BlockchainAmount({ raw: assertUint256(value), decimals });
+  } catch {
+    throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
+  }
+}
+
+// src/universal/types/providers/centrifuge/centrifuge.ts
+var CentrifugeVaultStatus = {
+  fromDto: (dto) => ({
+    chain: EthereumChain(dto.chain),
+    symbol: AssetSymbol(dto.symbol),
+    vaultAddress: EvmContractAddress(dto.vault_address),
+    linked: dto.linked,
+    permissioned: dto.permissioned,
+    membershipValidUntil: dateOrNull(
+      dto.membership_valid_until,
+      "CentrifugeVaultStatus.membership_valid_until"
+    ),
+    halted: dto.halted,
+    priceUpdatedAt: dateOrNull(
+      dto.price_updated_at,
+      "CentrifugeVaultStatus.price_updated_at"
+    ),
+    orderability: parseOrderability(
+      dto.can_order,
+      dto.reasons,
+      "CentrifugeVaultStatus"
+    ),
+    asOf: requiredDate(dto.as_of, "CentrifugeVaultStatus.as_of")
+  })
+};
+var CentrifugeVaultBuyTransaction = {
+  fromDto: (dto) => {
+    const spendInputAmount = blockchainAmountFromRawOrThrow({
+      label: "spend_input_amount",
+      raw: dto.spend_input_amount,
+      decimals: AssetDecimals(dto.spend_input_decimals)
+    });
+    if (spendInputAmount.raw <= 0n) {
+      throw new ValidationError(
+        `spend_input_amount: must be greater than zero ("${dto.spend_input_amount}") - a deposit of nothing is not a request`
+      );
+    }
+    return {
+      ...parseTransactionCore(dto, "CentrifugeVaultBuyTransaction"),
+      spendInputAmount
+    };
+  }
+};
+var CentrifugeVaultClaimTransaction = {
+  fromDto: (dto) => ({
+    ...parseTransactionCore(dto, "CentrifugeVaultClaimTransaction"),
+    claimableShares: blockchainAmountFromRawOrThrow({
+      label: "claimable_shares",
+      raw: dto.claimable_shares,
+      decimals: AssetDecimals(dto.share_decimals)
+    })
+  })
+};
+var CentrifugeVaultPosition = {
+  fromDto: (dto) => {
+    const assetDecimals = AssetDecimals(dto.asset_decimals);
+    const shareDecimals = AssetDecimals(dto.share_decimals);
+    const asset = (label, raw) => blockchainAmountFromRawOrThrow({ label, raw, decimals: assetDecimals });
+    const shares = (label, raw) => blockchainAmountFromRawOrThrow({ label, raw, decimals: shareDecimals });
+    return {
+      chain: EthereumChain(dto.chain),
+      symbol: AssetSymbol(dto.symbol),
+      walletAddress: EvmWalletAddress(dto.wallet_address),
+      status: dto.status,
+      requested: asset("requested", dto.requested),
+      pending: asset("pending", dto.pending),
+      filledAssets: asset("filled_assets", dto.filled_assets),
+      earnedShares: shares("earned_shares", dto.earned_shares),
+      claimedShares: shares("claimed_shares", dto.claimed_shares),
+      claimableShares: shares("claimable_shares", dto.claimable_shares),
+      shareBalance: shares("share_balance", dto.share_balance),
+      averagePrice: decimalOrNull(dto.average_price),
+      frozen: dto.frozen,
+      asOf: requiredDate(dto.as_of, "CentrifugeVaultPosition.as_of")
+    };
+  }
+};
+var CentrifugeVaultRedeemPosition = {
+  fromDto: (dto) => ({
+    chain: EthereumChain(dto.chain),
+    symbol: AssetSymbol(dto.symbol),
+    walletAddress: EvmWalletAddress(dto.wallet_address),
+    status: dto.status,
+    pending: blockchainAmountFromRawOrThrow({
+      label: "pending",
+      raw: dto.pending,
+      decimals: AssetDecimals(dto.share_decimals)
+    }),
+    claimableAssets: blockchainAmountFromRawOrThrow({
+      label: "claimable_assets",
+      raw: dto.claimable_assets,
+      decimals: AssetDecimals(dto.asset_decimals)
+    }),
+    frozen: dto.frozen,
+    asOf: requiredDate(dto.as_of, "CentrifugeVaultRedeemPosition.as_of")
+  })
+};
+var CentrifugeVaultClaimProceedsTransaction = {
+  fromDto: (dto) => ({
+    ...parseTransactionCore(dto, "CentrifugeVaultClaimProceedsTransaction"),
+    claimableAssets: blockchainAmountFromRawOrThrow({
+      label: "claimable_assets",
+      raw: dto.claimable_assets,
+      decimals: AssetDecimals(dto.asset_decimals)
+    })
+  })
+};
+function parseOrderability(canOrder, reasons, model) {
+  const [first, ...rest] = reasons;
+  if (canOrder) {
+    if (first !== void 0) {
+      throw new ValidationError(
+        `${model}.reasons: expected none when can_order is true, got ${JSON.stringify(reasons)}`
+      );
+    }
+    return { type: "orderable" };
+  }
+  if (first === void 0) {
+    throw new ValidationError(
+      `${model}.reasons: expected at least one when can_order is false`
+    );
+  }
+  return { type: "blocked", reasons: [first, ...rest] };
+}
+function parseTransactionCore(dto, model) {
+  return {
+    tx: {
+      to: EvmContractAddress(dto.to),
+      data: HexEncodedTransactionData(dto.data)
+    },
+    expiresAt: dateOrNull(dto.expires_at, `${model}.expires_at`)
+  };
+}
+
+// src/universal/api/frontline/providers/centrifuge/centrifuge.ts
+async function getCentrifugeVaultStatus(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/centrifuge/vault/status",
+    queryParams: {
+      symbol: params.symbol,
+      chain: params.chain
+    },
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultStatus.fromDto(dto);
+}
+async function buildCentrifugeVaultBuy(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/centrifuge/vault/invest",
+    body: {
+      ...walletFields(params),
+      amount: params.amount.raw.toString()
+    },
+    attributes: Attributes.protected()
+  });
+  if (dto.spend_input_decimals !== params.amount.decimals) {
+    throw new ValidationError(
+      `spend_input_decimals: the request was priced in ${dto.spend_input_decimals} decimals but the deposit was sized in ${params.amount.decimals}`
+    );
+  }
+  return CentrifugeVaultBuyTransaction.fromDto(dto);
+}
+async function getCentrifugeVaultPosition(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/centrifuge/vault/position",
+    queryParams: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultPosition.fromDto(dto);
+}
+async function getCentrifugeVaultRedeemPosition(api, params) {
+  const dto = await api.send({
+    method: "GET",
+    url: "/v1/centrifuge/vault/redeem-position",
+    queryParams: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultRedeemPosition.fromDto(dto);
+}
+async function createCentrifugeVaultClaim(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/centrifuge/vault/claim",
+    body: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultClaimTransaction.fromDto(dto);
+}
+async function createCentrifugeVaultClaimProceeds(api, params) {
+  const dto = await api.send({
+    method: "POST",
+    url: "/v1/centrifuge/vault/claim-proceeds",
+    body: walletFields(params),
+    attributes: Attributes.protected()
+  });
+  return CentrifugeVaultClaimProceedsTransaction.fromDto(dto);
+}
+function walletFields(params) {
+  return {
+    symbol: params.symbol,
+    chain: params.chain,
+    wallet_address: params.walletAddress
+  };
+}
+
+// src/universal/core/checkout/centrifuge/centrifuge-namespace.ts
+var CentrifugeNamespaceImpl = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.log = internalLogger(ctx.logger, "CENTRIFUGE");
+  }
+  async getVaultStatus(params) {
+    return this.log.wrap("getVaultStatus", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getCentrifugeVaultStatus(this.ctx.api, params);
+    });
+  }
+  async getPosition(params) {
+    return this.log.wrap("getPosition", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getCentrifugeVaultPosition(this.ctx.api, params);
+    });
+  }
+  async getRedeemPosition(params) {
+    return this.log.wrap("getRedeemPosition", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return getCentrifugeVaultRedeemPosition(this.ctx.api, params);
+    });
+  }
+  async createClaim(params) {
+    return this.log.wrap("createClaim", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createCentrifugeVaultClaim(this.ctx.api, params);
+    });
+  }
+  async createClaimProceeds(params) {
+    return this.log.wrap("createClaimProceeds", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return createCentrifugeVaultClaimProceeds(this.ctx.api, params);
+    });
+  }
+  async buildBuyTransaction(params) {
+    return this.log.wrap("buildBuyTransaction", params, async () => {
+      await this.ctx.ensureUserAuthenticated();
+      return buildCentrifugeVaultBuy(this.ctx.api, params);
+    });
+  }
+};
+
 // src/universal/types/providers/coin-list/token-sale.ts
 var ParticipationId = (value) => value;
 var Blockchain = (value) => value;
@@ -1816,37 +2483,15 @@ var CoinListTokenSaleNamespaceImpl = class {
 };
 
 // src/universal/core/shared/blockchain/formatters.ts
-var import_viem4 = require("viem");
+var import_viem5 = require("viem");
 function formatRawAmount(amount) {
-  return (0, import_viem4.formatUnits)(amount.raw, amount.decimals);
+  return (0, import_viem5.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
-var import_viem5 = require("viem");
-function blockchainAmountFromRawOrThrow({
-  label,
-  raw,
-  decimals
-}) {
-  const trimmed = raw.trim();
-  if (trimmed === "") {
-    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
-  }
-  let value;
-  try {
-    value = BigInt(trimmed);
-  } catch {
-    throw new ValidationError(`${label}: not a uint256 integer ("${raw}")`);
-  }
-  try {
-    return BlockchainAmount({ raw: assertUint256(value), decimals });
-  } catch {
-    throw new ValidationError(`${label}: out of uint256 bounds (${value})`);
-  }
-}
-
 // src/universal/types/providers/ondo/ondo.ts
 var OndoTradingStatus = {
   fromDto: (dto) => {
@@ -1862,7 +2507,6 @@ var OndoTradingStatus = {
     };
   }
 };
-var decimalOrNull = (value) => value === null ? null : DecimalString(value);
 var OndoQuote = {
   fromDto: (dto) => {
     const assetDecimals = AssetDecimals(dto.asset_decimals);
@@ -3666,28 +4310,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),
@@ -3702,6 +4344,7 @@ var CoinListServerImpl = class {
     this.tokenSale = new CoinListTokenSaleNamespaceImpl(ctx);
     this.superstate = new SuperstateSwapNamespaceImpl(ctx);
     this.ondo = new OndoNamespaceImpl(ctx);
+    this.centrifuge = new CentrifugeNamespaceImpl(ctx);
     this.tokens = new TokensNamespaceImpl(
       _config.tokensBaseUrl ?? NABU_BASE_URL,
       logger
@@ -3865,9 +4508,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,