@gibs/bridge-sdk 1.19.0 → 1.20.0

package/dist/cjs/route-steps.js

@@ -3,15 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeRelaySteps = exports.normalizeLifiSteps = void 0;
 const chain_names_js_1 = require("./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;
@@ -28,13 +19,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';
@@ -46,12 +30,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 ${(0, chain_names_js_1.chainDisplayName)(toChainId)}`;
@@ -63,15 +41,6 @@ const buildLifiLabel = (kind, toChainId, toolName) => {
         return `Unwrap to native on ${(0, chain_names_js_1.chainDisplayName)(toChainId)}`;
     return `Transfer on ${(0, chain_names_js_1.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
- */
 const normalizeLifiSteps = (steps) => {
     if (!Array.isArray(steps) || steps.length === 0) {
         return [];
@@ -92,12 +61,6 @@ 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);
@@ -117,10 +80,6 @@ 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);
@@ -138,15 +97,10 @@ 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,
@@ -169,12 +123,6 @@ const normalizeLifiSteps = (steps) => {
     return result;
 };
 exports.normalizeLifiSteps = normalizeLifiSteps;
-/**
- * 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);
@@ -183,8 +131,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;
     }
@@ -206,46 +152,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
- */
 const normalizeRelaySteps = (quote) => {
     const details = asRecord(asRecord(quote)?.details);
     const route = asRecord(details?.route);
@@ -260,15 +172,12 @@ 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) {
@@ -287,20 +196,11 @@ 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/cjs/routing/amounts.js

@@ -3,35 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.valueEquivalentAmount = exports.restateInDecimals = exports.netDeliveredAmount = void 0;
 const viem_1 = require("viem");
 const settings_js_1 = require("../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
- */
 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;
     }
@@ -40,25 +12,6 @@ const netDeliveredAmount = (entryChainAmount, omnibridgeFeePerEther) => {
     return net ?? entryChainAmount;
 };
 exports.netDeliveredAmount = netDeliveredAmount;
-/**
- * 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
- */
 const restateInDecimals = ({ amount, fromDecimals, toDecimals, }) => {
     if (fromDecimals === toDecimals)
         return amount;
@@ -67,47 +20,11 @@ const restateInDecimals = ({ amount, fromDecimals, toDecimals, }) => {
     return amount / 10n ** BigInt(fromDecimals - toDecimals);
 };
 exports.restateInDecimals = restateInDecimals;
-/**
- * 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
- */
 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 (0, exports.restateInDecimals)({ amount, fromDecimals, toDecimals });
     const valueUsd = Number((0, viem_1.formatUnits)(amount, fromDecimals)) * fromPrice;

package/dist/cjs/routing/candidate-route.js

@@ -4,85 +4,12 @@ exports.routeSignatureCountForAccount = exports.routeSignatureCount = exports.bu
 const near_intents_route_js_1 = require("../near-intents-route.js");
 const execution_js_1 = require("../execution.js");
 const producers_js_1 = require("./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
- */
 const buildRouteDataForCandidate = (candidate) => candidate.deferredCrossing
     ? (0, near_intents_route_js_1.buildNearIntentsTwoStepRouteData)(candidate)
     : (0, producers_js_1.buildCandidateRouteData)(candidate);
 exports.buildRouteDataForCandidate = buildRouteDataForCandidate;
-/**
- * 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.
- *
- * 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, with no approvals
- */
 const routeSignatureCount = (route) => route.sections.length;
 exports.routeSignatureCount = routeSignatureCount;
-/**
- * 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
- */
 const routeSignatureCountForAccount = async (inputs) => {
     const plan = await (0, execution_js_1.planCandidateExecution)(inputs);
     if (plan.kind === 'refused') {

package/dist/cjs/routing/candidate.js

@@ -4,39 +4,6 @@ exports.buildDirectCrossingCandidate = void 0;
 const viem_1 = require("viem");
 const amounts_js_1 = require("./amounts.js");
 const providers_js_1 = require("./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`)
- */
 const buildDirectCrossingCandidate = ({ entryChainId, originChainId, originToken, destinationToken, amountIn, originUsdPrice, destinationUsdPrice, omnibridgeFeePerEther, }) => {
     const provider = (0, providers_js_1.omnibridgeProviderForEntryChain)(entryChainId);
     if (provider === null) {
@@ -52,13 +19,6 @@ const buildDirectCrossingCandidate = ({ entryChainId, originChainId, originToken
         : 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,
@@ -68,9 +28,6 @@ const buildDirectCrossingCandidate = ({ entryChainId, originChainId, originToken
         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',
@@ -91,9 +48,6 @@ const buildDirectCrossingCandidate = ({ entryChainId, originChainId, originToken
         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/cjs/routing/carrier-provider-key.js

@@ -3,40 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.carrierStepKind = exports.carrierProviderKey = exports.WRAP_CARRIER_ID = void 0;
 const config_js_1 = require("../config.js");
 const providers_js_1 = require("../providers.js");
-/**
- * The carrier id of the native-coin wrap and unwrap step
- * (`routing/carriers/wrap.ts`).
- */
 exports.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(config_js_1.Providers).map((provider) => [provider, provider]),
     ...providers_js_1.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
- */
 const carrierProviderKey = (carrierId) => providerKeyByCarrierId.get(carrierId) ?? null;
 exports.carrierProviderKey = carrierProviderKey;
-/**
- * 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
- */
 const carrierStepKind = (carrierId) => carrierId === exports.WRAP_CARRIER_ID ? 'wrap' : null;
 exports.carrierStepKind = carrierStepKind;