@gibs/bridge-sdk 1.13.0 → 1.17.0

package/dist/cjs/providers.d.ts

@@ -0,0 +1,238 @@
+import { type ConsolidatedQuote, type ConsolidatedQuoteRequest } from './consolidated-quote.js';
+import { type Provider } from './config.js';
+import type { Ecosystem } from './ecosystems.js';
+import { type PreQuoteRequest, type PreQuoteResult } from './pre-quote.js';
+import { type NearIntentsAsset } from './near-intents.js';
+import type { QuoteFeeToken } from './quote-fees.js';
+/**
+ * A consolidated-route aggregator. Like {@link Ecosystem}, this is the `id` of a
+ * descriptor in {@link providerRegistry}, so adding a provider is one descriptor
+ * rather than an edit spread across a union, a capability conditional, and two
+ * interface-side arrays.
+ */
+export type ProviderId = 'lifi' | 'relay' | 'near-intents';
+/**
+ * Every source a hop or a lookup table can attribute to a name, a logo or a
+ * display colour: a consolidated-route aggregator ({@link ProviderId}), an
+ * omnibridge crossing ({@link Provider}, from `config.ts` — `'pulsechain'` or
+ * `'tokensex'`), or the on-chain PulseChain DEX swap leg, which belongs to
+ * neither registry and is named here as its own literal.
+ *
+ * THE ONE UNION FOR "NAME A CARRIER." Every table a hop's carrier is looked up
+ * in — a logo url, a glyph, a display name — must be typed
+ * `Record<ProviderKey, X>`, never `Record<string, X>`: a table keyed on
+ * `string` accepts a carrier with no entry silently, which is how NEAR
+ * Intents shipped with no logo and how a lower-cased `'pulsex'` drew the
+ * initials tile "PU" instead of the PulseX mark. Typed on this union, a
+ * carrier added to any of its three sources fails to compile until it also
+ * has a name and a mark.
+ *
+ * `'PulseX'` IS SPELLED WITH THAT EXACT CASING, matching `providerKey:
+ * 'PulseX'` in `routing/producers.ts` and every lookup table keyed on it.
+ * `routing/search/graph.ts`'s `HopEdge.carrier` is a plain `CarrierId`
+ * string, not this union — the route-search engine is a plug-in host that
+ * does not close its carrier vocabulary over gibs's own three; every member
+ * of THIS union is still a valid `CarrierId`, just not the only one.
+ */
+export type ProviderKey = ProviderId | Provider | 'PulseX';
+/**
+ * What a provider may need to form a request or read an answer, beyond the
+ * route request itself.
+ *
+ * EVERY FIELD IS OPTIONAL AND MOST PROVIDERS IGNORE ALL OF THEM. LI.FI and Relay
+ * name assets by chain and address, and hand back a signable transaction, so
+ * their builders and parsers are total over the request alone — and they stay
+ * referenced here unchanged, because a function of one argument satisfies a type
+ * of two. NEAR Intents needs more in both directions: it names assets by its own
+ * identifiers, which can only be looked up in its published list, and it answers
+ * with a deposit ADDRESS rather than a transaction, so the chain and token the
+ * transfer must be composed from exist only on the request.
+ *
+ * Kept as one optional record rather than a per-provider generic parameter
+ * because the registry's whole purpose is that callers iterate descriptors
+ * without knowing which provider they hold.
+ */
+export type ProviderQuoteContext = {
+    /**
+     * The NEAR Intents asset list. Its identifiers cannot be constructed from a
+     * chain and an address — see `findNearIntentsAsset`.
+     */
+    nearIntentsAssets?: readonly NearIntentsAsset[];
+    /** The clock, for a provider whose request states a deadline. */
+    now?: Date;
+    /** Distribution-channel tag, for a provider that accepts one. */
+    referral?: string;
+    /**
+     * The request being answered. Needed only by a parser whose response does not
+     * carry enough to build the origin deposit on its own.
+     */
+    request?: ConsolidatedQuoteRequest;
+    /** The paid token, for normalizing a charge denominated in it. */
+    originToken?: QuoteFeeToken;
+    /** The delivered token, for the same reason. */
+    destinationToken?: QuoteFeeToken;
+};
+/**
+ * A self-describing provider: which source ecosystems it can carry, and the
+ * existing request-builders and response-parsers for each of the two quoting
+ * phases. The builders and parsers are REFERENCED, never re-implemented — they
+ * already exist and are tested. Endpoint URLs are intentionally absent: the
+ * transport wrappers that own the endpoint, abort signal, and headers live in
+ * the interface package.
+ */
+export type ProviderDescriptor = {
+    id: ProviderId;
+    label: string;
+    /** The source ecosystems this provider can originate a route from. */
+    supportedSourceEcosystems: readonly Ecosystem[];
+    /**
+     * Whether this provider's executor performs a call on the destination chain
+     * when the funds arrive.
+     *
+     * THE FIELD THAT DECIDES WHAT SHAPE OF ROUTE A PROVIDER CAN CARRY, and the
+     * owner's standing criterion expressed as data rather than as a rule somebody
+     * has to remember.
+     *
+     * True — hand it the omnibridge entry call and the crossing is one signature.
+     * False — it delivers tokens to an address and stops, so a crossing through it
+     * takes TWO signatures: the provider's leg, then the reader signing the entry
+     * call themselves once the funds land.
+     *
+     * It also gates the entry-anchor pre-quote, and that is the part that bites.
+     * That phase takes the LARGEST delivered amount across providers and feeds it
+     * to the execution quote as a fixed exact-output target. A provider that
+     * cannot execute can still deliver more — so letting one bid there raises a
+     * target only it could reach and that nobody can execute, turning a working
+     * route into no route at all. See `selectPreQuoteProviderIds`.
+     */
+    executesDestinationCalls: boolean;
+    /**
+     * The origin chains this provider can perform a destination call FROM, or
+     * `'any'` when every origin it carries can. Read only when
+     * {@link executesDestinationCalls} is true.
+     *
+     * LI.FI IS ETHEREUM ONLY — the owner's rule: its contract-calls endpoint
+     * is what attaches the omnibridge entry call, and from any other origin a
+     * LI.FI leg is an ordinary delivery to the reader's own wallet, followed by
+     * a crossing the reader signs. The route search reads this list, so it never
+     * proposes a fused LI.FI hop it could not have signed.
+     */
+    destinationCallOriginChainIds: readonly number[] | 'any';
+    /**
+     * Whether the destination call this provider performs may carry native
+     * value — the omnibridge's native entry (`wrapAndRelayTokens`) is a payable
+     * call, where every other entry moves a token.
+     *
+     * Relay's is verified: a dry `quote/v2` for Base USD Coin into Ethereum
+     * ether with a value-bearing `wrapAndRelayTokens` call answered 200 at 0.05
+     * ether and refused with `DESTINATION_TX_FAILED` at 0.01 (under the
+     * mediator's floor) — so Relay simulates the call with its value attached
+     * (measured 2026-09-27). LI.FI's is not verified, and its request builder
+     * refuses such a call; this field and that builder must agree (see
+     * `providers.test.ts`).
+     */
+    destinationCallCarriesNativeValue: boolean;
+    /**
+     * How this provider takes an Ethereum token from the reader's wallet.
+     *
+     * - `'allowance'` — the provider's contract pulls the token, so the wallet
+     *   must first approve that contract as a spender. The execution quote names
+     *   the spender (`ConsolidatedQuote.approvalAddress`), and the executor
+     *   raises the allowance before it sends.
+     * - `'transfer'` — the reader sends the token to an address the provider
+     *   gives. A plain transfer needs no approval, and the parser leaves
+     *   `approvalAddress` null.
+     *
+     * A DISPLAY FACT, NEVER A SIGNING ONE. The press reads the live quote's own
+     * `approvalAddress` and the live allowance. This field lets a route say, BEFORE
+     * any live quote exists, that its wallet may ask for an approval first.
+     * The native coin never needs one, whatever this says.
+     */
+    originTokenSpend: 'allowance' | 'transfer';
+    /**
+     * Phase one: the plain forward-solving origin-to-anchor swap pre-quote.
+     *
+     * The `context` argument is ignored by every provider that does not need it,
+     * and a builder written to take only the request still satisfies this type.
+     */
+    preQuote: {
+        method: 'GET' | 'POST';
+        build: (request: PreQuoteRequest, context?: ProviderQuoteContext) => string | object | null;
+        parse: (payload: unknown, context?: ProviderQuoteContext) => PreQuoteResult | null;
+    };
+    /** Phase two: the backward-solving execution quote with destination calls. */
+    executionQuote: {
+        method: 'GET' | 'POST';
+        build: (request: ConsolidatedQuoteRequest, context?: ProviderQuoteContext) => object | null;
+        parse: (payload: unknown, context?: ProviderQuoteContext) => ConsolidatedQuote | null;
+    };
+};
+/**
+ * Every integrated provider. LI.FI is first: the interface preserves this order
+ * in its active lists, and LI.FI-first is the existing tie-break that prefers
+ * the verified provider on an equal-cost quote. NEAR Intents is last, so it
+ * wins a tie against neither — appropriate for the one provider whose route
+ * costs the reader a second signature.
+ */
+export declare const providerRegistry: readonly ProviderDescriptor[];
+/**
+ * Looks up a provider descriptor for ANY carrier id, answering null for an id
+ * the registry does not hold. The route-search engine carries hops for
+ * carriers that are not providers at all (a local wrap, a pool swap, a
+ * host's own plug-in), so a caller holding an open carrier id must ask this,
+ * never cast the id to {@link ProviderId} and call {@link providerById}, which
+ * throws for such an id.
+ *
+ * @param id - any carrier id
+ * @returns the descriptor, or null when no provider is registered under `id`
+ */
+export declare const findProviderById: (id: string) => ProviderDescriptor | null;
+/**
+ * Looks up a provider descriptor. Total over the `ProviderId` union; throws only
+ * if the registry is left incomplete.
+ *
+ * @param id - the provider key
+ * @returns the descriptor whose `id` equals `id`
+ */
+export declare const providerById: (id: ProviderId) => ProviderDescriptor;
+/**
+ * The providers that can originate a route from `ecosystem`, in registry order.
+ * This is the data that used to be the hand-written capability conditional.
+ *
+ * @param ecosystem - the source ecosystem
+ * @returns the descriptors whose `supportedSourceEcosystems` include `ecosystem`
+ */
+export declare const providersForOrigin: (ecosystem: Ecosystem) => readonly ProviderDescriptor[];
+/**
+ * The providers that may bid in the entry-anchor pre-quote for an origin.
+ *
+ * A STRICTER LIST THAN {@link providersForOrigin}, AND THE DIFFERENCE IS NOT
+ * COSMETIC. The pre-quote exists for one purpose: to learn, for the reader's
+ * fixed input, how much anchor an entry really delivers, so that figure can
+ * become the exact-output target of the execution quote. The winner is whoever
+ * delivers MOST.
+ *
+ * A provider that cannot execute the entry call can still win that comparison —
+ * it has one less thing to pay for. Its number then becomes a target handed to
+ * the providers that must actually fill it, and they cannot, so the whole entry
+ * produces no route. The failure is silent and looks like an absent quote.
+ *
+ * So the pre-quote is restricted to providers that execute. This is not a
+ * judgement about quality; it is that a pre-quote and an execution quote have
+ * to be answerable by the same provider for the handoff between them to mean
+ * anything.
+ *
+ * @param ecosystem - the source ecosystem
+ * @returns the descriptors that may pre-quote this origin, in registry order
+ */
+export declare const preQuoteProvidersForOrigin: (ecosystem: Ecosystem) => readonly ProviderDescriptor[];
+/**
+ * Whether a provider can quote a request's origin ecosystem, derived from the
+ * registry. Equivalent to `providersForOrigin(...).some(...)`, kept as a named
+ * predicate for the call sites that ask about one provider at a time.
+ *
+ * @param provider - the aggregator under consideration
+ * @param request - the request whose origin is being checked
+ * @returns true when the provider supports the request's origin ecosystem
+ */
+export declare const providerSupportsOrigin: (provider: ProviderId, request: Pick<ConsolidatedQuoteRequest, "originVmType">) => boolean;

package/dist/cjs/providers.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerSupportsOrigin = exports.preQuoteProvidersForOrigin = exports.providersForOrigin = exports.providerById = exports.findProviderById = exports.providerRegistry = void 0;
+const consolidated_quote_js_1 = require("./consolidated-quote.js");
+const config_js_1 = require("./config.js");
+const pre_quote_js_1 = require("./pre-quote.js");
+const near_intents_js_1 = require("./near-intents.js");
+const relay_quote_js_1 = require("./relay-quote.js");
+const lifiDescriptor = {
+    id: 'lifi',
+    label: 'LI.FI',
+    supportedSourceEcosystems: ['evm'],
+    // Its contract-calls endpoint exists to deliver and then call something.
+    executesDestinationCalls: true,
+    destinationCallOriginChainIds: [Number(config_js_1.Chains.ETH)],
+    destinationCallCarriesNativeValue: false,
+    // Its quote names the Diamond as `estimate.approvalAddress`.
+    originTokenSpend: 'allowance',
+    preQuote: {
+        method: 'GET',
+        build: pre_quote_js_1.buildLifiPreQuoteRequest,
+        parse: pre_quote_js_1.parseLifiPreQuote,
+    },
+    executionQuote: {
+        method: 'POST',
+        build: consolidated_quote_js_1.buildLifiContractCallsRequest,
+        parse: consolidated_quote_js_1.parseLifiContractCallsQuote,
+    },
+};
+const relayDescriptor = {
+    id: 'relay',
+    label: 'Relay',
+    // Relay carries every origin family the registry models. Listed explicitly
+    // rather than derived from the registry so that registering a future
+    // ecosystem does not silently claim Relay support the integration lacks.
+    supportedSourceEcosystems: ['evm', 'svm', 'bvm', 'tvm', 'tonvm', 'hypevm'],
+    // Its solver performs the `txs` attached to a quote on arrival.
+    executesDestinationCalls: true,
+    destinationCallOriginChainIds: 'any',
+    destinationCallCarriesNativeValue: true,
+    // Its quote carries an approve step; the parser lifts its spender.
+    originTokenSpend: 'allowance',
+    preQuote: {
+        method: 'POST',
+        build: pre_quote_js_1.buildRelayPreQuoteRequest,
+        parse: pre_quote_js_1.parseRelayPreQuote,
+    },
+    executionQuote: {
+        method: 'POST',
+        build: relay_quote_js_1.buildRelayQuoteRequest,
+        parse: relay_quote_js_1.parseRelayQuote,
+    },
+};
+const nearIntentsDescriptor = {
+    id: 'near-intents',
+    label: 'NEAR Intents',
+    // ETHEREUM ORIGINS, AND THE CHAINS A READER PAYS BY HAND. The service
+    // carries Solana, Bitcoin, Tron, The Open Network and more, but it returns a
+    // deposit ADDRESS and no transaction. For a wallet-connected origin the
+    // transfer that funds a route has to be composed on this side, and only the
+    // Ethereum one is composed today (`nearIntentsOriginDeposit`); claiming a
+    // family whose transfer nothing here can build would offer a route that
+    // dead-ends at the signing step. A pay-by-hand chain needs nothing composed:
+    // the address and the amount ARE the deposit (`DepositAddressDeposit`).
+    supportedSourceEcosystems: ['evm', 'zcash'],
+    // The measured answer, and the reason this provider's routes take two
+    // signatures. See the head of `near-intents.ts`.
+    executesDestinationCalls: false,
+    destinationCallOriginChainIds: [],
+    destinationCallCarriesNativeValue: false,
+    // The reader sends the token to a deposit address.
+    originTokenSpend: 'transfer',
+    preQuote: {
+        method: 'POST',
+        build: near_intents_js_1.buildNearIntentsPreQuoteRequest,
+        parse: near_intents_js_1.parseNearIntentsPreQuote,
+    },
+    executionQuote: {
+        method: 'POST',
+        build: near_intents_js_1.buildNearIntentsQuoteRequest,
+        parse: near_intents_js_1.parseNearIntentsQuote,
+    },
+};
+/**
+ * Every integrated provider. LI.FI is first: the interface preserves this order
+ * in its active lists, and LI.FI-first is the existing tie-break that prefers
+ * the verified provider on an equal-cost quote. NEAR Intents is last, so it
+ * wins a tie against neither — appropriate for the one provider whose route
+ * costs the reader a second signature.
+ */
+exports.providerRegistry = [
+    lifiDescriptor,
+    relayDescriptor,
+    nearIntentsDescriptor,
+];
+const byId = new Map(exports.providerRegistry.map((descriptor) => [descriptor.id, descriptor]));
+/**
+ * Looks up a provider descriptor for ANY carrier id, answering null for an id
+ * the registry does not hold. The route-search engine carries hops for
+ * carriers that are not providers at all (a local wrap, a pool swap, a
+ * host's own plug-in), so a caller holding an open carrier id must ask this,
+ * never cast the id to {@link ProviderId} and call {@link providerById}, which
+ * throws for such an id.
+ *
+ * @param id - any carrier id
+ * @returns the descriptor, or null when no provider is registered under `id`
+ */
+const findProviderById = (id) => byId.get(id) ?? null;
+exports.findProviderById = findProviderById;
+/**
+ * Looks up a provider descriptor. Total over the `ProviderId` union; throws only
+ * if the registry is left incomplete.
+ *
+ * @param id - the provider key
+ * @returns the descriptor whose `id` equals `id`
+ */
+const providerById = (id) => {
+    const descriptor = byId.get(id);
+    if (descriptor === undefined) {
+        throw new Error(`no provider descriptor registered for id "${id}"`);
+    }
+    return descriptor;
+};
+exports.providerById = providerById;
+/**
+ * The providers that can originate a route from `ecosystem`, in registry order.
+ * This is the data that used to be the hand-written capability conditional.
+ *
+ * @param ecosystem - the source ecosystem
+ * @returns the descriptors whose `supportedSourceEcosystems` include `ecosystem`
+ */
+const providersForOrigin = (ecosystem) => exports.providerRegistry.filter((descriptor) => descriptor.supportedSourceEcosystems.includes(ecosystem));
+exports.providersForOrigin = providersForOrigin;
+/**
+ * The providers that may bid in the entry-anchor pre-quote for an origin.
+ *
+ * A STRICTER LIST THAN {@link providersForOrigin}, AND THE DIFFERENCE IS NOT
+ * COSMETIC. The pre-quote exists for one purpose: to learn, for the reader's
+ * fixed input, how much anchor an entry really delivers, so that figure can
+ * become the exact-output target of the execution quote. The winner is whoever
+ * delivers MOST.
+ *
+ * A provider that cannot execute the entry call can still win that comparison —
+ * it has one less thing to pay for. Its number then becomes a target handed to
+ * the providers that must actually fill it, and they cannot, so the whole entry
+ * produces no route. The failure is silent and looks like an absent quote.
+ *
+ * So the pre-quote is restricted to providers that execute. This is not a
+ * judgement about quality; it is that a pre-quote and an execution quote have
+ * to be answerable by the same provider for the handoff between them to mean
+ * anything.
+ *
+ * @param ecosystem - the source ecosystem
+ * @returns the descriptors that may pre-quote this origin, in registry order
+ */
+const preQuoteProvidersForOrigin = (ecosystem) => (0, exports.providersForOrigin)(ecosystem).filter((descriptor) => descriptor.executesDestinationCalls);
+exports.preQuoteProvidersForOrigin = preQuoteProvidersForOrigin;
+// A request with no origin family is the existing-caller shape and is treated as
+// Ethereum, preserving the original single-ecosystem default.
+const ecosystemOf = (request) => request.originVmType ?? 'evm';
+/**
+ * Whether a provider can quote a request's origin ecosystem, derived from the
+ * registry. Equivalent to `providersForOrigin(...).some(...)`, kept as a named
+ * predicate for the call sites that ask about one provider at a time.
+ *
+ * @param provider - the aggregator under consideration
+ * @param request - the request whose origin is being checked
+ * @returns true when the provider supports the request's origin ecosystem
+ */
+const providerSupportsOrigin = (provider, request) => (0, exports.providerById)(provider).supportedSourceEcosystems.includes(ecosystemOf(request));
+exports.providerSupportsOrigin = providerSupportsOrigin;

package/dist/cjs/quote-fees.d.ts

@@ -0,0 +1,102 @@
+/**
+ * What a consolidated route actually charges, normalized across the aggregators.
+ *
+ * WHY THIS EXISTS. A quote used to carry `fromAmount` and nothing else about
+ * cost, so the interface could show the reader only the omnibridge crossing fee
+ * — a figure that is real, and on a twenty-five dollar transfer is a rounding
+ * error beside what the aggregator takes. Measured on one live route on
+ * 2026-09-01: Relay charged 1.466338 USD Coin, or 5.54%, and none of it
+ * appeared anywhere on screen.
+ *
+ * THE FLAG THAT MATTERS IS `includedInFromAmount`. The two providers express
+ * cost differently, and the difference is not cosmetic:
+ *
+ *   Relay folds everything into `fromAmount`. You send 26.466338 to receive
+ *   25.000000, and the 1.466338 difference IS the fee.
+ *
+ *   LI.FI does not. On the same route it quoted `fromAmount` 25.317074 and a
+ *   SEPARATE LayerZero fee of 0.000561734871157119 ether — about 1.37 dollars —
+ *   marked `included: false`, which the sender pays on top in native currency.
+ *
+ * So comparing the two on `fromAmount` alone reads LI.FI as more than a dollar
+ * cheaper when it is in fact slightly dearer. Anything that ranks or displays
+ * cost has to add the charges that sit outside `fromAmount`, and that is what
+ * this flag is for.
+ */
+/** The token a charge is denominated in, enough to format it. */
+export type QuoteFeeToken = {
+    symbol: string;
+    decimals: number;
+    chainId: number;
+};
+/**
+ * What a charge IS, independent of the name its provider gives it.
+ *
+ * Deliberately coarse. The provider's own wording travels in `label`, so this
+ * only has to carry the distinction a reader acts on: is this the network's
+ * cost, somebody's margin, or our own referral.
+ */
+export type QuoteFeeKind = 'gas' | 'service' | 'integrator';
+/** One charge on a route. */
+export type QuoteFee = {
+    kind: QuoteFeeKind;
+    /** The provider's own name for it, so a reader can reconcile against them. */
+    label: string;
+    /** The charge, in the token's base units. */
+    amount: bigint;
+    token: QuoteFeeToken;
+    /** United States dollar value, exactly as the provider reported it. */
+    amountUsd: string | null;
+    /**
+     * FALSE means the sender pays this ON TOP of `fromAmount`.
+     *
+     * Getting this backwards double-counts a fee or hides one entirely, and in
+     * both directions the number on screen is wrong in the direction that
+     * flatters the route.
+     */
+    includedInFromAmount: boolean;
+};
+/**
+ * The charges Relay reports, in the order a reader meets them.
+ *
+ * `fees.relayer` IS DELIBERATELY SKIPPED. It is the sum of `relayerGas` and
+ * `relayerService`, so listing it beside them would count the same money twice
+ * and make the breakdown disagree with the amount the sender pays.
+ *
+ * `fees.gas` is the sender's OWN origin-chain transaction cost. It sits outside
+ * `fromAmount` because the wallet pays it directly, which is exactly the case
+ * `includedInFromAmount` exists to mark.
+ * @param payload - the raw body from Relay's quote endpoint
+ * @returns the charges, in display order
+ */
+export declare const relayQuoteFees: (payload: unknown) => QuoteFee[];
+/**
+ * The charges LI.FI reports.
+ *
+ * `feeCosts` CARRIES ITS OWN `included` FLAG and it is the whole point of
+ * reading this: a fee marked `included: false` is paid on top of `fromAmount`,
+ * in that fee's own token, and on a live route it was worth more than a dollar.
+ * `gasCosts` is the sender's own origin transaction and is never included.
+ * @param payload - the raw body from LI.FI's quote endpoint
+ * @returns the charges, in display order
+ */
+export declare const lifiQuoteFees: (payload: unknown) => QuoteFee[];
+/**
+ * What the route costs the sender all in, in United States dollars.
+ *
+ * `fromAmount` already contains every charge marked included, so only the ones
+ * marked otherwise are added. This is the figure two providers must be compared
+ * on: ranking them on `fromAmount` alone picked LI.FI over Relay by more than a
+ * dollar on a route where LI.FI was in fact the dearer of the two, because its
+ * LayerZero fee is charged outside the amount.
+ *
+ * Returns null when the input's own dollar value is unknown — a partial total
+ * would rank routes against each other on different bases.
+ * @param quote.fromAmountUsd - the provider's dollar value for the input amount
+ * @param quote.fees - the route's charges
+ * @returns the all-in dollar cost, or null when it cannot be totalled
+ */
+export declare const totalQuoteCostUsd: ({ fromAmountUsd, fees, }: {
+    fromAmountUsd: string | null;
+    fees: QuoteFee[];
+}) => number | null;