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

package/dist/src/placements/batch.js

@@ -1,197 +0,0 @@
-export class TransientError extends Error {
-    constructor(message, retryAfterMs) {
-        super(message);
-        this.name = "TransientError";
-        this.retryAfterMs = retryAfterMs;
-    }
-}
-export class ChunkTooLargeError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ChunkTooLargeError";
-    }
-}
-export class AbortedError extends Error {
-    constructor(message = "aborted") {
-        super(message);
-        this.name = "AbortedError";
-    }
-}
-export function retryAfterMs(header) {
-    if (!header)
-        return undefined;
-    const seconds = Number(header);
-    if (Number.isFinite(seconds))
-        return Math.max(0, seconds * 1000);
-    const at = Date.parse(header);
-    return Number.isNaN(at) ? undefined : Math.max(0, at - Date.now());
-}
-export function isTransientStatus(status) {
-    return status === 429 || status >= 500;
-}
-export function isAbortError(error) {
-    return (error instanceof AbortedError ||
-        (error instanceof Error && error.name === "AbortError"));
-}
-const defaultSleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-const defaultSchedule = (flush) => {
-    setTimeout(flush, 0);
-};
-export class Batcher {
-    constructor(options) {
-        this.queue = [];
-        this.inFlight = new Map();
-        this.waiting = [];
-        this.active = 0;
-        this.scheduled = false;
-        this.send = options.send;
-        this.key = options.key;
-        this.weight = options.weight ?? (() => 1);
-        this.bytes = options.bytes ?? (() => 0);
-        this.maxWeight = options.maxWeight ?? 10;
-        this.maxBytes = options.maxBytes ?? Number.POSITIVE_INFINITY;
-        this.concurrency = options.concurrency ?? 3;
-        this.retries = options.retries ?? 3;
-        this.baseDelayMs = options.baseDelayMs ?? 300;
-        this.maxDelayMs = options.maxDelayMs ?? 10000;
-        this.sleep = options.sleep ?? defaultSleep;
-        this.schedule = options.schedule ?? defaultSchedule;
-        this.signal = options.signal;
-    }
-    enqueue(item) {
-        if (this.signal?.aborted)
-            return Promise.reject(new AbortedError());
-        const key = this.key(item);
-        const shared = this.inFlight.get(key);
-        if (shared)
-            return shared;
-        const promise = new Promise((resolve, reject) => {
-            this.queue.push({ item, resolve, reject });
-        });
-        this.inFlight.set(key, promise);
-        const forget = () => {
-            if (this.inFlight.get(key) === promise)
-                this.inFlight.delete(key);
-        };
-        promise.then(forget, forget);
-        this.scheduleFlush();
-        return promise;
-    }
-    scheduleFlush() {
-        if (this.scheduled)
-            return;
-        this.scheduled = true;
-        this.schedule(() => {
-            this.scheduled = false;
-            this.flush();
-        });
-    }
-    flush() {
-        const pending = this.queue.splice(0);
-        for (const chunk of this.chunk(pending)) {
-            void this.run(chunk, 1);
-        }
-    }
-    chunk(pending) {
-        const chunks = [];
-        let current = [];
-        let weight = 0;
-        let bytes = 0;
-        for (const entry of pending) {
-            const entryWeight = this.weight(entry.item);
-            const entryBytes = this.bytes(entry.item);
-            const overflows = weight + entryWeight > this.maxWeight ||
-                bytes + entryBytes > this.maxBytes;
-            if (current.length > 0 && overflows) {
-                chunks.push(current);
-                current = [];
-                weight = 0;
-                bytes = 0;
-            }
-            current.push(entry);
-            weight += entryWeight;
-            bytes += entryBytes;
-        }
-        if (current.length > 0)
-            chunks.push(current);
-        return chunks;
-    }
-    async run(chunk, attempt) {
-        if (this.signal?.aborted) {
-            for (const entry of chunk)
-                entry.reject(new AbortedError());
-            return;
-        }
-        await this.acquire();
-        let results;
-        try {
-            results = await this.send(chunk.map(entry => entry.item), attempt);
-        }
-        catch (error) {
-            this.release();
-            if (error instanceof ChunkTooLargeError && chunk.length > 1) {
-                const half = Math.ceil(chunk.length / 2);
-                void this.run(chunk.slice(0, half), 1);
-                void this.run(chunk.slice(half), 1);
-                return;
-            }
-            if (error instanceof TransientError && attempt <= this.retries) {
-                await this.retryLater(chunk, attempt, error.retryAfterMs);
-                return;
-            }
-            const failure = error instanceof Error ? error : new Error(String(error));
-            for (const entry of chunk)
-                entry.reject(failure);
-            return;
-        }
-        this.release();
-        const throttled = [];
-        let retryAfter;
-        chunk.forEach((entry, index) => {
-            const result = results[index];
-            if (result === undefined) {
-                entry.reject(new Error("batch: no result for item"));
-                return;
-            }
-            if (result.ok === true) {
-                entry.resolve(result.value);
-                return;
-            }
-            if (result.error instanceof TransientError && attempt <= this.retries) {
-                throttled.push(entry);
-                retryAfter = retryAfter ?? result.error.retryAfterMs;
-                return;
-            }
-            entry.reject(result.error);
-        });
-        if (throttled.length > 0)
-            await this.retryLater(throttled, attempt, retryAfter);
-    }
-    async retryLater(chunk, attempt, retryAfter) {
-        await this.sleep(Math.min(retryAfter ?? this.backoff(attempt), this.maxDelayMs));
-        void this.run(chunk, attempt + 1);
-    }
-    backoff(attempt) {
-        const base = this.baseDelayMs * 2 ** (attempt - 1);
-        const jitter = base * 0.3 * (Math.random() * 2 - 1);
-        return Math.round(base + jitter);
-    }
-    acquire() {
-        if (this.active < this.concurrency) {
-            this.active += 1;
-            return Promise.resolve();
-        }
-        return new Promise(resolve => {
-            this.waiting.push(() => {
-                this.active += 1;
-                resolve();
-            });
-        });
-    }
-    release() {
-        this.active -= 1;
-        const next = this.waiting.shift();
-        if (next)
-            next();
-    }
-}

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

@@ -1,17 +0,0 @@
-import { AccountShares, PlacementsContext, ProtocolId } from "./types.js";
-export interface ForAccountOptions {
-    /** Restrict to these protocols. Defaults to every registered adapter. */
-    protocols?: ProtocolId[];
-}
-export declare class PlacementsClient {
-    private readonly ctx;
-    constructor(ctx: PlacementsContext);
-    /** One vault, one account. */
-    forAccount(vaultId: string, account: string, options?: ForAccountOptions): Promise<AccountShares[]>;
-    forAccounts(vaultIds: string[], account: string, options?: ForAccountOptions): Promise<AccountShares[]>;
-    private sharesForCoin;
-    private walletBalance;
-    private coveredBalance;
-    private placementsForCoin;
-    private select;
-}

package/dist/src/placements/client.js

@@ -1,194 +0,0 @@
-import { asContractAddress, decodeUint256, encodeBalanceOf } from "./evm.js";
-import { getAdapter, listAdapters } from "./registry.js";
-function reasonOf(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-/**
- * Resolves what one account holds of a vault's shares: in its wallet, wrapped
- * for cover, and deployed elsewhere.
- *
- * A protocol that fails is reported in `failures` rather than thrown, so a
- * single unreachable protocol does not zero an otherwise valid answer.
- */
-/**
- * Whether `account` could be an address on this chain.
- *
- * Only one direction is decidable: a 32-byte sui address fed to
- * `balanceOf(address)` overflows the 20-byte word and the node reverts, so it
- * is certainly not evm. A 20-byte address is a valid short-form sui address,
- * so the reverse cannot be ruled out and is left to the chain to answer.
- */
-function addressFits(chain, account) {
-    const hex = account.trim().replace(/^0x/i, "");
-    if (!/^[0-9a-fA-F]+$/.test(hex))
-        return false;
-    return chain === "evm" ? hex.length <= 40 : hex.length <= 64;
-}
-function unresolvedVault(vaultId, reason) {
-    return {
-        vaultId,
-        coin: { coin: "", chain: { type: "sui" }, decimals: 0 },
-        available: "0",
-        covered: undefined,
-        placements: [],
-        failures: [{ protocol: "vault", stage: "discover", reason }],
-        unresolved: true
-    };
-}
-export class PlacementsClient {
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    /** One vault, one account. */
-    async forAccount(vaultId, account, options = {}) {
-        if (!this.ctx.vaults)
-            throw new Error("no vault resolver configured");
-        const coins = await this.ctx.vaults.coinsForVault(vaultId);
-        return Promise.all(coins.map(coin => this.sharesForCoin(vaultId, coin, account, options)));
-    }
-    async forAccounts(vaultIds, account, options = {}) {
-        if (!this.ctx.vaults)
-            throw new Error("no vault resolver configured");
-        const vaults = this.ctx.vaults;
-        const resolved = await Promise.all(vaultIds.map(async (vaultId) => {
-            try {
-                const coins = await vaults.coinsForVault(vaultId);
-                if (!Array.isArray(coins) || coins.length === 0) {
-                    return {
-                        vaultId,
-                        coins: undefined,
-                        reason: "resolver returned no coins"
-                    };
-                }
-                return { vaultId, coins };
-            }
-            catch (error) {
-                return { vaultId, coins: undefined, reason: reasonOf(error) };
-            }
-        }));
-        return Promise.all(resolved.flatMap(entry => entry.coins
-            ? entry.coins.map(coin => this.sharesForCoin(entry.vaultId, coin, account, options))
-            : [
-                Promise.resolve(unresolvedVault(entry.vaultId, entry.reason ?? ""))
-            ]));
-    }
-    async sharesForCoin(vaultId, coin, account, options) {
-        const failures = [];
-        // A vault on several chains issues a coin on each, so for any one
-        // account all but one of them belongs to a wallet it does not have.
-        // Holding none of it is the true answer, and cheaper than asking.
-        if (!addressFits(coin.chain.type, account)) {
-            return {
-                vaultId,
-                coin,
-                available: "0",
-                covered: undefined,
-                placements: [],
-                failures
-            };
-        }
-        const [available, covered, placements] = await Promise.all([
-            this.walletBalance(coin, account).catch(error => {
-                failures.push({
-                    protocol: "wallet",
-                    stage: "read",
-                    coin: coin.coin,
-                    reason: reasonOf(error)
-                });
-                return "0";
-            }),
-            this.coveredBalance(coin, account).catch(error => {
-                failures.push({
-                    protocol: "opencover",
-                    stage: "read",
-                    coin: coin.coin,
-                    reason: reasonOf(error)
-                });
-                return undefined;
-            }),
-            this.placementsForCoin(coin, account, options, failures)
-        ]);
-        return { vaultId, coin, available, covered, placements, failures };
-    }
-    async walletBalance(coin, account) {
-        if (coin.chain.type === "sui") {
-            if (!this.ctx.sui)
-                throw new Error("no sui reader configured");
-            return this.ctx.sui.balance(account, coin.coin);
-        }
-        if (!this.ctx.evm)
-            throw new Error("no evm reader configured");
-        const chainId = coin.chain.chainId;
-        if (chainId === undefined)
-            throw new Error(`${coin.coin} has no chainId`);
-        const raw = await this.ctx.evm.call(chainId, asContractAddress(coin.coin), encodeBalanceOf(account), coin.rpcUrl);
-        return decodeUint256(raw).toString();
-    }
-    async coveredBalance(coin, account) {
-        const coverVault = await this.ctx.vaults?.coverVault?.(coin);
-        if (!coverVault)
-            return undefined;
-        if (!this.ctx.evm)
-            throw new Error("no evm reader configured");
-        const chainId = coin.chain.chainId;
-        if (chainId === undefined)
-            throw new Error(`${coin.coin} has no chainId`);
-        const raw = await this.ctx.evm.call(chainId, asContractAddress(coverVault), encodeBalanceOf(account), coin.rpcUrl);
-        return decodeUint256(raw).toString();
-    }
-    async placementsForCoin(coin, account, options, failures) {
-        const adapters = this.select(options.protocols, failures).filter(adapter => adapter.chain === coin.chain.type);
-        const discovered = await Promise.allSettled(adapters.map(adapter => adapter.discover(coin, this.ctx)));
-        const jobs = [];
-        discovered.forEach((result, index) => {
-            const adapter = adapters[index];
-            if (result.status === "rejected") {
-                failures.push({
-                    protocol: adapter.id,
-                    stage: "discover",
-                    coin: coin.coin,
-                    reason: reasonOf(result.reason)
-                });
-                return;
-            }
-            if (result.value.length > 0)
-                jobs.push({ adapter, refs: result.value });
-        });
-        // One read per adapter rather than per venue, so an adapter can batch
-        // every pointer it owns into as few chain round-trips as it can manage.
-        const read = await Promise.allSettled(jobs.map(job => job.adapter.read(job.refs, account, this.ctx)));
-        const placements = [];
-        read.forEach((result, index) => {
-            const { adapter } = jobs[index];
-            if (result.status === "rejected") {
-                failures.push({
-                    protocol: adapter.id,
-                    stage: "read",
-                    coin: coin.coin,
-                    reason: reasonOf(result.reason)
-                });
-                return;
-            }
-            placements.push(...result.value);
-        });
-        return placements;
-    }
-    select(protocols, failures) {
-        if (!protocols)
-            return listAdapters();
-        const selected = [];
-        for (const id of protocols) {
-            const adapter = getAdapter(id);
-            if (!adapter) {
-                failures.push({
-                    protocol: id,
-                    stage: "discover",
-                    reason: "no adapter registered"
-                });
-                continue;
-            }
-            selected.push(adapter);
-        }
-        return selected;
-    }
-}

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

@@ -1,29 +0,0 @@
-import { EvmReader } from "./types.js";
-import { TransportRequest } from "./batch.js";
-export type { TransportRequest } from "./batch.js";
-export declare function encodeBalanceOf(owner: string): string;
-export declare function asContractAddress(address: string): string;
-export declare function decodeUint256(hex: string): bigint;
-export interface JsonRpcEvmReaderOptions {
-    maxCalls?: number;
-    concurrency?: number;
-    retries?: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-    sleep?: (ms: number) => Promise<void>;
-    fetch?: typeof globalThis.fetch;
-    signal?: AbortSignal;
-    onRequest?: (request: TransportRequest) => void;
-    multicall?: boolean;
-}
-interface EvmCall {
-    to: string;
-    data: string;
-}
-export declare const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
-export declare function encodeAggregate3(calls: EvmCall[]): string;
-export declare function decodeAggregate3(data: string, count: number): {
-    success: boolean;
-    data: string;
-}[];
-export declare function jsonRpcEvmReader(endpoints?: Record<number, string>, options?: JsonRpcEvmReaderOptions): EvmReader;