@ember-finance/sdk 2.11.0-pre.7 → 2.11.0

package/dist/src/placements/evm.js

@@ -1,280 +0,0 @@
-import { Batcher, ChunkTooLargeError, TransientError, isAbortError, isTransientStatus, retryAfterMs } from "./batch.js";
-/** `balanceOf(address)` */
-const BALANCE_OF_SELECTOR = "0x70a08231";
-export function encodeBalanceOf(owner) {
-    const address = owner.toLowerCase().replace(/^0x/, "").padStart(64, "0");
-    return `${BALANCE_OF_SELECTOR}${address}`;
-}
-export function asContractAddress(address) {
-    // An EVM node rejects an unprefixed `to` outright rather than coercing it,
-    // so a pointer carrying a bare address would fail the whole read.
-    const trimmed = address.trim();
-    return trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
-}
-export function decodeUint256(hex) {
-    if (!hex || hex === "0x")
-        return 0n;
-    return BigInt(hex);
-}
-export const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
-const AGGREGATE3_SELECTOR = "0x82ad56cb";
-const RATE_LIMITED = /too many requests|rate ?limit/i;
-const HEX = /^(0x)?[0-9a-fA-F]*$/;
-class HttpError extends Error {
-    constructor(status) {
-        super(`evm rpc ${status}`);
-        this.name = "HttpError";
-        this.status = status;
-    }
-}
-function stripHex(value) {
-    return value.trim().replace(/^0x/i, "");
-}
-function word(value) {
-    return BigInt(value).toString(16).padStart(64, "0");
-}
-function addressWord(address) {
-    return stripHex(address).toLowerCase().padStart(64, "0");
-}
-function bytesWords(data) {
-    const raw = stripHex(data);
-    const length = raw.length / 2;
-    const padded = raw.padEnd(Math.ceil(length / 32) * 64, "0");
-    return word(length) + padded;
-}
-export function encodeAggregate3(calls) {
-    const tuples = calls.map(call => addressWord(call.to) + word(1) + word(0x60) + bytesWords(call.data));
-    let offset = calls.length * 32;
-    const offsets = tuples.map(tuple => {
-        const current = offset;
-        offset += tuple.length / 2;
-        return word(current);
-    });
-    return (AGGREGATE3_SELECTOR +
-        word(0x20) +
-        word(calls.length) +
-        offsets.join("") +
-        tuples.join(""));
-}
-export function decodeAggregate3(data, count) {
-    const raw = stripHex(data);
-    const read = (byteOffset) => {
-        const slice = raw.slice(byteOffset * 2, byteOffset * 2 + 64);
-        if (slice.length !== 64)
-            throw new Error("multicall: truncated response");
-        return Number(BigInt(`0x${slice}`));
-    };
-    const arrayOffset = read(0);
-    const length = read(arrayOffset);
-    if (length !== count)
-        throw new Error("multicall: result count mismatch");
-    const base = arrayOffset + 32;
-    const results = [];
-    for (let index = 0; index < length; index += 1) {
-        const tupleOffset = base + read(base + index * 32);
-        const success = read(tupleOffset) === 1;
-        const bytesOffset = tupleOffset + read(tupleOffset + 32);
-        const bytesLength = read(bytesOffset);
-        const start = (bytesOffset + 32) * 2;
-        const body = raw.slice(start, start + bytesLength * 2);
-        if (body.length !== bytesLength * 2)
-            throw new Error("multicall: truncated response");
-        results.push({ success, data: `0x${body}` });
-    }
-    return results;
-}
-function jsonRpcRequest(method, params, id) {
-    return { jsonrpc: "2.0", id, method, params };
-}
-function callRequest(call, id) {
-    return jsonRpcRequest("eth_call", [{ to: call.to, data: call.data }, "latest"], id);
-}
-function isRateLimited(entry) {
-    const error = entry?.error;
-    if (!error)
-        return false;
-    return error.code === -32005 || RATE_LIMITED.test(error.message ?? "");
-}
-function toResult(entry) {
-    if (!entry)
-        return { ok: false, error: new Error("evm rpc: no result for call") };
-    if (isRateLimited(entry)) {
-        return {
-            ok: false,
-            error: new TransientError(`evm rpc: ${entry.error?.message}`)
-        };
-    }
-    if (entry.error)
-        return { ok: false, error: new Error(`evm rpc: ${entry.error.message}`) };
-    return { ok: true, value: entry.result ?? "0x" };
-}
-function validateCall(to, data) {
-    const address = stripHex(to);
-    if (!HEX.test(to) || address.length !== 40) {
-        throw new Error(`evm rpc: ${to} is not a contract address`);
-    }
-    const calldata = stripHex(data);
-    if (!HEX.test(data) || calldata.length % 2 !== 0) {
-        throw new Error(`evm rpc: calldata ${data} is not even-length hex`);
-    }
-}
-export function jsonRpcEvmReader(endpoints = {}, options = {}) {
-    const fetchImpl = options.fetch ??
-        ((input, init) => globalThis.fetch(input, init));
-    const onRequest = options.onRequest;
-    const useMulticall = options.multicall ?? false;
-    const batchers = new Map();
-    const modes = new Map();
-    const probes = new Map();
-    const post = async (endpoint, body, items, attempt) => {
-        let response;
-        try {
-            response = await fetchImpl(endpoint, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(body),
-                signal: options.signal
-            });
-        }
-        catch (error) {
-            if (isAbortError(error))
-                throw error;
-            onRequest?.({ items, attempt, status: "network-error" });
-            throw new TransientError(`evm rpc: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        onRequest?.({ items, attempt, status: response.status });
-        if (isTransientStatus(response.status)) {
-            throw new TransientError(`evm rpc ${response.status}`, retryAfterMs(response.headers?.get("retry-after")));
-        }
-        if (!response.ok)
-            throw new HttpError(response.status);
-        return response;
-    };
-    const rpc = async (endpoint, method, params, items, attempt) => {
-        const response = await post(endpoint, jsonRpcRequest(method, params, 1), items, attempt);
-        const parsed = (await response.json());
-        const entry = Array.isArray(parsed) ? parsed[0] : parsed;
-        if (isRateLimited(entry))
-            throw new TransientError(`evm rpc: ${entry?.error?.message}`);
-        return entry ?? {};
-    };
-    const detectMode = (endpoint, attempt) => {
-        const known = modes.get(endpoint);
-        if (known)
-            return Promise.resolve(known);
-        if (!useMulticall) {
-            modes.set(endpoint, "batch");
-            return Promise.resolve("batch");
-        }
-        const pending = probes.get(endpoint);
-        if (pending)
-            return pending;
-        const probe = (async () => {
-            let mode = "batch";
-            try {
-                const code = await rpc(endpoint, "eth_getCode", [MULTICALL3_ADDRESS, "latest"], 1, attempt);
-                if (!code.error && stripHex(code.result ?? "").length > 2)
-                    mode = "multicall";
-            }
-            catch (error) {
-                if (error instanceof TransientError || isAbortError(error))
-                    throw error;
-            }
-            modes.set(endpoint, mode);
-            return mode;
-        })();
-        probes.set(endpoint, probe);
-        const clear = () => probes.delete(endpoint);
-        probe.then(clear, clear);
-        return probe;
-    };
-    const sendMulticall = async (endpoint, calls, attempt) => {
-        let entry;
-        try {
-            entry = await rpc(endpoint, "eth_call", [{ to: MULTICALL3_ADDRESS, data: encodeAggregate3(calls) }, "latest"], calls.length, attempt);
-        }
-        catch (error) {
-            if (error instanceof TransientError || isAbortError(error))
-                throw error;
-            return undefined;
-        }
-        if (entry.error || !entry.result)
-            return undefined;
-        let decoded;
-        try {
-            decoded = decodeAggregate3(entry.result, calls.length);
-        }
-        catch {
-            return undefined;
-        }
-        return decoded.map(result => result.success
-            ? { ok: true, value: result.data }
-            : { ok: false, error: new Error("evm rpc: execution reverted") });
-    };
-    const sendBatch = async (endpoint, calls, attempt) => {
-        let response;
-        try {
-            response = await post(endpoint, calls.map((call, id) => callRequest(call, id)), calls.length, attempt);
-        }
-        catch (error) {
-            if (error instanceof HttpError) {
-                modes.set(endpoint, "single");
-                throw new ChunkTooLargeError(error.message);
-            }
-            throw error;
-        }
-        const parsed = (await response.json());
-        if (!Array.isArray(parsed)) {
-            modes.set(endpoint, "single");
-            throw new ChunkTooLargeError("evm rpc: batch unsupported");
-        }
-        const byId = new Map(parsed.map(entry => [Number(entry.id), entry]));
-        return calls.map((_, id) => toResult(byId.get(id)));
-    };
-    const sendSingle = async (endpoint, call, attempt) => {
-        const response = await post(endpoint, callRequest(call, 1), 1, attempt);
-        const parsed = (await response.json());
-        return [toResult(Array.isArray(parsed) ? parsed[0] : parsed)];
-    };
-    const send = async (endpoint, calls, attempt) => {
-        if (calls.length === 1)
-            return sendSingle(endpoint, calls[0], attempt);
-        const mode = await detectMode(endpoint, attempt);
-        if (mode === "single")
-            throw new ChunkTooLargeError("evm rpc: batch unsupported");
-        if (mode === "multicall") {
-            const aggregated = await sendMulticall(endpoint, calls, attempt);
-            if (aggregated)
-                return aggregated;
-            modes.set(endpoint, "batch");
-        }
-        return sendBatch(endpoint, calls, attempt);
-    };
-    const batcherFor = (endpoint) => {
-        const existing = batchers.get(endpoint);
-        if (existing)
-            return existing;
-        const batcher = new Batcher({
-            send: (calls, attempt) => send(endpoint, calls, attempt),
-            key: call => `${call.to.toLowerCase()}:${call.data.toLowerCase()}`,
-            maxWeight: options.maxCalls ?? 20,
-            concurrency: options.concurrency,
-            retries: options.retries,
-            baseDelayMs: options.baseDelayMs,
-            maxDelayMs: options.maxDelayMs,
-            sleep: options.sleep,
-            signal: options.signal
-        });
-        batchers.set(endpoint, batcher);
-        return batcher;
-    };
-    return {
-        async call(chainId, to, data, override) {
-            const endpoint = override ?? endpoints[chainId];
-            if (!endpoint)
-                throw new Error(`no evm endpoint for chain ${chainId}`);
-            validateCall(to, data);
-            return batcherFor(endpoint).enqueue({ to, data });
-        }
-    };
-}

package/dist/src/placements/index.d.ts

@@ -1,9 +0,0 @@
-export * from "./types.js";
-export { AbortedError, isAbortError } from "./batch.js";
-export * from "./registry.js";
-export * from "./client.js";
-export * from "./pointers.js";
-export * from "./vaults.js";
-export * from "./sui.js";
-export * from "./evm.js";
-export * from "./adapters/index.js";

package/dist/src/placements/index.js

@@ -1,9 +0,0 @@
-export * from "./types.js";
-export { AbortedError, isAbortError } from "./batch.js";
-export * from "./registry.js";
-export * from "./client.js";
-export * from "./pointers.js";
-export * from "./vaults.js";
-export * from "./sui.js";
-export * from "./evm.js";
-export * from "./adapters/index.js";

package/dist/src/placements/pointers.d.ts

@@ -1,24 +0,0 @@
-import { PlatformEnv } from "../common/constants.js";
-import { PlacementRef, PointerSource } from "./types.js";
-/**
- * Pointers held in memory. Useful for tests, and for pinning a known venue set
- * without a round-trip.
- */
-export declare function staticPointerSource(refs: PlacementRef[]): PointerSource;
-export interface HttpPointerSourceOptions {
-    /** Vaults API environment. Defaults to prod. */
-    env?: PlatformEnv;
-    /** Overrides `env` entirely. For a local deployment, or a proxy. */
-    baseUrl?: string;
-    path?: string;
-    /** How long a coin's rows may be reused, in milliseconds. Default 30s. */
-    cacheMs?: number;
-}
-/** Pointers from the vaults API. Defaults to prod. */
-export declare function httpPointerSource(options?: HttpPointerSourceOptions): PointerSource;
-/**
- * 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
- * skipped rather than failing the set.
- */
-export declare function mergePointerSources(...sources: PointerSource[]): PointerSource;

package/dist/src/placements/pointers.js

@@ -1,126 +0,0 @@
-import { environmentConfig } from "../common/constants.js";
-import { coinTypesMatch } from "./sui.js";
-/**
- * Pointers held in memory. Useful for tests, and for pinning a known venue set
- * without a round-trip.
- */
-export function staticPointerSource(refs) {
-    return {
-        // Coins are compared with `coinTypesMatch` rather than by string
-        // equality, so a row pinned in one spelling still matches a caller
-        // passing another — a short Sui address against its padded form, say.
-        // Exact matching would fail by returning nothing, which reads as
-        // "listed nowhere".
-        async placements(protocol, coin) {
-            return refs.filter(ref => ref.protocol === protocol && coinTypesMatch(ref.coin, coin.coin));
-        }
-    };
-}
-/**
- * Decimals scale every amount an adapter returns, so a missing or malformed
- * value is a silent power-of-ten error rather than a visible failure.
- */
-function requireDecimals(row) {
-    if (!Number.isInteger(row.decimals)) {
-        throw new Error(`placement ${row.protocol}/${row.venue} has no decimals`);
-    }
-    return row.decimals;
-}
-/** Pointers from the vaults API. Defaults to prod. */
-export function httpPointerSource(options = {}) {
-    // The cache window exists to collapse the burst a single `forAccount`
-    // makes, not to cache across a session: pointers change when a venue is
-    // added, and a long window would keep a new one invisible.
-    const baseUrl = options.baseUrl ?? environmentConfig[options.env ?? "prod"].apiHost;
-    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.
-     *
-     * 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();
-        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
-            }));
-        })();
-        // 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;
-    };
-    return {
-        async placements(protocol, coin) {
-            const rows = await rowsForCoin(coin);
-            return rows.filter(ref => ref.protocol === protocol);
-        }
-    };
-}
-/**
- * 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
- * skipped rather than failing the set.
- */
-export function mergePointerSources(...sources) {
-    return {
-        async placements(protocol, coin) {
-            const results = await Promise.allSettled(sources.map(source => source.placements(protocol, coin)));
-            const byVenue = new Map();
-            for (const result of results) {
-                if (result.status !== "fulfilled")
-                    continue;
-                for (const ref of result.value) {
-                    // Key on the chain type as well as its id: an evm row whose
-                    // chainId is absent would otherwise land in the same slot as
-                    // a sui row at the same venue string and silently replace it.
-                    const key = `${ref.chain.type}:${ref.chain.chainId ?? ""}:${ref.venue.toLowerCase()}`;
-                    if (!byVenue.has(key))
-                        byVenue.set(key, ref);
-                }
-            }
-            return [...byVenue.values()];
-        }
-    };
-}

package/dist/src/placements/registry.d.ts

@@ -1,11 +0,0 @@
-import { ChainType } from "../common/constants.js";
-import { ProtocolAdapter, ProtocolId } from "./types.js";
-/**
- * Add a protocol. Re-registering an id replaces it, so a consumer can override
- * a bundled adapter without forking the module.
- */
-export declare function registerAdapter(adapter: ProtocolAdapter): void;
-export declare function getAdapter(id: ProtocolId): ProtocolAdapter | undefined;
-export declare function listAdapters(chain?: ChainType): ProtocolAdapter[];
-/** Drops every registration. Intended for tests. */
-export declare function resetAdapters(): void;

package/dist/src/placements/registry.js

@@ -1,19 +0,0 @@
-const adapters = new Map();
-/**
- * Add a protocol. Re-registering an id replaces it, so a consumer can override
- * a bundled adapter without forking the module.
- */
-export function registerAdapter(adapter) {
-    adapters.set(adapter.id, adapter);
-}
-export function getAdapter(id) {
-    return adapters.get(id);
-}
-export function listAdapters(chain) {
-    const all = [...adapters.values()];
-    return chain ? all.filter(adapter => adapter.chain === chain) : all;
-}
-/** Drops every registration. Intended for tests. */
-export function resetAdapters() {
-    adapters.clear();
-}

package/dist/src/placements/sui.d.ts

@@ -1,47 +0,0 @@
-import { SuiReader } from "./types.js";
-import { TransportRequest } from "./batch.js";
-export type { TransportRequest } from "./batch.js";
-/**
- * Canonical form for a Sui coin type: `0x` stripped from the address segment,
- * lowercased and left-padded to 64 hex chars.
- *
- * Object JSON returns unprefixed padded types ("0000..02::sui::SUI") while
- * config and RPC use the short prefixed form ("0x2::sui::SUI"). Comparing the
- * two without normalising silently never matches.
- *
- * Only the address is folded. It is hex, so case is not significant there, but
- * the module and struct names are Move identifiers and two that differ only in
- * case are two different types.
- */
-export declare function normalizeCoinType(coinType: string): string;
-export declare function coinTypesMatch(a: string, b: string): boolean;
-/**
- * A Sui address as GraphQL wants a dynamic-field key: base64 of its BCS
- * encoding, which for an address is simply its 32 raw bytes.
- */
-export declare function bcsAddress(address: string): string;
-/** Type arguments of a Move type, e.g. `Pool<A, B>` -> ["A", "B"]. */
-export declare function typeArguments(type: string): string[];
-/** The object id a Move table's entries actually hang off. */
-export declare function tableId(field: unknown): string | undefined;
-/**
- * Some protocols wrap fixed-point numbers as `{ value }` scaled by 1e18.
- * Returns base units, truncated — these feed balances, not accounting.
- */
-export declare function decimalToBaseUnits(field: unknown): bigint;
-export declare function toBigInt(field: unknown): bigint;
-export declare const DEFAULT_SUI_GRAPHQL_ENDPOINT = "https://graphql.mainnet.sui.io/graphql";
-export interface GraphqlSuiReaderOptions {
-    endpoint?: string;
-    maxRootFields?: number;
-    maxBytes?: number;
-    concurrency?: number;
-    retries?: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-    sleep?: (ms: number) => Promise<void>;
-    fetch?: typeof globalThis.fetch;
-    signal?: AbortSignal;
-    onRequest?: (request: TransportRequest) => void;
-}
-export declare function graphqlSuiReader(options?: string | GraphqlSuiReaderOptions): SuiReader;