@ember-finance/sdk 2.15.0 → 2.16.0

package/dist/src/placements/pointers.js

@@ -1,5 +1,6 @@
 import { environmentConfig } from "../common/constants.js";
-import { coinTypesMatch } from "./sui.js";
+import { isAbortError, isTransientStatus, retryAfterMs } from "./batch.js";
+import { coinTypesMatch, normalizeCoinType } from "./sui.js";
 /**
  * Pointers held in memory. Useful for tests, and for pinning a known venue set
  * without a round-trip.
@@ -35,69 +36,152 @@ export function httpPointerSource(options = {}) {
     const path = options.path ?? "/api/v2/vaults/placements";
     const cacheMs = options.cacheMs ?? 30000;
     /**
-     * One request per coin, not per (coin, protocol).
-     *
-     * `?coin=` already returns every protocol's rows, so asking once per adapter
-     * fetched the same list five times and threw four of them away. Reading one
-     * vault meant eight requests where two would do, and a caller sweeping every
-     * vault made hundreds — enough to be rate-limited, and a rejected discover
-     * drops that venue from the answer.
+     * One request for every coin. The endpoint answers with the whole registry
+     * when `coin` is omitted, so reading every vault costs one call rather than
+     * one per receipt coin.
      *
      * In-flight requests are shared rather than merely cached, so the adapters
      * racing each other at the start of a `forAccount` collapse into one call.
      */
     const inFlight = new Map();
-    const rowsForCoin = (coin) => {
-        const key = coin.coin.toLowerCase();
+    // Set when the server rejects the unfiltered call, i.e. it predates it.
+    // Rechecked after a while, so a long-lived source picks up a server that
+    // has since been upgraded.
+    let perCoinUntil = 0;
+    const shared = (key, load) => {
         const hit = inFlight.get(key);
         if (hit && Date.now() - hit.at < cacheMs)
             return hit.rows;
-        const rows = (async () => {
-            const url = new URL(`${baseUrl.replace(/\/$/, "")}${path}`);
-            url.searchParams.set("coin", coin.coin);
-            const response = await fetch(url.toString(), {
-                headers: { Accept: "application/json" }
-            });
-            if (!response.ok) {
-                throw new Error(`pointer source ${response.status}`);
-            }
-            const body = (await response.json());
-            // The chain type comes from the coin, not the wire: an adapter only
-            // ever runs on its own chain, so a server that named it again could
-            // only ever disagree.
-            return (body.placements ?? []).map(placement => ({
-                id: placement.id,
-                protocol: placement.protocol,
-                chain: {
-                    type: coin.chain.type,
-                    chainId: placement.chainId,
-                    identifier: placement.chainIdentifier
-                },
-                venue: placement.venue,
-                coin: placement.coin,
-                decimals: requireDecimals(placement),
-                protocolName: placement.protocolName,
-                protocolLogoUrl: placement.protocolLogoUrl,
-                source: placement.source,
-                label: placement.label,
-                shareToken: placement.shareToken,
-                url: placement.url,
-                rpcUrl: placement.rpcUrl
-            }));
-        })();
+        const rows = load();
         // A failure is not cached: the next adapter should retry rather than
         // inherit a rejection it never caused.
         rows.catch(() => inFlight.delete(key));
         inFlight.set(key, { at: Date.now(), rows });
         return rows;
     };
+    const request = (coin) => {
+        const url = new URL(`${baseUrl.replace(/\/$/, "")}${path}`);
+        if (coin !== undefined)
+            url.searchParams.set("coin", coin);
+        return fetchPlacements(url.toString());
+    };
+    const rowsFor = async (coin) => {
+        if (Date.now() >= perCoinUntil) {
+            try {
+                return await shared("*", () => request());
+            }
+            catch (error) {
+                if (!(error instanceof PointerSourceError) || error.status !== 400) {
+                    throw error;
+                }
+                perCoinUntil = Date.now() + FALLBACK_RECHECK_MS;
+            }
+        }
+        return shared(coin.coin.toLowerCase(), () => request(coin.coin));
+    };
     return {
         async placements(protocol, coin) {
-            const rows = await rowsForCoin(coin);
-            return rows.filter(ref => ref.protocol === protocol);
+            const rows = await rowsFor(coin);
+            const wanted = coinKey(coin.coin);
+            // One venue stored under two spellings of the coin would otherwise
+            // be read twice and double-count the position.
+            const seen = new Set();
+            return (rows
+                .filter(row => {
+                if (row.protocol !== protocol || coinKey(row.coin) !== wanted) {
+                    return false;
+                }
+                const key = [row.chainIdentifier, row.venue, row.shareToken ?? ""]
+                    .join(":")
+                    .toLowerCase();
+                if (seen.has(key))
+                    return false;
+                seen.add(key);
+                return true;
+            })
+                // The chain type comes from the coin, not the wire: an adapter
+                // only ever runs on its own chain, so a server that named it
+                // again could only ever disagree.
+                .map(row => ({
+                id: row.id,
+                protocol: row.protocol,
+                chain: {
+                    type: coin.chain.type,
+                    chainId: row.chainId,
+                    identifier: row.chainIdentifier
+                },
+                venue: row.venue,
+                coin: row.coin,
+                decimals: requireDecimals(row),
+                protocolName: row.protocolName,
+                protocolLogoUrl: row.protocolLogoUrl,
+                source: row.source,
+                label: row.label,
+                shareToken: row.shareToken,
+                url: row.url,
+                rpcUrl: row.rpcUrl
+            })));
         }
     };
 }
+class PointerSourceError extends Error {
+    constructor(status) {
+        super(`pointer source ${status}`);
+        this.status = status;
+        this.name = "PointerSourceError";
+    }
+}
+const FETCH_ATTEMPTS = 3;
+const RETRY_BASE_MS = 250;
+const RETRY_MAX_MS = 2000;
+const FALLBACK_RECHECK_MS = 5 * 60000;
+/**
+ * Retries transient failures. Every vault's venues now ride on this one
+ * request, and callers keep a failed discover rather than retrying it.
+ */
+async function fetchPlacements(url) {
+    for (let attempt = 1;; attempt++) {
+        let waitMs;
+        try {
+            const response = await fetch(url, {
+                headers: { Accept: "application/json" }
+            });
+            if (response.ok) {
+                const body = (await response.json());
+                return body.placements ?? [];
+            }
+            if (!isTransientStatus(response.status) || attempt >= FETCH_ATTEMPTS) {
+                throw new PointerSourceError(response.status);
+            }
+            waitMs = retryAfterMs(response.headers?.get("retry-after"));
+            // Retrying before the server asked would only add to the load it
+            // is shedding and fail again.
+            if (waitMs !== undefined && waitMs > RETRY_MAX_MS) {
+                throw new PointerSourceError(response.status);
+            }
+        }
+        catch (error) {
+            // fetch rejects only on network failure; retry that, not our own
+            // errors or an abort.
+            if (error instanceof PointerSourceError ||
+                isAbortError(error) ||
+                attempt >= FETCH_ATTEMPTS) {
+                throw error;
+            }
+        }
+        const backoff = Math.min(RETRY_BASE_MS * 2 ** (attempt - 1), RETRY_MAX_MS);
+        await new Promise(resolve => setTimeout(resolve, waitMs ?? backoff));
+    }
+}
+/**
+ * Coin identity across spellings. `coinTypesMatch` folds a Sui address; EVM
+ * addresses are compared case-insensitively and with or without `0x`, since
+ * the API returns them lowercased and the vaults list checksums them.
+ */
+function coinKey(coin) {
+    const normalized = normalizeCoinType(coin);
+    return normalized.includes("::") ? normalized : normalized.replace(/^0x/, "");
+}
 /**
  * Merges what every source returns, de-duplicated by venue. Earlier sources win,
  * so a caller can pin rows ahead of a remote set. A source that throws is

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@ember-finance/sdk",
     "description": "Ember Protocol SDK",
-    "version": "2.15.0",
+    "version": "2.16.0",
     "type": "module",
     "module": "./dist/index.js",
     "main": "./dist/index.js",