@gibs/bridge-sdk 1.18.0 → 1.20.0

package/dist/route-steps.js

@@ -1,14 +1,5 @@
 import { chainDisplayName } from './chain-names.js';
 const isHexString = (value) => typeof value === 'string' && value.startsWith('0x');
-/**
- * Sums the `amountUSD` field across a LI.FI cost array (`feeCosts` or
- * `gasCosts`), tolerating missing/malformed entries by skipping them. LI.FI
- * reports each cost's dollar value as a numeric string; entries without a finite
- * `amountUSD` contribute nothing rather than poisoning the sum with `NaN`.
- *
- * @param costs - a raw `feeCosts`/`gasCosts` value from a step estimate
- * @returns the total United States dollar cost; zero when none are present
- */
 const sumUsdCosts = (costs) => {
     if (!Array.isArray(costs)) {
         return 0;
@@ -25,13 +16,6 @@ const asRecord = (value) => {
     }
     return value;
 };
-/**
- * Maps a LI.FI step type string to the normalized `RouteStepKind`.
- *
- * LI.FI reports `"cross"` for bridge legs and `"swap"` for same-chain
- * exchanges. `"wrap"` and `"unwrap"` map directly. Unknown types fall back to
- * `"send"` rather than failing the whole normalization.
- */
 const lifiTypeToKind = (type) => {
     if (type === 'cross')
         return 'bridge';
@@ -43,12 +27,6 @@ const lifiTypeToKind = (type) => {
         return 'unwrap';
     return 'send';
 };
-/**
- * Builds a human-readable label for a LI.FI step.
- *
- * Labels are fully spelled out (no acronyms) so they can be displayed
- * directly in the UI without any post-processing.
- */
 const buildLifiLabel = (kind, toChainId, toolName) => {
     if (kind === 'bridge')
         return `Bridge to ${chainDisplayName(toChainId)}`;
@@ -60,15 +38,6 @@ const buildLifiLabel = (kind, toChainId, toolName) => {
         return `Unwrap to native on ${chainDisplayName(toChainId)}`;
     return `Transfer on ${chainDisplayName(toChainId)}`;
 };
-/**
- * Normalizes a LI.FI `includedSteps` array into the provider-agnostic
- * `RouteStep[]` shape. Steps with missing or non-hex token addresses are
- * silently dropped rather than causing the whole normalization to fail.
- *
- * @param steps - the raw `includedSteps` value from a LI.FI quote response,
- *   or `undefined` when the field was absent (trimmed responses)
- * @returns ordered list of normalized steps; empty when no usable legs are present
- */
 export const normalizeLifiSteps = (steps) => {
     if (!Array.isArray(steps) || steps.length === 0) {
         return [];
@@ -89,12 +58,6 @@ export const normalizeLifiSteps = (steps) => {
         if (fromChainId === null || toChainId === null) {
             continue;
         }
-        // A step that changes chains IS a bridge, whatever the provider called its
-        // type. LI.FI labels most cross-chain legs `"cross"`, but some (e.g. an Across
-        // leg, or a `"protocol"`/`"lifi"`-typed leg) would otherwise fall through to
-        // the generic `"send"` kind and read as "Transfer on Ethereum" — misleading,
-        // since the funds are actually being BRIDGED there. Deciding from the chains
-        // rather than the type string keeps the label honest.
         const typeKind = lifiTypeToKind(type);
         const kind = typeKind === 'send' && fromChainId !== toChainId ? 'bridge' : typeKind;
         const fromTokenRecord = asRecord(action.fromToken);
@@ -114,10 +77,6 @@ export const normalizeLifiSteps = (steps) => {
             : typeof step.tool === 'string'
                 ? step.tool
                 : 'unknown';
-        // The per-step tool's logo, when the provider supplies one. This is the best
-        // source for a real service-provider image on the consuming interface (for
-        // example the Uniswap or Stargate logo for the leg the aggregator routes
-        // through). Null when absent, so the interface falls back to an initials tile.
         const providerLogoUri = typeof toolDetails?.logoURI === 'string' ? toolDetails.logoURI : null;
         const label = buildLifiLabel(kind, toChainId, toolName);
         const estimate = asRecord(step.estimate);
@@ -135,15 +94,10 @@ export const normalizeLifiSteps = (steps) => {
         const router = isHexString(integrationData?.callToAddress)
             ? integrationData.callToAddress
             : null;
-        // Per-step cost = protocol fees + gas, both reported in United States dollars.
-        // Null when the provider reported neither, so the UI omits the hop's fee.
         const protocolFeeUsd = sumUsdCosts(estimate?.feeCosts);
         const gasCostUsd = sumUsdCosts(estimate?.gasCosts);
         const stepCostUsd = protocolFeeUsd + gasCostUsd;
         const feeUsd = stepCostUsd > 0 ? stepCostUsd : null;
-        // Gas alone, for route ranking (which charges gas on top of the paid-versus-
-        // delivered spread and must not double-count the protocol fees already baked
-        // into the quote's `fromAmount`). Null when no gas was reported.
         const gasUsd = gasCostUsd > 0 ? gasCostUsd : null;
         result.push({
             kind,
@@ -165,12 +119,6 @@ export const normalizeLifiSteps = (steps) => {
     }
     return result;
 };
-/**
- * Parses one `{ currency, amount }` entry from Relay's `details.route`.
- *
- * @param value - a raw `inputCurrency`/`outputCurrency` value
- * @returns the endpoint, or null when the chain id or address is unusable
- */
 const relayRouteEndpoint = (value) => {
     const entry = asRecord(value);
     const currency = asRecord(entry?.currency);
@@ -179,8 +127,6 @@ const relayRouteEndpoint = (value) => {
     }
     const chainId = typeof currency.chainId === 'number' ? currency.chainId : null;
     const address = typeof currency.address === 'string' ? currency.address : null;
-    // Without a chain and an identifier there is no leg to describe. Both are
-    // always present in Relay's verified shape; bail rather than invent one.
     if (chainId === null || address === null) {
         return null;
     }
@@ -202,46 +148,12 @@ const relayRouteEndpoint = (value) => {
         amount,
     };
 };
-/**
- * Reads a `{ amountUsd }` entry from Relay's `fees` object as a number.
- * Relay reports dollar values as numeric strings; anything non-finite
- * contributes nothing rather than poisoning the sum with `NaN`.
- */
 const relayFeeUsd = (fees, key) => {
     const fee = asRecord(fees?.[key]);
     const amountUsd = typeof fee?.amountUsd === 'string' ? Number(fee.amountUsd) : Number.NaN;
     return Number.isFinite(amountUsd) ? amountUsd : 0;
 };
-/** True when two endpoints are the same currency on the same chain. */
 const isSameEndpoint = (left, right) => left.chainId === right.chainId && left.address === right.address;
-/**
- * Normalizes a Relay quote into the provider-agnostic `RouteStep[]` shape.
- *
- * Relay's `steps` array holds only OPERATIONAL steps (`approve` and `deposit`) —
- * what the user signs, not where the funds go. The route itself lives in
- * `details.route`, which describes the journey as an origin leg and a
- * destination leg, each with an input and an output currency. Reading those four
- * endpoints in order and emitting a step between each consecutive pair recovers
- * the real path, so a Bitcoin origin renders as "Bitcoin → United States Dollar
- * Coin on Ethereum" rather than as nothing at all.
- *
- * Consecutive endpoints that name the same currency on the same chain are
- * collapsed, because Relay repeats an endpoint when a leg performs no
- * conversion. A step's kind follows from its chains: crossing chains is a
- * `bridge`, staying put is a `swap`. Relay reports no wrap/unwrap distinction,
- * so none is invented.
- *
- * Costs are route-level in Relay's response, not per leg, so they are attached
- * to the FIRST step — the one the user actually signs and pays at. `gasUsd`
- * carries `fees.gas` alone (the origin transaction's gas, paid on top in the
- * network's native token), while `feeUsd` adds the relayer and application fees
- * on top of it, matching how the LI.FI normalizer splits the two. The relayer
- * fee's `relayerGas`/`relayerService` components are deliberately NOT summed:
- * they add up to `relayer` exactly, so counting them would double the fee.
- *
- * @param quote - a raw Relay quote response body
- * @returns ordered list of normalized steps; empty when no route is present
- */
 export const normalizeRelaySteps = (quote) => {
     const details = asRecord(asRecord(quote)?.details);
     const route = asRecord(details?.route);
@@ -256,15 +168,12 @@ export const normalizeRelaySteps = (quote) => {
         relayRouteEndpoint(destination?.inputCurrency),
         relayRouteEndpoint(destination?.outputCurrency),
     ].filter((endpoint) => endpoint !== null);
-    // Collapse repeats so a leg that converts nothing does not become a step.
     const path = endpoints.filter((endpoint, index) => index === 0 || !isSameEndpoint(endpoint, endpoints[index - 1]));
     if (path.length < 2) {
         return [];
     }
     const fees = asRecord(asRecord(quote)?.fees);
     const gasUsd = relayFeeUsd(fees, 'gas');
-    // `relayer` is the full relayer charge; its `relayerGas` and `relayerService`
-    // components sum to it exactly, so only the total is counted here.
     const totalUsd = gasUsd + relayFeeUsd(fees, 'relayer') + relayFeeUsd(fees, 'app');
     const result = [];
     for (let index = 1; index < path.length; index += 1) {
@@ -283,20 +192,11 @@ export const normalizeRelaySteps = (quote) => {
             toToken: to.address,
             fromTokenSymbol: from.symbol,
             toTokenSymbol: to.symbol,
-            // Relay's currency metadata carries the TOKEN's own image, which is the only
-            // one available for a non-Ethereum endpoint (Bitcoin, Solana, Tron, The Open
-            // Network) — the image service cannot key those by a hex address.
             fromTokenLogoUri: from.logoUri,
             toTokenLogoUri: to.logoUri,
-            // Relay's `router` field on a route leg names the service ("relay"), not a
-            // contract address, so there is no router address to surface for the leg.
             router: null,
-            // Relay supplies a logo for the currency, not for a per-leg tool, so the
-            // consuming interface falls back to the provider tile. Deliberately null
-            // rather than passing a token image off as a service-provider image.
             providerLogoUri: null,
             estimatedOut: to.amount,
-            // Route-level costs land on the signed step; later legs run inside it.
             feeUsd: isFirstStep && totalUsd > 0 ? totalUsd : null,
             gasUsd: isFirstStep && gasUsd > 0 ? gasUsd : null,
         });

package/dist/routing/amounts.js

@@ -1,34 +1,6 @@
 import { formatUnits, parseUnits } from 'viem';
 import { amountAfterBridgeFee, bridgeCost } from '../settings.js';
-/**
- * The amount that actually LANDS on PulseChain for an aggregator candidate, net
- * of the omnibridge crossing fee.
- *
- * The aggregator delivers `entryChainAmount` (the consolidated request's
- * `toAmount`) onto the omnibridge entry chain, and the omnibridge entry call
- * relays exactly that — but the omnibridge takes its foreign→home crossing fee on
- * the way to PulseChain, so the user receives LESS than `entryChainAmount`. This
- * nets that crossing fee out using the SDK's OWN fee primitives ({@link bridgeCost}
- * and {@link amountAfterBridgeFee}) — the identical math the direct engine applies
- * — so the displayed received amount is honest rather than overstated.
- *
- * The multiplexed (aggregator) swap fees are NOT subtracted here: the aggregator
- * already quotes the source-chain `fromAmount` it needs to GUARANTEE
- * `entryChainAmount` arrives, so those fees are already reflected in `fromAmount`.
- * Only the omnibridge crossing fee remains to net out, which is this function's
- * sole job.
- *
- * @param entryChainAmount - the amount arriving on the entry chain (request `toAmount`)
- * @param omnibridgeFeePerEther - the omnibridge foreign→home fee rate (per 1e18), or null
- * @returns the net amount delivered on PulseChain; equals `entryChainAmount` when the fee is unknown
- */
 export const netDeliveredAmount = (entryChainAmount, omnibridgeFeePerEther) => {
-    // Defensive: the omnibridge percentage math runs ONLY when both operands are
-    // true bigints. A non-bigint fee (a value rehydrated from storage as a string,
-    // the project's documented BigInt-serialization gotcha) would throw inside
-    // `bridgeCost`'s mixed-type multiplication, so fall back to the un-netted
-    // entry-chain amount rather than crash the render. The `typeof` guards intentionally
-    // outlive the static `bigint` types because the runtime value can violate them.
     if (typeof entryChainAmount !== 'bigint' || typeof omnibridgeFeePerEther !== 'bigint') {
         return entryChainAmount;
     }
@@ -36,25 +8,6 @@ export const netDeliveredAmount = (entryChainAmount, omnibridgeFeePerEther) => {
     const net = amountAfterBridgeFee({ amountToBridge: entryChainAmount, bridgeCost: cost });
     return net ?? entryChainAmount;
 };
-/**
- * Restates an amount in a different token's decimals, preserving the QUANTITY.
- *
- * This is the honest degraded answer when {@link valueEquivalentAmount} cannot
- * price a conversion. Losing the price must not also lose the decimals: the two
- * omnibridge anchors hold the same asset bridged two ways, and the only
- * difference between them is where the decimal point sits. Returning an
- * unadjusted amount across that gap is wrong by a factor of 10^12, which is the
- * exact error the value conversion exists to prevent.
- *
- * Scaling DOWN truncates, and must — a six-decimal token cannot hold the twelve
- * extra digits an eighteen-decimal one carries. The lost remainder is smaller
- * than one base unit of the target.
- *
- * @param params.amount - the amount, in `fromDecimals` base units
- * @param params.fromDecimals - the decimals the amount is currently expressed in
- * @param params.toDecimals - the decimals to restate it in
- * @returns the same quantity, in `toDecimals` base units
- */
 export const restateInDecimals = ({ amount, fromDecimals, toDecimals, }) => {
     if (fromDecimals === toDecimals)
         return amount;
@@ -62,47 +15,11 @@ export const restateInDecimals = ({ amount, fromDecimals, toDecimals, }) => {
         return amount * 10n ** BigInt(toDecimals - fromDecimals);
     return amount / 10n ** BigInt(fromDecimals - toDecimals);
 };
-/**
- * Converts `amount` of a source token into the base-unit amount of a TARGET token
- * carrying the SAME United States dollar value:
- *
- *   valueUsd     = amount / 10^fromDecimals × fromPrice
- *   targetAmount = valueUsd / toPrice × 10^toDecimals
- *
- * This is what lets the two omnibridge entry points be quoted for the SAME VALUE
- * even when their anchor tokens differ in decimals — a PulseChain-bridged
- * stablecoin is 6 decimals when bridged from Ethereum but 18 from Binance Smart
- * Chain. Feeding one raw integer to both targeted quantities ~10^12 apart, so the
- * routes were not comparable and the higher-decimal entry won on a bigger NUMBER
- * rather than more value. Targeting equal value in each anchor's own decimals
- * restores a fair, decimals-correct comparison.
- *
- * Returns null when either price is missing or non-positive, the scaled value is
- * not finite, or the target cannot be parsed — the caller then has no
- * value-equivalent target and must fall back rather than quote a bogus amount.
- *
- * @param params.amount - the source amount, in `fromDecimals` base units
- * @param params.fromDecimals - the source token's decimals
- * @param params.fromPrice - the source token's per-token United States dollar price, or null
- * @param params.toDecimals - the target token's decimals
- * @param params.toPrice - the target token's per-token United States dollar price, or null
- * @returns the value-equivalent amount in the target token's base units, or null
- */
 export const valueEquivalentAmount = ({ amount, fromDecimals, fromPrice, toDecimals, toPrice, }) => {
     if (fromPrice === null || toPrice === null)
         return null;
     if (!(fromPrice > 0) || !(toPrice > 0))
         return null;
-    // Equal prices make this a pure change of decimals, and integer rescaling is
-    // EXACT where the double round trip is not. `39.3` is not representable as a
-    // double, so `toFixed(18)` writes 39.299999999999997158 and the conversion
-    // comes back 2842 base units short of the 39.3 that went in. At the same
-    // decimals it lands one unit out (0.008802 returns as 8802000000000001).
-    //
-    // Both are negligible in value and neither is a reason to convert at all: with
-    // one price on both sides there is no value question to answer, only a decimal
-    // point to move. Moving it in integers keeps the same input producing the same
-    // target.
     if (fromPrice === toPrice)
         return restateInDecimals({ amount, fromDecimals, toDecimals });
     const valueUsd = Number(formatUnits(amount, fromDecimals)) * fromPrice;

package/dist/routing/candidate-route.d.ts

@@ -1,3 +1,4 @@
+import { type CandidateExecutionInputs } from '../execution.js';
 import type { RouteCandidate } from './candidate.js';
 import type { RouteData } from './route-data.js';
 /**
@@ -37,7 +38,51 @@ export declare const buildRouteDataForCandidate: (candidate: RouteCandidate) =>
  * site, so a surface that warns about a long journey and a surface that ranks
  * routes cannot come to different counts.
  *
+ * THIS COUNT LEAVES OUT APPROVALS. A token that is not the chain's native coin
+ * needs an `approve` transaction before its first section when the allowance
+ * is too small, and that approval is a signature too. Raw route data does not
+ * say who the spender is or what the account has approved already, so this
+ * function cannot count it. Use {@link routeSignatureCountForAccount} for the
+ * number the wallet will really ask for.
+ *
  * @param route - the raw route data
- * @returns the number of signatures, one per section
+ * @returns the number of signatures, one per section, with no approvals
  */
 export declare const routeSignatureCount: (route: RouteData) => number;
+/** What {@link routeSignatureCountForAccount} reports. */
+export type RouteSignatureCount = {
+    /** Signatures for the sections themselves: one per planned section. */
+    readonly signatures: number;
+    /** Approval transactions the account must sign first, given what it has approved already. */
+    readonly approvals: number;
+    /** `signatures + approvals`: every wallet prompt the planned sections cause. */
+    readonly total: number;
+};
+/**
+ * How many wallet signatures a route asks one account for, approvals included.
+ *
+ * {@link routeSignatureCount} counts sections only, so a USDC route reads "1"
+ * and then asks for two prompts: approve, then send. This function plans the
+ * sections with {@link planCandidateExecution} and counts what that plan
+ * contains, so it uses the same allowance rule and the same spender the
+ * execution planner uses. A native input needs no approval. An allowance that
+ * already covers the amount needs none. A smaller, non-zero allowance counts
+ * the reset and the new approval, the two transactions the planner emits. The
+ * spender is whatever the planner picks: the omnibridge mediator, a swap
+ * venue's router (including routers passed in `swapVenues`), or the
+ * aggregator's approval address.
+ *
+ * Pass every section of the route to count the whole route. Pass fewer to
+ * count only the window you plan now; each section is counted against the
+ * allowance on chain today, so a later section that spends a token an earlier
+ * section delivers is counted as if the approval is still needed.
+ *
+ * An aggregator section needs its `aggregator` inputs, a quote and the request
+ * it answered, exactly as {@link planCandidateExecution} does. Without them
+ * this function throws, because the approval spender comes from that quote.
+ *
+ * @param inputs - the same inputs {@link planCandidateExecution} takes
+ * @returns the signatures, approvals, and their total
+ * @throws when a section cannot be planned; the message names the section and the reason
+ */
+export declare const routeSignatureCountForAccount: (inputs: CandidateExecutionInputs) => Promise<RouteSignatureCount>;

package/dist/routing/candidate-route.js

@@ -1,45 +1,16 @@
 import { buildNearIntentsTwoStepRouteData } from '../near-intents-route.js';
+import { planCandidateExecution } from '../execution.js';
 import { buildCandidateRouteData } from './producers.js';
-/**
- * One door in front of the two base route builders.
- *
- * WHY THIS EXISTS. A candidate is drawn by one of two builders and the choice
- * is not the caller's to make by hand. {@link buildCandidateRouteData} draws a
- * candidate as ONE signature, because the aggregator's executor performs the
- * omnibridge entry call on arrival. {@link buildNearIntentsTwoStepRouteData}
- * draws it as TWO, because the aggregator that carried it cannot execute
- * anything on the chain it delivers to, so the reader signs the crossing
- * themselves.
- *
- * Every composer that builds on top of a candidate — the PulseX conversion
- * route is the first — has to pick between them, and picking wrong is not a
- * cosmetic error. A two-signature candidate run through the one-signature
- * builder produces a route that claims the crossing happens inside the
- * transaction the reader already signed. It does not. The reader would select
- * that route, sign once, and be left holding the anchor token on the entry
- * chain with the interface reporting the journey finished.
- *
- * `candidate.deferredCrossing` is the fact that decides it, and it is the same
- * field {@link buildNearIntentsTwoStepRouteData} refuses to build without. So
- * the two agree by construction rather than by two callers remembering the
- * same rule.
- *
- * @param candidate - the priced route candidate
- * @returns the raw route data, or null when the candidate names a deferred
- *   crossing but no omnibridge provider to perform it
- */
 export const buildRouteDataForCandidate = (candidate) => candidate.deferredCrossing
     ? buildNearIntentsTwoStepRouteData(candidate)
     : buildCandidateRouteData(candidate);
-/**
- * How many wallet signatures a raw route asks the reader for.
- *
- * Counts the sections, because one section is one signature — that is what a
- * section means. Named rather than left as `sections.length` at each call
- * site, so a surface that warns about a long journey and a surface that ranks
- * routes cannot come to different counts.
- *
- * @param route - the raw route data
- * @returns the number of signatures, one per section
- */
 export const routeSignatureCount = (route) => route.sections.length;
+export const routeSignatureCountForAccount = async (inputs) => {
+    const plan = await planCandidateExecution(inputs);
+    if (plan.kind === 'refused') {
+        throw new Error(`Cannot count signatures: section ${plan.sectionIndex} cannot be planned (${JSON.stringify(plan.refusal)}).`);
+    }
+    const approvals = plan.transactions.filter((transaction) => transaction.kind === 'approve').length;
+    const signatures = plan.transactions.length - approvals;
+    return { signatures, approvals, total: plan.transactions.length };
+};

package/dist/routing/candidate.js

@@ -1,39 +1,6 @@
 import { formatUnits } from 'viem';
 import { netDeliveredAmount } from './amounts.js';
 import { omnibridgeProviderForEntryChain } from './providers.js';
-/**
- * Synthesizes a {@link RouteCandidate} for the SAME-CHAIN direct-omnibridge
- * conversion case: when the origin chain IS one of the omnibridge entry chains
- * (Ethereum chain 1 or Binance Smart Chain chain 56), there is no aggregator leg
- * to quote — the user bridges directly from that chain to PulseChain. The
- * same-chain skip in {@link useAggregatorRouteCandidate} is correct (nothing to
- * quote), but it left the conversion path empty. This helper fills that gap by
- * synthesizing a zero-step candidate. The user interface no longer calls this:
- * the route engine serves a conversion now. The export stays as published
- * interface until a separate decision removes it.
- *
- * The synthetic quote carries zero steps (no aggregator hops), a zero execution
- * duration (the direct crossing needs no quote wait), and a null transaction
- * request — this candidate is DISPLAY and RANKING only. The candidate's
- * `deliveredAmount` is net of the omnibridge crossing fee, identical to the math
- * {@link useAggregatorRouteCandidate} applies.
- *
- * This is a PURE exported helper (no hooks, no side effects) so it is
- * unit-testable in isolation and can be called from two `useMemo` blocks in
- * Bridge.tsx without duplicating the object literal.
- *
- * EXECUTION: when the route built from this candidate is selected, the
- * consolidated (aggregator) execute path is deliberately NOT used — there is no
- * aggregator leg for it to sign. `executesViaConsolidated`
- * (`packages/ui/src/lib/state/bridgeExecution.ts`) recognizes the candidate's
- * `entryChainId === originChainId` and routes the selection through the direct
- * omnibridge sender instead, which builds its transaction from the live
- * `useBridgeSettings` cascade rather than from this synthetic quote.
- *
- * @param inputs - the entry chain, origin/destination tokens, amount, and fee rate
- * @returns the synthesized RouteCandidate, or throws when the entry chain is not
- *   a valid omnibridge entry point (caller must guard on `omnibridgeProviderForEntryChain`)
- */
 export const buildDirectCrossingCandidate = ({ entryChainId, originChainId, originToken, destinationToken, amountIn, originUsdPrice, destinationUsdPrice, omnibridgeFeePerEther, }) => {
     const provider = omnibridgeProviderForEntryChain(entryChainId);
     if (provider === null) {
@@ -49,13 +16,6 @@ export const buildDirectCrossingCandidate = ({ entryChainId, originChainId, orig
         : null;
     const quoteId = `direct-omnibridge-${entryChainId}-${originChainId}`;
     const syntheticQuote = {
-        // The synthetic quote wraps the omnibridge provider slug. ConsolidatedQuote's
-        // `provider` field is typed for the aggregator providers ('lifi' | 'relay'),
-        // but the functions that read it (`resolveProviderDisplayName`,
-        // `resolveProviderLogoUri`) accept any string at runtime. The cast is safe here
-        // because no aggregator-specific code path runs on a zero-step candidate —
-        // this synthetic quote is never itself signed; see the module doc comment
-        // above for where execution actually happens for the route built from it.
         provider: provider,
         quoteId,
         tool: provider,
@@ -65,9 +25,6 @@ export const buildDirectCrossingCandidate = ({ entryChainId, originChainId, orig
         approvalAddress: null,
         executionDurationSeconds: 0,
         steps: [],
-        // A direct crossing carries no aggregator, so there is no carrier fee to
-        // report. The omnibridge's own crossing fee is `omnibridgeFeeAmount`
-        // beside it, which the route surfaces separately.
         fees: [],
         originDeposit: {
             ecosystem: 'evm',
@@ -88,9 +45,6 @@ export const buildDirectCrossingCandidate = ({ entryChainId, originChainId, orig
         deliveredAmount: delivered,
         omnibridgeFeeAmount,
         destinationUsdPrice,
-        // A same-chain crossing has no aggregator leg to solve backward, so it spends
-        // exactly what was typed — requested and spent are the same figure by
-        // construction, and the route reports nothing unspent.
         requestedAmount: amountIn,
     };
 };

package/dist/routing/carrier-provider-key.js

@@ -1,37 +1,10 @@
 import { Providers } from '../config.js';
 import { providerRegistry } from '../providers.js';
-/**
- * The carrier id of the native-coin wrap and unwrap step
- * (`routing/carriers/wrap.ts`).
- */
 export const WRAP_CARRIER_ID = 'wrap';
-/**
- * Every engine carrier id that IS a provider, mapped to its {@link ProviderKey}.
- * The omnibridge crossings carry the provider value itself; the aggregators
- * carry their registry id; the PulseChain exchange carries its own literal.
- */
 const providerKeyByCarrierId = new Map([
     ...Object.values(Providers).map((provider) => [provider, provider]),
     ...providerRegistry.map((descriptor) => [descriptor.id, descriptor.id]),
     ['PulseX', 'PulseX'],
 ]);
-/**
- * The one place an engine carrier id becomes a {@link ProviderKey}.
- *
- * AN ENGINE CARRIER ID IS NOT A PROVIDER KEY. The engine is a plug-in host: a
- * carrier id is any string, and one of them, `'wrap'`, names a step that no
- * provider performs. Handing a raw id to the logo, glyph, or name tables drew a
- * blank mark and logged an error. Route data resolves the key here, once, and
- * every display site reads the resolved key.
- *
- * @param carrierId - the `carrier` of a planned hop's edge
- * @returns the provider key, or null when no registered provider carries that id
- */
 export const carrierProviderKey = (carrierId) => providerKeyByCarrierId.get(carrierId) ?? null;
-/**
- * The kind of provider-less step a carrier id performs.
- *
- * @param carrierId - the `carrier` of a planned hop's edge
- * @returns the step kind, or null when the carrier is a provider or unknown
- */
 export const carrierStepKind = (carrierId) => carrierId === WRAP_CARRIER_ID ? 'wrap' : null;