tapimo 0.7.1 → 0.7.2

package/dist/apps/data/FundingQuoteProviders.js

@@ -1,775 +0,0 @@
-import * as z from 'zod/mini';
-import * as FundingQuotes from '../../internal/FundingQuotes.js';
-import * as Store from '../../internal/Store.js';
-const defaultFetch = (input, init) => globalThis.fetch(input, init);
-const defaultAcrossBaseUrl = 'https://app.across.to/api';
-const defaultRelayBaseUrl = 'https://api.relay.link';
-const defaultRhinoBaseUrl = 'https://api.rhino.fi/bridge';
-const defaultSquidBaseUrl = 'https://v2.api.squidrouter.com/v2';
-const defaultSymbiosisBaseUrl = 'https://api.symbiosis.finance/crosschain';
-// Keep one upstream slot free for deployment smoke tests and operational probes.
-const symbiosisRateLimit = 4;
-const symbiosisRateLimitWindowMs = 1_000;
-const providerOperations = {
-    across: 'swap/approval',
-    relay: 'quote/v2',
-    rhino: 'quote/bridge-swap/public',
-    squid: 'v2/route',
-    symbiosis: 'v2/quote',
-};
-/** Returns the stable upstream operation used by a funding quote provider. */
-export function providerOperation(provider) {
-    return providerOperations[provider];
-}
-var schema;
-(function (schema) {
-    const IntegerString = z.string().check(z.regex(/^\d+$/));
-    const AcrossToken = z.object({
-        address: z.string(),
-        chainId: z.number().check(z.int(), z.nonnegative()),
-        decimals: z.number().check(z.int(), z.nonnegative()),
-    });
-    schema.AcrossQuote = z.object({
-        amountType: z.literal('exactInput'),
-        expectedFillTime: z.number().check(z.int(), z.nonnegative()),
-        expectedOutputAmount: IntegerString,
-        inputAmount: IntegerString,
-        inputToken: AcrossToken,
-        minOutputAmount: IntegerString,
-        outputToken: AcrossToken,
-        quoteExpiryTimestamp: z.number().check(z.int(), z.nonnegative()),
-    });
-    schema.RhinoQuote = z.object({
-        _tag: z.literal('bridge'),
-        chainIn: z.string(),
-        chainOut: z.string(),
-        estimatedDuration: z.optional(z.nullable(z.number().check(z.nonnegative()))),
-        payAmount: z.string().check(z.regex(/^\d+(\.\d+)?$/)),
-        receiveAmount: z.string().check(z.regex(/^\d+(\.\d+)?$/)),
-        token: z.string(),
-    });
-    const SquidToken = z.object({
-        address: z.string(),
-        chainId: z.union([z.string(), z.number().check(z.int(), z.nonnegative())]),
-        decimals: z.number().check(z.int(), z.nonnegative()),
-    });
-    schema.SquidQuote = z.object({
-        route: z.object({
-            estimate: z.object({
-                estimatedRouteDuration: z.number().check(z.nonnegative()),
-                fromAmount: IntegerString,
-                fromToken: SquidToken,
-                toAmount: IntegerString,
-                toAmountMin: IntegerString,
-                toToken: SquidToken,
-            }),
-        }),
-    });
-    schema.SymbiosisToken = z.object({
-        address: z.string(),
-        chainId: z.number().check(z.int(), z.nonnegative()),
-        decimals: z.number().check(z.int(), z.nonnegative()),
-    });
-    const SymbiosisTokenAmount = z.extend(schema.SymbiosisToken, { amount: IntegerString });
-    schema.SymbiosisQuote = z.object({
-        estimatedTime: z.optional(z.number().check(z.nonnegative())),
-        kind: z.union([z.literal('bridge'), z.literal('crosschain-swap'), z.literal('intent-swap')]),
-        routes: z
-            .array(z.object({
-            tokens: z.array(schema.SymbiosisToken).check(z.minLength(1)),
-        }))
-            .check(z.minLength(1)),
-        tokenAmountOut: SymbiosisTokenAmount,
-        tokenAmountOutMin: SymbiosisTokenAmount,
-        tx: z.object({ chainId: z.number().check(z.int(), z.nonnegative()) }),
-        type: z.union([z.literal('evm'), z.literal('tron')]),
-    });
-})(schema || (schema = {}));
-/** Creates the live funding quote adapters configured for this deployment. */
-export function createAdapters(options = {}) {
-    return {
-        ...(options.across ? { across: across(options.across) } : {}),
-        ...(options.relay ? { relay: relay(options.relay) } : {}),
-        ...(options.rhino ? { rhino: rhino(options.rhino) } : {}),
-        ...(options.squid ? { squid: squid(options.squid) } : {}),
-        ...(options.symbiosis ? { symbiosis: symbiosis(options.symbiosis) } : {}),
-    };
-}
-/** Resolves all-or-none Across deployment configuration. */
-export function configureAcross(options = {}) {
-    const configured = [options.apiKey, options.integratorId, options.userAddress].filter(Boolean);
-    if (configured.length === 0)
-        return undefined;
-    if (!options.apiKey || !options.integratorId || !options.userAddress)
-        throw new ProviderConfigurationError();
-    return {
-        apiKey: options.apiKey,
-        integratorId: options.integratorId,
-        userAddress: options.userAddress,
-    };
-}
-/** Resolves all-or-none Squid deployment configuration. */
-export function configureSquid(options = {}) {
-    const configured = [options.integratorId, options.userAddress].filter(Boolean);
-    if (configured.length === 0)
-        return undefined;
-    if (!options.integratorId || !options.userAddress)
-        throw new ProviderConfigurationError();
-    return {
-        integratorId: options.integratorId,
-        userAddress: options.userAddress,
-    };
-}
-/** Resolves Symbiosis deployment configuration. */
-export function configureSymbiosis(options = {}) {
-    if (!options.userAddress)
-        return undefined;
-    return { userAddress: options.userAddress };
-}
-/** Creates an Across quote adapter backed by `/swap/approval`. */
-export function across(options) {
-    assertAcrossConfiguration(options);
-    const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultAcrossBaseUrl);
-    const fetcher = options.fetch ?? defaultFetch;
-    const now = options.now ?? (() => new Date());
-    return {
-        async probeQuote({ candidate }, signal) {
-            const destinationChainId = eip155ChainId(candidate.destinationChain);
-            const originChainId = providerChainId(candidate.sourceChain, 'across');
-            const url = new URL(`${baseUrl}/swap/approval`);
-            url.search = new URLSearchParams({
-                amount: candidate.sourceAmount.amount,
-                depositor: options.userAddress,
-                destinationChainId,
-                inputToken: candidate.sourceToken.address,
-                integratorId: options.integratorId,
-                originChainId,
-                outputToken: candidate.destinationToken.address,
-                recipient: options.userAddress,
-                skipOriginTxEstimation: 'true',
-                strictTradeType: 'true',
-                tradeType: 'exactInput',
-            }).toString();
-            try {
-                const quote = await requestJson(url, {
-                    fetcher,
-                    headers: { Authorization: `Bearer ${options.apiKey}` },
-                    signal,
-                });
-                return formatAcrossResult(candidate, quote, now());
-            }
-            catch (cause) {
-                const unavailable = providerUnavailable(cause, [
-                    'AMOUNT_TOO_HIGH',
-                    'AMOUNT_TOO_LOW',
-                    'INSUFFICIENT_LIQUIDITY',
-                    'NO_QUOTES',
-                    'NO_ROUTE',
-                    'UNSUPPORTED_ROUTE',
-                ]);
-                if (!unavailable)
-                    throw cause;
-                return unavailableResult({
-                    detail: 'across:swap-approval',
-                    message: unavailable,
-                    now: now(),
-                    source: 'providerQuote',
-                });
-            }
-        },
-    };
-}
-/** Creates a Relay quote adapter backed by `/quote/v2`. */
-export function relay(options) {
-    const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultRelayBaseUrl);
-    const fetcher = options.fetch ?? defaultFetch;
-    const now = options.now ?? (() => new Date());
-    return {
-        async probeQuote({ candidate }, signal) {
-            const originChainId = providerChainId(candidate.sourceChain, 'relay');
-            const destinationChainId = eip155ChainId(candidate.destinationChain);
-            const headers = relayHeaders(options.apiKey);
-            try {
-                const quote = await requestJson(new URL(`${baseUrl}/quote/v2`), {
-                    body: {
-                        amount: candidate.sourceAmount.amount,
-                        destinationChainId: Number(destinationChainId),
-                        destinationCurrency: candidate.destinationToken.address,
-                        originChainId: Number(originChainId),
-                        originCurrency: candidate.sourceToken.address,
-                        recipient: options.recipientAddress ?? options.userAddress,
-                        tradeType: 'EXACT_INPUT',
-                        user: options.userAddress,
-                    },
-                    fetcher,
-                    headers,
-                    method: 'POST',
-                    signal,
-                });
-                return formatRelayResult(quote, now());
-            }
-            catch (cause) {
-                const unavailable = providerUnavailable(cause, [
-                    'NO_QUOTES',
-                    'NO_ROUTE',
-                    'UNSUPPORTED_ROUTE',
-                ]);
-                if (!unavailable)
-                    throw cause;
-                return unavailableResult({
-                    detail: 'relay:quote-v2',
-                    message: unavailable,
-                    now: now(),
-                    source: 'providerQuote',
-                });
-            }
-        },
-    };
-}
-/** Creates a Rhino quote adapter backed by the public bridge-and-swap quote endpoint. */
-export function rhino(options = {}) {
-    const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultRhinoBaseUrl);
-    const fetcher = options.fetch ?? defaultFetch;
-    const now = options.now ?? (() => new Date());
-    return {
-        async probeQuote({ cache, candidate }, signal) {
-            const chainIn = providerChainReference(candidate.sourceChain, 'rhino');
-            const tokenOut = rhinoToken(candidate.destinationToken);
-            const url = new URL(`${baseUrl}/quote/bridge-swap/public`);
-            url.search = new URLSearchParams({
-                amount: candidate.sourceAmount.formatted,
-                amountNative: '0',
-                chainIn,
-                chainOut: 'TEMPO',
-                mode: 'pay',
-                tokenIn: candidate.sourceToken.symbol,
-                tokenOut,
-            }).toString();
-            try {
-                const quote = await requestJson(url, {
-                    fetcher,
-                    headers: cache.bypass ? { 'cache-control': 'no-cache' } : undefined,
-                    signal,
-                });
-                return formatRhinoResult(candidate, quote, { chainIn, now: now(), tokenOut });
-            }
-            catch (cause) {
-                const unavailable = providerUnavailable(cause, ['NoRouteFoundError']);
-                if (!unavailable)
-                    throw cause;
-                return unavailableResult({
-                    detail: 'rhino:bridge-swap-public',
-                    message: unavailable,
-                    now: now(),
-                    source: 'providerQuote',
-                });
-            }
-        },
-    };
-}
-/** Creates a Squid quote adapter backed by `/v2/route`. */
-export function squid(options) {
-    assertSquidConfiguration(options);
-    const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultSquidBaseUrl);
-    const fetcher = options.fetch ?? defaultFetch;
-    const now = options.now ?? (() => new Date());
-    return {
-        async probeQuote({ candidate }, signal) {
-            const fromChain = eip155ChainId(candidate.sourceChain);
-            const toChain = eip155ChainId(candidate.destinationChain);
-            try {
-                const quote = await requestJson(new URL(`${baseUrl}/route`), {
-                    body: {
-                        fromAddress: options.userAddress,
-                        fromAmount: candidate.sourceAmount.amount,
-                        fromChain,
-                        fromToken: candidate.sourceToken.address,
-                        quoteOnly: true,
-                        // V1 quotes use a fixed 1% tolerance; callers cannot customize execution policy.
-                        slippage: 1,
-                        toAddress: options.userAddress,
-                        toChain,
-                        toToken: candidate.destinationToken.address,
-                    },
-                    fetcher,
-                    headers: { 'x-integrator-id': options.integratorId },
-                    method: 'POST',
-                    signal,
-                });
-                return formatSquidResult(candidate, quote, now());
-            }
-            catch (cause) {
-                const unavailable = providerUnavailable(cause, [
-                    'NO_ROUTE',
-                    'NO_ROUTE_FOUND',
-                    'ROUTE_NOT_FOUND',
-                    'UNSUPPORTED_ROUTE',
-                ]) ?? squidUnavailable(cause);
-                if (!unavailable)
-                    throw cause;
-                return unavailableResult({
-                    detail: 'squid:route-v2',
-                    message: unavailable,
-                    now: now(),
-                    source: 'providerQuote',
-                });
-            }
-        },
-    };
-}
-/** Creates a Symbiosis quote adapter backed by `/v2/quote`. */
-export function symbiosis(options) {
-    assertUserAddress(options.userAddress);
-    const baseUrl = normalizeBaseUrl(options.baseUrl ?? defaultSymbiosisBaseUrl);
-    const fetcher = options.fetch ?? defaultFetch;
-    const now = options.now ?? (() => new Date());
-    const rateLimitStore = options.rateLimitStore ?? Store.memory();
-    return {
-        async probeQuote({ candidate }, signal) {
-            const fromChainId = Number(providerChainId(candidate.sourceChain, 'symbiosis'));
-            const fromToken = symbiosisSourceToken(candidate.sourceChain, candidate.sourceToken);
-            const toChainId = Number(eip155ChainId(candidate.destinationChain));
-            try {
-                await consumeSymbiosisQuota(rateLimitStore, now());
-                const quote = await requestJson(new URL(`${baseUrl}/v2/quote`), {
-                    body: {
-                        from: options.userAddress,
-                        slippage: 100,
-                        to: options.userAddress,
-                        tokenAmountIn: {
-                            address: fromToken,
-                            amount: candidate.sourceAmount.amount,
-                            chainId: fromChainId,
-                            decimals: candidate.sourceToken.decimals,
-                            symbol: candidate.sourceToken.symbol,
-                        },
-                        tokenOut: {
-                            address: candidate.destinationToken.address,
-                            chainId: toChainId,
-                            decimals: candidate.destinationToken.decimals,
-                            symbol: candidate.destinationToken.symbol,
-                        },
-                    },
-                    fetcher,
-                    headers: { 'x-partner-id': 'tempo' },
-                    method: 'POST',
-                    signal,
-                });
-                return formatSymbiosisResult(candidate, quote, now());
-            }
-            catch (cause) {
-                const unavailable = providerUnavailable(cause, [
-                    'AMOUNT_TOO_LOW',
-                    'NO_ROUTE',
-                    'NO_ROUTE_FOUND',
-                    'ROUTE_NOT_FOUND',
-                    'UNSUPPORTED_ROUTE',
-                ]) ?? symbiosisUnavailable(cause);
-                if (!unavailable)
-                    throw cause;
-                return unavailableResult({
-                    detail: 'symbiosis:quote-v2',
-                    message: unavailable,
-                    now: now(),
-                    source: 'providerQuote',
-                });
-            }
-        },
-    };
-}
-/** Returns bounded provider failure details suitable for structured request logs. */
-export function providerFailure(options) {
-    const operation = providerOperation(options.provider);
-    if (options.cause instanceof FundingQuotes.ProviderAdapterTimeoutError ||
-        (options.cause instanceof DOMException && options.cause.name === 'AbortError'))
-        return { failure: 'timeout', id: options.provider, operation };
-    if (options.cause instanceof ProviderResponseError) {
-        const code = providerErrorCode(options.cause.body);
-        return {
-            ...(code === undefined ? {} : { code }),
-            failure: 'http',
-            id: options.provider,
-            operation,
-            status: options.cause.status,
-        };
-    }
-    if (options.cause instanceof ProviderPayloadError)
-        return { failure: 'payload', id: options.provider, operation };
-    if (options.cause instanceof ProviderRateLimitError)
-        return { failure: 'rate_limit', id: options.provider, operation };
-    if (options.cause instanceof TypeError)
-        return { failure: 'network', id: options.provider, operation };
-    return { failure: 'unknown', id: options.provider, operation };
-}
-function formatAcrossResult(candidate, quote, now) {
-    const parsed = schema.AcrossQuote.safeParse(quote);
-    if (!parsed.success)
-        throw new ProviderPayloadError();
-    const response = parsed.data;
-    const expiresAt = new Date(response.quoteExpiryTimestamp * 1_000);
-    if (response.inputAmount !== candidate.sourceAmount.amount ||
-        !matchesToken(response.inputToken, candidate.sourceChain, candidate.sourceToken) ||
-        !matchesToken(response.outputToken, candidate.destinationChain, candidate.destinationToken) ||
-        BigInt(response.expectedOutputAmount) <= 0n ||
-        BigInt(response.minOutputAmount) <= 0n ||
-        BigInt(response.minOutputAmount) > BigInt(response.expectedOutputAmount) ||
-        Number.isNaN(expiresAt.getTime()) ||
-        response.quoteExpiryTimestamp * 1_000 <= now.getTime())
-        throw new ProviderPayloadError();
-    return {
-        expiresAt: expiresAt.toISOString(),
-        minimumOutputAmount: response.minOutputAmount,
-        outputAmount: response.expectedOutputAmount,
-        quality: {
-            estimatedSeconds: response.expectedFillTime,
-            liquiditySource: 'providerQuote',
-            sourceDetail: 'across:swap-approval',
-            tier: 'liquid',
-        },
-        sampledAt: now.toISOString(),
-        status: 'available',
-    };
-}
-function formatRelayResult(quote, now) {
-    const details = record(record(quote)['details']);
-    const currencyOut = record(details['currencyOut']);
-    const outputAmount = decimalString(currencyOut['amount']);
-    const status = outputAmount
-        ? { status: 'available', tier: 'liquid' }
-        : { status: 'unknown', tier: 'unknown' };
-    return {
-        minimumOutputAmount: decimalString(currencyOut['minimumAmount']),
-        outputAmount,
-        quality: {
-            estimatedSeconds: nonnegativeInteger(details['timeEstimate']),
-            liquiditySource: 'providerQuote',
-            sourceDetail: 'relay:quote-v2',
-            tier: status.tier,
-        },
-        sampledAt: now.toISOString(),
-        status: status.status,
-    };
-}
-function formatRhinoResult(candidate, quote, options) {
-    const parsed = schema.RhinoQuote.safeParse(quote);
-    if (!parsed.success)
-        throw new ProviderPayloadError();
-    const response = parsed.data;
-    const inputAmount = baseUnitsFromDecimal(response.payAmount, candidate.sourceToken.decimals);
-    const outputAmount = baseUnitsFromDecimal(response.receiveAmount, candidate.destinationToken.decimals);
-    if (response.chainIn !== options.chainIn ||
-        response.chainOut !== 'TEMPO' ||
-        response.token !== options.tokenOut ||
-        inputAmount !== candidate.sourceAmount.amount ||
-        outputAmount === undefined ||
-        BigInt(outputAmount) <= 0n)
-        throw new ProviderPayloadError();
-    return {
-        outputAmount,
-        quality: {
-            ...(response.estimatedDuration === undefined || response.estimatedDuration === null
-                ? {}
-                : { estimatedSeconds: Math.ceil(response.estimatedDuration / 1_000) }),
-            liquiditySource: 'providerQuote',
-            sourceDetail: 'rhino:bridge-swap-public',
-            tier: 'liquid',
-        },
-        sampledAt: options.now.toISOString(),
-        status: 'available',
-    };
-}
-function formatSquidResult(candidate, quote, now) {
-    const parsed = schema.SquidQuote.safeParse(quote);
-    if (!parsed.success)
-        throw new ProviderPayloadError();
-    const response = parsed.data.route.estimate;
-    if (response.fromAmount !== candidate.sourceAmount.amount ||
-        !matchesSquidToken(response.fromToken, candidate.sourceChain, candidate.sourceToken) ||
-        !matchesSquidToken(response.toToken, candidate.destinationChain, candidate.destinationToken) ||
-        BigInt(response.toAmount) <= 0n ||
-        BigInt(response.toAmountMin) <= 0n ||
-        BigInt(response.toAmountMin) > BigInt(response.toAmount))
-        throw new ProviderPayloadError();
-    return {
-        minimumOutputAmount: response.toAmountMin,
-        outputAmount: response.toAmount,
-        quality: {
-            estimatedSeconds: Math.ceil(response.estimatedRouteDuration),
-            liquiditySource: 'providerQuote',
-            sourceDetail: 'squid:route-v2',
-            tier: 'liquid',
-        },
-        sampledAt: now.toISOString(),
-        status: 'available',
-    };
-}
-function formatSymbiosisResult(candidate, quote, now) {
-    const parsed = schema.SymbiosisQuote.safeParse(quote);
-    if (!parsed.success)
-        throw new ProviderPayloadError();
-    const response = parsed.data;
-    const sourceChainId = Number(providerChainId(candidate.sourceChain, 'symbiosis'));
-    const sourceToken = symbiosisSourceToken(candidate.sourceChain, candidate.sourceToken);
-    const firstToken = response.routes[0].tokens[0];
-    const lastRoute = response.routes[response.routes.length - 1];
-    const lastToken = lastRoute.tokens[lastRoute.tokens.length - 1];
-    if (response.tx.chainId !== sourceChainId ||
-        response.type !== candidate.sourceChain.kind ||
-        !matchesSymbiosisToken(firstToken, {
-            address: sourceToken,
-            chainId: sourceChainId,
-            decimals: candidate.sourceToken.decimals,
-        }) ||
-        !matchesSymbiosisToken(lastToken, {
-            address: candidate.destinationToken.address,
-            chainId: Number(eip155ChainId(candidate.destinationChain)),
-            decimals: candidate.destinationToken.decimals,
-        }) ||
-        !matchesSymbiosisToken(response.tokenAmountOut, {
-            address: candidate.destinationToken.address,
-            chainId: Number(eip155ChainId(candidate.destinationChain)),
-            decimals: candidate.destinationToken.decimals,
-        }) ||
-        !matchesSymbiosisToken(response.tokenAmountOutMin, {
-            address: candidate.destinationToken.address,
-            chainId: Number(eip155ChainId(candidate.destinationChain)),
-            decimals: candidate.destinationToken.decimals,
-        }) ||
-        BigInt(response.tokenAmountOut.amount) <= 0n ||
-        BigInt(response.tokenAmountOutMin.amount) <= 0n ||
-        BigInt(response.tokenAmountOutMin.amount) > BigInt(response.tokenAmountOut.amount))
-        throw new ProviderPayloadError();
-    return {
-        minimumOutputAmount: response.tokenAmountOutMin.amount,
-        outputAmount: response.tokenAmountOut.amount,
-        quality: {
-            ...(response.estimatedTime === undefined
-                ? {}
-                : { estimatedSeconds: Math.ceil(response.estimatedTime) }),
-            liquiditySource: 'providerQuote',
-            sourceDetail: 'symbiosis:quote-v2',
-            tier: 'liquid',
-        },
-        sampledAt: now.toISOString(),
-        status: 'available',
-    };
-}
-function unavailableResult(options) {
-    return {
-        quality: {
-            liquiditySource: options.source,
-            sourceDetail: `${options.detail}:${options.message}`,
-            tier: 'unavailable',
-        },
-        sampledAt: options.now.toISOString(),
-        status: 'unavailable',
-    };
-}
-async function requestJson(url, options) {
-    const headers = { accept: 'application/json', ...options.headers };
-    const init = {
-        headers: options.body === undefined ? headers : { ...headers, 'content-type': 'application/json' },
-        method: options.method ?? 'GET',
-        signal: options.signal,
-    };
-    if (options.body !== undefined)
-        init.body = JSON.stringify(options.body);
-    const response = await options.fetcher(url, init);
-    const text = await response.text();
-    const body = parseJson(text);
-    if (!response.ok)
-        throw new ProviderResponseError(response.status, body);
-    return body;
-}
-function relayHeaders(apiKey) {
-    return apiKey ? { 'x-api-key': apiKey } : undefined;
-}
-function providerUnavailable(cause, codes) {
-    if (!(cause instanceof ProviderResponseError) || cause.status < 400 || cause.status >= 500)
-        return undefined;
-    const code = providerErrorCode(cause.body);
-    if (code && codes.includes(code))
-        return code;
-    return undefined;
-}
-function providerErrorCode(input) {
-    const body = record(input);
-    const error = record(body['error']);
-    const code = stringValue(body['_tag']) ??
-        stringValue(body['code']) ??
-        stringValue(body['errorCode']) ??
-        stringValue(body['errorType']) ??
-        stringValue(body['type']) ??
-        stringValue(error['code']) ??
-        stringValue(error['type']);
-    return code && /^[A-Za-z0-9_.:-]{1,64}$/.test(code) ? code : undefined;
-}
-function squidUnavailable(cause) {
-    if (!(cause instanceof ProviderResponseError) || cause.status !== 400)
-        return undefined;
-    const body = record(cause.body);
-    if (body['type'] === 'BAD_REQUEST' &&
-        body['message'] === 'Please increase the swap amount and try again.')
-        return 'AMOUNT_TOO_LOW';
-    return undefined;
-}
-function symbiosisUnavailable(cause) {
-    if (!(cause instanceof ProviderResponseError) || cause.status !== 400)
-        return undefined;
-    const body = record(cause.body);
-    if (body['message'] === 'Amount is too low to cover fees')
-        return 'AMOUNT_TOO_LOW';
-    return undefined;
-}
-async function consumeSymbiosisQuota(store, now) {
-    const time = now.getTime();
-    const bucket = Math.floor(time / symbiosisRateLimitWindowMs);
-    const count = await Store.increment(store, `funding:symbiosis:quote:${bucket}`, {
-        ttl: symbiosisRateLimitWindowMs * 2,
-    });
-    if (count > symbiosisRateLimit)
-        throw new ProviderRateLimitError();
-}
-function providerChainId(quoteChain, provider) {
-    const providerIds = quoteChain.providerIds;
-    const id = providerIds?.[provider];
-    if (id && /^\d+$/.test(id))
-        return id;
-    return eip155ChainId(quoteChain);
-}
-function providerChainReference(quoteChain, provider) {
-    const providerIds = quoteChain.providerIds;
-    const id = providerIds?.[provider];
-    if (!id)
-        throw new UnsupportedProviderChainError();
-    return id;
-}
-function rhinoToken(token) {
-    const tokens = {
-        '0x20c00000000000000000000014f22ca97301eb73': 'USDT',
-        '0x20c000000000000000000000b9537d11c60e8b50': 'USDC',
-    };
-    const id = tokens[token.address.toLowerCase()];
-    if (!id)
-        throw new UnsupportedProviderTokenError();
-    return id;
-}
-function symbiosisSourceToken(chain, token) {
-    if (chain.kind !== 'tron')
-        return token.address;
-    const tokens = {
-        TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t: '0xa614f803b6fd780986a42c78ec9c7f77e6ded13c',
-    };
-    const id = tokens[token.address];
-    if (!id)
-        throw new UnsupportedProviderTokenError();
-    return id;
-}
-function matchesToken(token, chain, expected) {
-    return (token.address.toLowerCase() === expected.address.toLowerCase() &&
-        token.chainId === Number(eip155ChainId(chain)) &&
-        token.decimals === expected.decimals);
-}
-function matchesSquidToken(token, chain, expected) {
-    return (token.address.toLowerCase() === expected.address.toLowerCase() &&
-        String(token.chainId) === eip155ChainId(chain) &&
-        token.decimals === expected.decimals);
-}
-function matchesSymbiosisToken(token, options) {
-    return (token.address.toLowerCase() === options.address.toLowerCase() &&
-        token.chainId === options.chainId &&
-        token.decimals === options.decimals);
-}
-function eip155ChainId(chain) {
-    if (chain.kind !== 'evm')
-        throw new UnsupportedProviderChainError();
-    const match = /^eip155:(\d+)$/.exec(chain.id);
-    if (!match?.[1])
-        throw new UnsupportedProviderChainError();
-    return match[1];
-}
-function normalizeBaseUrl(input) {
-    return input.replace(/\/+$/, '');
-}
-function parseJson(input) {
-    if (!input)
-        return null;
-    try {
-        return JSON.parse(input);
-    }
-    catch {
-        return input;
-    }
-}
-function record(input) {
-    return input && typeof input === 'object' && !Array.isArray(input)
-        ? input
-        : {};
-}
-function stringValue(input) {
-    return typeof input === 'string' && input.length > 0 ? input : undefined;
-}
-function decimalString(input) {
-    if (typeof input === 'string' && /^\d+(\.\d+)?$/.test(input))
-        return input;
-    if (typeof input === 'number' && Number.isFinite(input) && input >= 0)
-        return String(input);
-    return undefined;
-}
-function nonnegativeInteger(input) {
-    if (typeof input === 'number' && Number.isSafeInteger(input) && input >= 0)
-        return input;
-    if (typeof input === 'string' && /^\d+$/.test(input))
-        return Number(input);
-    return undefined;
-}
-function baseUnitsFromDecimal(value, decimals) {
-    if (!/^\d+(\.\d+)?$/.test(value))
-        return undefined;
-    const [whole, fraction = ''] = value.split('.');
-    const significantFraction = fraction.replace(/0+$/, '');
-    if (significantFraction.length > decimals)
-        return undefined;
-    return BigInt(`${whole}${significantFraction.padEnd(decimals, '0')}`).toString();
-}
-function assertAcrossConfiguration(options) {
-    if (options.apiKey.length === 0 ||
-        !/^0x[\da-fA-F]{4}$/.test(options.integratorId) ||
-        !/^0x[\da-fA-F]{40}$/.test(options.userAddress))
-        throw new ProviderConfigurationError();
-}
-function assertSquidConfiguration(options) {
-    if (options.integratorId.length === 0)
-        throw new ProviderConfigurationError();
-    assertUserAddress(options.userAddress);
-}
-function assertUserAddress(userAddress) {
-    if (!/^0x[\da-fA-F]{40}$/.test(userAddress))
-        throw new ProviderConfigurationError();
-}
-class ProviderConfigurationError extends Error {
-    name = 'FundingQuoteProviders.ProviderConfigurationError';
-}
-class ProviderPayloadError extends Error {
-    name = 'FundingQuoteProviders.ProviderPayloadError';
-}
-class ProviderRateLimitError extends Error {
-    name = 'FundingQuoteProviders.ProviderRateLimitError';
-}
-class ProviderResponseError extends Error {
-    status;
-    body;
-    name = 'FundingQuoteProviders.ProviderResponseError';
-    constructor(status, body) {
-        super(`Provider request failed with status ${status}`);
-        this.status = status;
-        this.body = body;
-    }
-}
-class UnsupportedProviderChainError extends Error {
-    name = 'FundingQuoteProviders.UnsupportedProviderChainError';
-}
-class UnsupportedProviderTokenError extends Error {
-    name = 'FundingQuoteProviders.UnsupportedProviderTokenError';
-}
-//# sourceMappingURL=FundingQuoteProviders.js.map