@gibs/bridge-sdk 1.13.0 → 1.17.0

package/dist/cjs/near-intents.d.ts

@@ -0,0 +1,524 @@
+import type { ConsolidatedQuote, ConsolidatedQuoteRequest, ConsolidatedStatus } from './consolidated-quote.js';
+import { type Ecosystem } from './ecosystems.js';
+import type { PreQuoteRequest, PreQuoteResult } from './pre-quote.js';
+import type { ProviderQuoteContext } from './providers.js';
+/**
+ * NEAR Intents, through its "one click" quoting service.
+ *
+ * THIS PROVIDER CANNOT EXECUTE ON THE DESTINATION CHAIN, AND IS REGISTERED
+ * ANYWAY. Read both halves of that before changing anything here.
+ *
+ * The service validates its request body against a closed property list and
+ * answers `property destinationCall should not exist` for every name a call
+ * could travel under — `destinationCall`, `calldata`, `msg`, `txs`, `hook`,
+ * `action`, `postSwapAction`. The only thing nameable on the destination side
+ * is an address: `recipient`, with a `recipientType` of `DESTINATION_CHAIN`,
+ * `INTENTS` or `CONFIDENTIAL_INTENTS`. That is measured, not inferred from
+ * silence. `docs/near-intents-capability-survey.md` holds the evidence.
+ *
+ * DELIVERING TO THE MEDIATOR INSTEAD IS NOT A WAY AROUND IT, and the reason is
+ * structural rather than a matter of configuration. The service will happily
+ * deliver to a contract — a quote naming a well-known router as `recipient` is
+ * accepted. But every omnibridge entry point learns WHO THE READER IS from a
+ * data field: `transferAndCall` carries the recipient in its third argument,
+ * `relayTokens` in its second, `wrapAndRelayTokens` in its first. A plain
+ * token transfer has no data field. So a bare arrival cannot name a recipient,
+ * which means it can only ever credit the sender — the solver — or nobody at
+ * all. Do not attempt it.
+ *
+ * SO THE ROUTE TAKES TWO SIGNATURES, and the interface says so on the route
+ * strip rather than in a tooltip. The reader signs the origin transfer; NEAR
+ * Intents lands the anchor token in THEIR OWN WALLET on the entry chain; then
+ * they sign the ordinary bridge leg themselves. `near-intents-route.ts` builds
+ * that shape, and `executesDestinationCalls: false` on the descriptor is what
+ * keeps this provider out of the single-signature machinery, including the
+ * entry-anchor pre-quote — that phase feeds an exact-output target to the
+ * providers that DO execute, and a target only a non-executing provider can
+ * reach is a target nobody can fill.
+ *
+ * TWO SIZE FLOORS MAKE THIS A ROUTING RULE, NOT A FOOTNOTE. Binance Smart
+ * Chain — one of the two omnibridge entry chains — refuses any transfer worth
+ * one thousand United States dollars or less, in either direction, and Polygon
+ * and Tron carry floors of their own. The service imposed these on 2026-09-09
+ * and calls them temporary. Only asking reveals them, so a route has to be
+ * WITHDRAWN on a refusal rather than left to fail: see
+ * {@link NearIntentsQuoteRefusal} and `near-intents-route.ts`.
+ */
+/** Base address for the NEAR Intents one-click service. */
+export declare const nearIntentsApiBaseUrl = "https://1click.chaindefuser.com";
+/** Quote endpoint. Verified live: no key required, and a key-less request is answered in full. */
+export declare const nearIntentsQuoteUrl = "https://1click.chaindefuser.com/v0/quote";
+/** The list of assets the service can carry, keyed by its own asset identifiers. */
+export declare const nearIntentsTokensUrl = "https://1click.chaindefuser.com/v0/tokens";
+/**
+ * Optional notification that the reader's deposit has been sent. The service
+ * detects the deposit on its own; telling it the transaction hash only makes
+ * the detection faster. Takes `{ txHash, depositAddress }`.
+ */
+export declare const nearIntentsDepositSubmitUrl = "https://1click.chaindefuser.com/v0/deposit/submit";
+/**
+ * What a key-less request costs, in basis points of the input amount.
+ *
+ * NOT A FEE THIS CODE CHARGES OR CAN DECLINE. The service inserts it into the
+ * echoed request as an `appFees` entry payable to its own account whenever no
+ * key is presented, so a reader on a key-less route pays a quarter of a percent
+ * that no part of this repository asked for. It is named here so the parser can
+ * surface it as a charge rather than let it disappear into the delivered
+ * amount. A partner key reduces it; obtaining one is an owner decision.
+ */
+export declare const nearIntentsUnauthenticatedFeeBasisPoints = 25;
+/**
+ * What a partner-key request costs instead, in basis points of the input
+ * amount, for an ordinary (non-stablecoin) pair.
+ *
+ * Read from the service's own current documentation on 2026-09-18:
+ * `docs.near-intents.org/integration/distribution-channels/1click-api/authentication`.
+ * See `docs/near-intents-partner-key.md` for the full process of obtaining a
+ * key and what else changes once one is configured.
+ */
+export declare const nearIntentsAuthenticatedFeeBasisPoints = 20;
+/**
+ * What a partner-key request costs on a stablecoin pair or a same-asset
+ * multi-chain route, in basis points of the input amount.
+ *
+ * Read from the same page as {@link nearIntentsAuthenticatedFeeBasisPoints} on
+ * 2026-09-18. Kept as its own constant rather than a special case of the other
+ * one because the service documents it as a distinct figure for a distinct
+ * class of route, not a discount computed from the ordinary rate.
+ */
+export declare const nearIntentsAuthenticatedStablecoinFeeBasisPoints = 1;
+/**
+ * Builds the status-poll address for one quote.
+ *
+ * The deposit address IS the lookup key here, unlike every other provider in
+ * this repository, which key by a request identifier. Each quote is issued its
+ * own deposit address, so the two are one and the same fact — see
+ * {@link parseNearIntentsQuote}, which puts the deposit address in `quoteId`
+ * for exactly this reason.
+ *
+ * @param options.quoteId - the quote's deposit address
+ * @returns the fully-formed status address
+ */
+export declare const nearIntentsStatusUrl: ({ quoteId }: {
+    quoteId: string;
+}) => string;
+/**
+ * What this repository calls itself when it asks the one-click service.
+ *
+ * SENT BECAUSE THE SERVICE REFUSES SOME CALLERS BY NAME, and until now the
+ * name was whatever the runtime happened to supply. The service sits behind
+ * Cloudflare, which answers a refused caller with HTTP 403 and a body reading
+ * `error code: 1010` — a page, not a quote, so a parser sees a shape it cannot
+ * read and the whole provider looks like an outage.
+ *
+ * MEASURED against the live quote endpoint on 2026-09-21, one identical body,
+ * one header changed:
+ *
+ * | user agent                | answer |
+ * | ------------------------- | ------ |
+ * | none (Node 26 default)    | 201    |
+ * | `undici`                  | 201    |
+ * | `node`                    | 201    |
+ * | `curl/8.7.1`              | 201    |
+ * | `python-requests/2.32`    | 201    |
+ * | `Python-urllib/3.14`      | 403    |
+ * | this value                | 201    |
+ *
+ * So nothing is blocked today. The point is that whether we are blocked was
+ * being decided by a list we do not control, matched against a string we never
+ * chose — and a runtime upgrade could change that string without anyone here
+ * touching a line. Naming ourselves fixes the input to that decision.
+ *
+ * A BROWSER IGNORES THIS, and that is fine. `User-Agent` is a forbidden header
+ * name for `fetch`, so the browser drops it silently and sends its own. The
+ * value therefore governs Node alone: the live test harness, the deposit
+ * poller, and any script written later.
+ */
+export declare const nearIntentsUserAgent = "gibs-bridge/1.0 (+https://gibs.finance)";
+/**
+ * Request headers for the one-click service.
+ *
+ * THE KEY IS A JSON WEB TOKEN, NOT A PLAIN IDENTIFIER LIKE RELAY'S. The
+ * service's own documentation accepts it as `Authorization: Bearer` as well as
+ * `X-API-Key`, calls it a "JWT token" throughout, and tells an integrator to
+ * "store your JWT token securely and never commit it to version control. Use
+ * environment variables or secure secret management systems." Relay's
+ * documentation says none of that about its key. `X-API-Key` is the form sent
+ * here because the service accepts it and it matches the header name Relay
+ * already uses, so one code path serves both — but the caller of this
+ * function decides where the value comes from, and that decision is where the
+ * secrecy question has to be answered. See `packages/ui/src/lib/config.ts`
+ * and `docs/near-intents-partner-key.md`.
+ *
+ * THE DEFAULT `User-Agent` NAMES GIBS FINANCE, AND THAT COSTS A CALLER
+ * NOTHING: it carries no key and no rate-limit budget, and a browser drops it.
+ * Pass `options.userAgent` to name yourself instead, or `null` to send none and
+ * let the runtime use its own.
+ *
+ * @param apiKey - a partner key, when one is configured
+ * @param options - `userAgent`: your own value, or `null` for none (defaults to {@link nearIntentsUserAgent})
+ * @returns the headers, carrying the key only when there is one to carry
+ */
+export declare const nearIntentsRequestHeaders: (apiKey?: string, options?: {
+    userAgent?: string | null;
+}) => Record<string, string>;
+/**
+ * Which side of the trade is fixed.
+ *
+ * - `EXACT_INPUT` — the reader names what they spend and the delivered amount
+ *   is whatever the market gives. This is the shape a plain crossing asks for.
+ * - `EXACT_OUTPUT` — the delivered amount is fixed and the input is solved
+ *   backward. The service adds the slippage cushion to `amountIn` and reports
+ *   the uncushioned figure as `minAmountIn`, so the two differ by roughly the
+ *   tolerance and neither is price degradation.
+ *
+ * - `FLEX_INPUT` — the reader is TOLD an amount but may send a slightly
+ *   different one. The slippage tolerance becomes a band rather than a
+ *   cushion: the service names `minAmountIn` about one percent below the
+ *   quote and fills anything at or above it, and it swaps an overpayment
+ *   instead of bouncing it. This is what a deposit-address origin sends, and
+ *   it is not a preference — a reader typing a figure into an exchange
+ *   withdrawal form misses the exact amount routinely, and under
+ *   `EXACT_INPUT` every one of those payments is refunded three days later
+ *   instead of filled. Measured on a Zcash origin: one Zcash quoted
+ *   `amountIn` 100,000,000 and `minAmountIn` 99,000,000.
+ *
+ * The service also offers `ANY_INPUT`, which is gated to authorized partners
+ * and is not modelled. One exclusion applies to the flexible mode:
+ * `CONFIDENTIAL_INTENTS` is not supported with it. Nothing here uses that.
+ */
+export type NearIntentsSwapType = 'EXACT_INPUT' | 'EXACT_OUTPUT' | 'FLEX_INPUT';
+/**
+ * Where the funds come from, and where a refund goes back to.
+ *
+ * The deposit is always `ORIGIN_CHAIN`: the reader holds their funds on a real
+ * chain. The refund is `ORIGIN_CHAIN` too, except on a chain the reader pays by
+ * hand, where it is `INTENTS` — a balance inside NEAR Intents itself, named for
+ * the reader's own Ethereum account. `CONFIDENTIAL_INTENTS` is never built.
+ */
+export type NearIntentsAccountKind = 'ORIGIN_CHAIN' | 'INTENTS' | 'CONFIDENTIAL_INTENTS';
+/**
+ * Where the delivered funds land.
+ *
+ * EVERY VALUE IS AN ADDRESS, and that is the whole of the destination-execution
+ * finding stated as a type. There is no variant that names a contract call.
+ */
+export type NearIntentsRecipientKind = 'DESTINATION_CHAIN' | 'INTENTS' | 'CONFIDENTIAL_INTENTS';
+/** The JSON body for `POST /v0/quote`. */
+export type NearIntentsQuoteRequestBody = {
+    /**
+     * Ask for a price without reserving anything. A dry answer omits
+     * `depositAddress`, `deadline` and `timeWhenInactive`, so it can price a
+     * route but can never execute one.
+     */
+    dry: boolean;
+    swapType: NearIntentsSwapType;
+    /** Maximum slippage in basis points (100 means one percent). */
+    slippageTolerance: number;
+    /** The service's own identifier for the origin asset, e.g. `nep141:base.omft.near`. */
+    originAsset: string;
+    depositType: NearIntentsAccountKind;
+    /** The service's own identifier for the delivered asset. */
+    destinationAsset: string;
+    /** The fixed side of the trade, in that asset's base units, as a decimal string. */
+    amount: string;
+    /**
+     * Where a refund goes: the reader's origin-chain address for an
+     * `ORIGIN_CHAIN` refund, or a lower-cased Ethereum address naming an account
+     * inside NEAR Intents for an `INTENTS` refund.
+     */
+    refundTo: string;
+    refundType: NearIntentsAccountKind;
+    /** Destination-chain address the funds are delivered to. */
+    recipient: string;
+    recipientType: NearIntentsRecipientKind;
+    /**
+     * When an unfilled swap starts refunding, as an ISO 8601 instant. It has to
+     * outlast the deposit's own confirmation time, which is why a Bitcoin origin
+     * needs far longer than an Ethereum one.
+     *
+     * A REQUEST, NOT A SETTING. The answer carries its own `deadline` three days
+     * later — see {@link defaultDeadlineMilliseconds}.
+     */
+    deadline: string;
+    /** Distribution-channel tag. The service requires lower case. */
+    referral?: string;
+};
+/** One asset the service can carry, as `GET /v0/tokens` reports it. */
+export type NearIntentsAsset = {
+    /** The identifier a quote request must use for this asset. */
+    assetId: string;
+    /** The service's own short name for the chain, e.g. `eth`, `base`, `sol`. */
+    blockchain: string;
+    symbol: string;
+    decimals: number;
+    /**
+     * The asset's address on its own chain, or null for a chain's native coin.
+     *
+     * ONLY DEPENDABLE FOR AN ETHEREUM-VIRTUAL-MACHINE CHAIN. Solana's USD Coin is
+     * reported here as a twenty-byte hexadecimal handle rather than its real
+     * base58 mint, so matching a Solana token by its on-chain address against
+     * this field finds nothing. That is why {@link findNearIntentsAsset} takes an
+     * ecosystem and refuses to guess for the families where the field is not the
+     * address it appears to be.
+     */
+    contractAddress: string | null;
+    /**
+     * The service's own United States dollar price for this asset, or null
+     * when the response carried none. Verified live against `GET /v0/tokens`,
+     * 2026-09-24 — every entry checked carried one (e.g. wrapped NEAR at
+     * 3.11), so `null` here means an unpriced or malformed entry, not an
+     * absent field this parser failed to read.
+     */
+    price: number | null;
+    /**
+     * When the service last refreshed {@link price}, as the ISO 8601 instant
+     * it reports — or null when the response carried none. Kept alongside the
+     * price rather than assumed fresh, so a caller pricing a route can tell a
+     * live figure from a stale one.
+     */
+    priceUpdatedAt: string | null;
+};
+/**
+ * This repository's chain identifiers, keyed by the service's short chain name.
+ *
+ * The Ethereum-virtual-machine entries are read from viem rather than written
+ * down, because a chain identifier typed from memory is a hypothesis that every
+ * later reader will trust — and a wrong one here does not fail loudly, it
+ * simply quotes a different chain's token.
+ *
+ * The non-Ethereum entries are this repository's own identifiers for those
+ * families, which are Relay's numbers (see {@link relayChainIds}); the service
+ * uses short names and has no numeric identifier of its own to reconcile with.
+ *
+ * DELIBERATELY SHORTER THAN THE SERVICE'S CHAIN LIST. The service names about
+ * thirty-five chains. Only the ones this bridge can actually originate from or
+ * enter are listed, because an unlisted chain resolves to no asset and
+ * therefore to no route, which is the honest outcome, whereas a guessed
+ * identifier resolves to a route on the wrong chain.
+ */
+export declare const chainIdByNearIntentsChain: ReadonlyMap<string, number>;
+/**
+ * Reads `GET /v0/tokens` into the asset records the identifier lookup needs.
+ *
+ * An entry missing any field the lookup reads is dropped rather than patched
+ * with a default: an asset whose decimals were invented would price every
+ * amount wrong by orders of magnitude, and an asset whose identifier is
+ * missing cannot be quoted at all.
+ *
+ * @param payload - the raw JSON body from `GET /v0/tokens`
+ * @returns every readable asset, in the order the service listed them
+ */
+export declare const parseNearIntentsTokens: (payload: unknown) => NearIntentsAsset[];
+/**
+ * Finds the service's identifier for one token on one chain.
+ *
+ * THE IDENTIFIER CANNOT BE CONSTRUCTED, ONLY LOOKED UP. It reads like a
+ * pattern — a chain name, the token's address, a fixed suffix — and for an
+ * Ethereum-virtual-machine token it currently is one. It is not one for the
+ * other families: Solana's USD Coin carries a hexadecimal handle that is
+ * nothing like its base58 mint. Building the string from its parts therefore
+ * produces an identifier that is well-formed and refers to nothing, so the
+ * asset list is the only source.
+ *
+ * @param options.assets - the parsed asset list
+ * @param options.chainId - this repository's identifier for the chain
+ * @param options.tokenAddress - the token's address on that chain
+ * @param options.ecosystem - the chain's virtual-machine family, which decides
+ *   whether the native-coin test and the address comparison are meaningful
+ * @returns the matching asset, or null when the service does not carry it
+ */
+export declare const findNearIntentsAsset: ({ assets, chainId, tokenAddress, ecosystem, }: {
+    assets: readonly NearIntentsAsset[];
+    chainId: number;
+    tokenAddress: string;
+    ecosystem: Ecosystem;
+}) => NearIntentsAsset | null;
+/**
+ * Converts a slippage fraction into the basis points the service expects.
+ *
+ * @param slippage - tolerance as a fraction (0.005 means half a percent)
+ * @returns basis points (0.005 becomes 50)
+ */
+export declare const slippageToNearIntentsBasisPoints: (slippage: number) => number;
+/**
+ * The smallest Zcash deposit that can actually be credited, in base units:
+ * 0.01 Zcash.
+ *
+ * THE LARGER OF TWO FIGURES THAT DISAGREE. The quoting service prices a Zcash
+ * input down to about two cents — the smaller floor, read live from its
+ * refusal by {@link parseNearIntentsQuoteRefusal}. But Zcash crosses on the
+ * Proof of Authority bridge, not the Omni Bridge, and that bridge publishes
+ * `min_deposit_amount: 1000000` for native Zcash. A quote between the two is
+ * priced by one surface and below the other's floor, so it takes the money and
+ * stalls — and the published stuck-deposit recovery flow is written for the
+ * Omni Bridge, so it does not cover Zcash. Measured 2026-09-21; see
+ * `docs/near-intents-capability-survey.md`.
+ */
+export declare const zcashWorkingFloorBaseUnits = 1000000n;
+/**
+ * The working floor for a pay-by-hand chain, in base units, or null when the
+ * chain has none registered.
+ *
+ * EXPORTED SO A SCREEN NEVER KEEPS ITS OWN COPY. {@link isBelowWorkingFloor} is
+ * the decision this library enforces when quoting; this is the SAME table,
+ * exposed so a payment screen can PRINT the figure it refuses under instead of
+ * hand-copying the table — a copy that would silently disagree with quoting
+ * the moment a second pay-by-hand chain gets a floor here and not there.
+ *
+ * @param chainId - the origin chain
+ * @returns the floor in base units, or null when the chain has none
+ */
+export declare const workingFloorFor: (chainId: number) => bigint | null;
+/**
+ * Whether an amount is below the floor a deposit on this chain can actually
+ * be credited at.
+ *
+ * ASK IT BEFORE ASKING FOR A LIVE QUOTE. The quote request builder already
+ * declines such an amount, so no deposit address is ever issued for money that
+ * would stall. This predicate lets a surface say WHY there is no route, and
+ * what size would work.
+ *
+ * @param options.chainId - the origin chain
+ * @param options.amount - the input, in base units of the origin asset
+ * @returns whether the amount is below that chain's working floor
+ */
+export declare const isBelowWorkingFloor: ({ chainId, amount, }: {
+    chainId: number;
+    amount: bigint;
+}) => boolean;
+/**
+ * Builds the forward-solving origin-to-anchor pre-quote body.
+ *
+ * READ THE HEAD OF THIS MODULE BEFORE CALLING THIS FROM THE ROUTER. The
+ * entry-anchor pre-quote takes the largest delivered amount across providers
+ * and hands it to the providers that execute, so a pre-quote from a provider
+ * that cannot execute raises a target nobody can reach. This builder exists
+ * because the request shape is real and testable, not because that wiring is
+ * wanted.
+ *
+ * @param request - the provider-agnostic pre-quote request
+ * @param options - the asset list, the clock, and the referral tag
+ * @returns the request body, or null when the service carries neither asset or
+ *   the amount is not positive
+ */
+export declare const buildNearIntentsPreQuoteRequest: (request: PreQuoteRequest, context?: ProviderQuoteContext) => NearIntentsQuoteRequestBody | null;
+/**
+ * Builds the execution quote body for a crossing with nothing to run on arrival.
+ *
+ * REFUSES ANY REQUEST CARRYING A DESTINATION CALL, and that refusal is the
+ * whole point of it. The service has no field a call can travel in, so a
+ * request built without the call would look like a valid quote for the same
+ * route and would deliver the reader's funds to an address instead of into the
+ * omnibridge — a silent, funds-affecting difference. Returning null leaves that
+ * route to the providers that execute.
+ *
+ * @param request - the provider-agnostic consolidated request
+ * @param context - carries the asset list, the clock and the referral tag
+ * @param options.dry - price only, reserving nothing. What a route ON DISPLAY
+ *   must ask; a live quote reserves a deposit address for three days, so it is
+ *   asked only when the reader commits. See `UnreservedDeposit`.
+ * @returns the request body, or null when the route needs a destination call,
+ *   names no input amount, or the service carries neither asset
+ */
+export declare const buildNearIntentsQuoteRequest: (request: ConsolidatedQuoteRequest, context?: ProviderQuoteContext, { dry }?: {
+    dry?: boolean;
+}) => NearIntentsQuoteRequestBody | null;
+/**
+ * Parses a quote response into the delivered amounts a pre-quote reports.
+ *
+ * `amountOut` is the expected delivery and `minAmountOut` the guaranteed floor
+ * after slippage, which is the same pair the other providers' pre-quote parsers
+ * produce, so the three rank on like figures.
+ *
+ * @param payload - the raw JSON body from `POST /v0/quote`
+ * @returns the delivered amounts, or null when the payload is an error or
+ *   otherwise not a quote
+ */
+export declare const parseNearIntentsPreQuote: (payload: unknown) => PreQuoteResult | null;
+/**
+ * A normalized NEAR Intents quote.
+ *
+ * An alias of the shared shape rather than a variant of it: a quote from here
+ * ranks, displays and resumes exactly like the others. What differs is the
+ * shape of the ROUTE built around it — two signatures rather than one, because
+ * this provider delivers to an address and runs nothing on arrival. That
+ * difference lives in `near-intents-route.ts`, not in the quote.
+ */
+export type NearIntentsQuote = ConsolidatedQuote;
+/**
+ * Normalizes a DRY answer into a quote that can be drawn and not paid.
+ *
+ * Same figures, fees and timing as a live quote; its deposit is
+ * {@link UnreservedDeposit} and its `quoteId` is empty, because a dry answer
+ * reserves no address and the address is a quote's identity. A caller that
+ * reaches the commit asks live with `buildNearIntentsQuoteRequest(…, { dry:
+ * false })` and pays that answer instead.
+ *
+ * @param payload - the raw JSON body of a `dry: true` quote
+ * @param context - the same context the live parser reads
+ * @returns the priced quote, or null when the body is not a quote
+ */
+export declare const parseNearIntentsPriceQuote: (payload: unknown, context?: ProviderQuoteContext) => NearIntentsQuote | null;
+export declare const parseNearIntentsQuote: (payload: unknown, context?: ProviderQuoteContext) => NearIntentsQuote | null;
+/**
+ * Why the service declined to quote a route.
+ *
+ * TWO DIFFERENT FLOORS, AND THEY ARE NOT THE SAME KIND OF THING. One is
+ * economics and one is policy, they are measured in different units, and a
+ * caller that treats them alike will tell a reader the wrong number.
+ *
+ * - `belowChainMinimum` is an administrative floor on a whole chain, stated in
+ *   United States dollars. On 2026-09-17 it stood at one thousand dollars for
+ *   Binance Smart Chain and Polygon and one hundred for Tron, with no floor on
+ *   the other chains measured. The service's own wording calls it TEMPORARY, so
+ *   it is a figure to read from an answer, never one to write into this
+ *   repository — and it has already moved once, on 2026-09-09, when it was
+ *   introduced on nine chains of which only two still enforce it.
+ *
+ *   IT IS CHECKED AGAINST THE AMOUNT ASKED FOR, WHICHEVER SIDE THAT IS, not
+ *   against what the reader spends. Measured: a backward-solved request for
+ *   999 USD Coin on Binance Smart Chain is refused even though it would take
+ *   about 1,011 dollars of input to fill. So a route cannot be slipped under
+ *   the floor by asking the other way round, and a caller estimating whether
+ *   this provider will bid must compare the floor to the side it is asking for.
+ * - `belowBridgeMinimum` is the economic floor: a transfer so small the
+ *   withdrawal fee would consume it. The service quotes the figure live, in the
+ *   ORIGIN asset's base units, and it moves between requests because it tracks
+ *   that fee.
+ *
+ * Both arrive as HTTP 400 with a `message`, which is why they have to be read
+ * out of the body rather than inferred from the status.
+ */
+export type NearIntentsQuoteRefusal = {
+    reason: 'belowChainMinimum';
+    minimumUsd: number;
+} | {
+    reason: 'belowBridgeMinimum';
+    minimumAmount: bigint;
+} | {
+    reason: 'noLiquidity';
+} | {
+    reason: 'other';
+};
+/**
+ * Reads why a quote request was declined.
+ *
+ * WORTH READING RATHER THAN TREATING AS A FAILURE. A route below one of these
+ * floors is not a fault to retry — it is a route this provider will never
+ * carry at that size, so a router can drop the provider from the competition
+ * and a surface can say what size would work. Left as a bare rejection, the
+ * same route simply produces a slower answer with one fewer bidder and nothing
+ * on screen to explain it.
+ *
+ * @param payload - the raw JSON body of a declined `POST /v0/quote`
+ * @returns the refusal, or null when the body carries no message to read
+ */
+export declare const parseNearIntentsQuoteRefusal: (payload: unknown) => NearIntentsQuoteRefusal | null;
+/**
+ * Normalizes a `GET /v0/status` response.
+ *
+ * @param payload - the raw JSON body
+ * @returns the normalized status, or null when the payload names no status
+ */
+export declare const parseNearIntentsStatus: (payload: unknown) => ConsolidatedStatus | null;