@gibs/bridge-sdk 1.19.0 → 1.20.0

package/dist/chains.js

@@ -1,99 +1,8 @@
-// Relative, not through this package's own name. A self-reference resolves
-// through the `exports` map, which now points at the compiled `dist` — so the
-// same module would be loaded twice, once as source and once as build output,
-// and `Chains.PLS` from one would not be the same object as from the other.
 import { chainDisplayName } from './chain-names.js';
 import { Chains, toChain } from './config.js';
 import * as imageLinks from './image-links.js';
-// Chain definitions come from viem, not from a wallet-connection library. These
-// five objects are identical in `@reown/appkit/networks`, which is where they used
-// to be imported from — but that made a package with no user interface depend on a
-// wallet modal, and it was never declared in `dependencies`, so the root entry
-// point of this package could not be loaded by anyone outside this repository.
 import { bsc, mainnet, pulsechain, pulsechainV4, sepolia } from 'viem/chains';
-/**
- * Builds an endpoint on valve.city, which proxies four of this dapp's chains.
- *
- * DEMO ONLY. These endpoints live in {@link demoRpcUrls}, never in
- * {@link chainsMetadata}. A third party that hands `chainsMetadata` to viem with
- * a bare `http()` gets the public endpoints below, not this shared key. The Gibs
- * interface asks for the demo list by name (`@gibs/bridge-client`'s
- * `clientFromChain`). Any other caller should pass its own clients.
- *
- * The key in this URL is `vk_demo`, and it is MEANT to be here. It is the
- * proxy's published demo key — it is already listed on chainlist.org, so it is
- * public knowledge and shipping it in a browser bundle discloses nothing. The
- * proxy reflects any `Origin` back, which is what makes it usable at all from
- * an IPFS build: the same bundle is served from gib.show, from ipfs.io, from
- * dweb.link, and from a local node, so an origin-locked key would break every
- * gateway but one.
- *
- * NEVER replace this with the unlimited key from 1Password. That one is a
- * bearer credential, this file compiles into the public bundle, and the two
- * facts together would hand an unmetered proxy to every visitor.
- *
- * Only chains 1, 369, 943 and 11155111 are proxied; the service lists them at
- * its root. Binance Smart Chain is not, which is why it keeps a public endpoint
- * alone. Every chain below keeps its previous endpoints after this one, so a
- * valve.city outage falls through to where it used to go rather than breaking.
- *
- * IT LEADS EVERY LIST IT APPEARS IN, and the measurement that says it may is
- * not a burst — it is the shape this interface actually produces.
- *
- * MEASURED 2026-08-29, against the real cadence rather than a synthetic flood:
- *
- *   steady, 1 request per 4 seconds for 3 minutes   45 of 45 answered 200
- *   bursts, 8 concurrent, four rounds                30 of 32 answered 200
- *   20 requests at concurrency 1, 2, 4, 6 and 8      20 of 20 every time
- *   20 requests at concurrency 12                    19 of 20
- *
- * Four seconds is not arbitrary: `watchBlocks` runs on viem's default poll, one
- * per watched chain, and `clientFromChain` coalesces up to 32 JSON-RPC calls
- * made within 10ms into ONE HTTP POST. So the interface's request rate is about
- * a quarter of a request per second per chain, and the key handles four times
- * that without a single refusal.
- *
- * AN EARLIER READING SAID THE OPPOSITE AND WAS MEASURING SOMETHING ELSE. On
- * 2026-08-27 this key answered 429 for four requests in five — from 40 requests
- * at 12 concurrent, fired four times back to back across four chains, roughly
- * 160 requests with no pause. That exhausts a windowed budget. No browser does
- * it. The reading before THAT one was 40 CONSECUTIVE requests, which cannot see
- * a rate limit at all because it paces itself. Both were honest measurements of
- * the wrong thing.
- *
- * THE PROBE STORM WAS THE REAL CULPRIT. `fallback` used to run `rank: true`,
- * which pings every url on every chain every few seconds forever — on an idle
- * page, every outbound request was one of those. That is what spent the key's
- * budget. It is off now (see `packages/common/src/client.ts`), and the
- * demotion that shipped alongside turning it off was treating the symptom.
- *
- * THE SPARE BEHIND IT IS STILL LOAD-BEARING. `vk_demo` is shared — published on
- * chainlist.org — so the budget is not ours alone and the headroom moves with
- * other people's use. About one burst request in sixteen still meets a 429, and
- * a 429 is an HTTP error, so `fallback` moves to the next entry at once. The
- * cost is one wasted round trip on a small fraction of burst requests, not a
- * failed read. Never leave a proxied chain with valve.city alone.
- *
- * @param chainId - the numeric chain id to proxy
- * @returns the fully qualified JSON-RPC endpoint
- */
 const valveCity = (chainId) => `https://one.valve.city/rpc/vk_demo/evm/${chainId}`;
-/**
- * all of the chains that are enabled in this dapp
- * and their corresponding useful metadata
- *
- * Every entry below sets `name` explicitly to `chainDisplayName(...)` rather
- * than trusting the spread-in viem chain object or typing a string here. Two
- * hand-typed copies of the same name is exactly how chain 943 once read as
- * "PulseChain Testnet V4" in the resolver and "Pulsechain V4" here — one
- * string, two spellings, and only one of them got fixed. Routing every name
- * through `chainDisplayName` leaves nothing to drift a second time.
- *
- * Each `logoURI` is a getter, not a string fixed at import time, so a later
- * `setImageRoot` call (from `image-links.ts`) changes every chain logo. Spread
- * an entry (`{ ...chainsMetadata[chain] }`) and the copy holds the URL as it
- * was at that moment.
- */
 export const chainsMetadata = {
     [Chains.PLS]: {
         ...pulsechain,
@@ -129,12 +38,6 @@ export const chainsMetadata = {
         alt: 'two pyramids joined on one side',
         rpcUrls: {
             default: {
-                // TWO PUBLIC ENDPOINTS, and {@link demoRpcUrls} puts valve.city in
-                // front of them. Both are needed behind it. On 2026-08-25 g4mm4
-                // answered nothing at all for hours, and the list was g4mm4 then
-                // valve.city — so every read fell through a dead host onto a key that
-                // rejects four requests in five. publicnode measured 40 of 40 on
-                // 2026-08-27 and costs nothing to carry.
                 http: [
                     'https://rpc-ethereum.g4mm4.io',
                     'https://ethereum-rpc.publicnode.com',
@@ -144,9 +47,6 @@ export const chainsMetadata = {
     },
     [Chains.BNB]: {
         ...bsc,
-        // viem's own default is "BNB Smart Chain" — deferring to the resolver
-        // keeps this the product's chosen "Binance Smart Chain" without a second
-        // hand-typed copy of that decision living here.
         name: chainDisplayName(bsc.id),
         chainId: Chains.BNB,
         get logoURI() {
@@ -155,11 +55,6 @@ export const chainsMetadata = {
         alt: 'a gold cube with slits in the middle of each side',
         rpcUrls: {
             default: {
-                // valve.city does not proxy chain 56 — it answers "Unsupported
-                // chain" — so this is the one chain with no entry of ours, which
-                // makes a second PUBLIC endpoint the only fallback available. A
-                // one-entry list is what took Sepolia down outright (see below).
-                // Both measured 40 of 40 on 2026-08-27.
                 http: ['https://bsc-rpc.publicnode.com', 'https://bsc-dataseed.binance.org'],
             },
         },
@@ -172,31 +67,8 @@ export const chainsMetadata = {
             return imageLinks.network(sepolia.id);
         },
         alt: 'two pyramids joined on one side',
-        // FOUR endpoints, not one, and the reason is specific: a public endpoint
-        // answers a single curl perfectly well and returns 403 under a browser's
-        // load — five times on one page render. A rate limit, not a dead host.
-        //
-        // The transport wraps this list in viem's `fallback()`, which moves on for
-        // an HTTP error, and 403 is one. With a single entry there was nowhere to
-        // move to, so the whole testnet side simply failed. All three were checked
-        // for a correct chain id AND for an allow-origin header, because answering
-        // curl is not the same as being reachable from a page.
         rpcUrls: {
             default: {
-                // Ordered deliberately, by the operational rule that the most reliable
-                // endpoint goes FIRST.
-                //
-                // valve.city is not here. It sits in front of these three only in
-                // {@link demoRpcUrls}. Being ours does not buy it a budget: the SHARED
-                // DEMO KEY answered 429 for 32 of 40 burst requests against Sepolia on
-                // 2026-08-27, which is why nothing may depend on it alone.
-                //
-                // These three keep the order an earlier browser measurement earned
-                // them. publicnode stays last of the public three because it is the one
-                // observed returning 403 under a browser's load — five times on one
-                // page render — which a `curl` burst does not reproduce and therefore
-                // cannot overturn. It answers fine when the others are busy, so it is
-                // demoted rather than dropped.
                 http: [
                     'https://sepolia.gateway.tenderly.co',
                     'https://1rpc.io/sepolia',
@@ -215,10 +87,6 @@ export const chainsMetadata = {
         alt: 'a pink blue and purple hexagon with an ekg line running horizontally',
         rpcUrls: {
             default: {
-                // Two, for the reason Ethereum has two: g4mm4 is a single host that
-                // has gone away before, and valve.city ({@link demoRpcUrls}) alone in
-                // front of it is not a fallback. The official testnet node measured 40
-                // of 40 on 2026-08-27.
                 http: [
                     'https://rpc-testnet-pulsechain.g4mm4.io',
                     'https://rpc.v4.testnet.pulsechain.com',
@@ -236,22 +104,6 @@ export const chainsMetadata = {
         },
     },
 };
-/**
- * The RPC endpoints the Gibs interface uses, FOR DEMOS ONLY.
- *
- * Each proxied chain's list starts with valve.city's shared `vk_demo` key and
- * falls through to that chain's public endpoints in {@link chainsMetadata}.
- * Binance Smart Chain has no valve.city entry, so its list is the public one.
- *
- * WHY IT IS A SEPARATE, NAMED LIST. The key is public, so shipping it discloses
- * nothing. But its rate budget is shared by everybody who uses it, and the proxy
- * belongs to the Gibs Finance operator. A wallet that inherits it without
- * choosing it puts its users' reads on somebody else's budget and uptime. So no
- * reader in this package uses it, and `chainsMetadata` does not carry it. A
- * caller who wants it asks for it by this name.
- *
- * Production callers: pass your own viem clients to every reader.
- */
 export const demoRpcUrls = Object.freeze({
     [Chains.PLS]: [valveCity(pulsechain.id), ...chainsMetadata[Chains.PLS].rpcUrls.default.http],
     [Chains.ETH]: [valveCity(mainnet.id), ...chainsMetadata[Chains.ETH].rpcUrls.default.http],
@@ -259,61 +111,11 @@ export const demoRpcUrls = Object.freeze({
     [Chains.SEP]: [valveCity(sepolia.id), ...chainsMetadata[Chains.SEP].rpcUrls.default.http],
     [Chains.V4PLS]: [valveCity(pulsechainV4.id), ...chainsMetadata[Chains.V4PLS].rpcUrls.default.http],
 });
-/**
- * The demo endpoints for one chain, FOR DEMOS ONLY. See {@link demoRpcUrls}.
- *
- * @param chainId - a decimal chain id
- * @returns a copy of the chain's demo endpoints, or an empty list for a chain the bridge does not cross
- */
 export const demoRpcUrlsFor = (chainId) => [
     ...(demoRpcUrls[toChain(chainId)] ?? []),
 ];
-/**
- * Every chain this bridge itself carries funds across, in the order the
- * metadata declares them.
- *
- * Read from {@link chainsMetadata} rather than typed out, for the reason the
- * whole table above gives: a second hand-written list is how one chain ends up
- * present in one place and missing from another. A control that offers the
- * reader a network to add or remove reads this, so a chain added to the
- * metadata appears in that control without anybody remembering to add it.
- *
- * This is NOT every chain a route can traverse. An aggregator reaches dozens
- * more, and `chain-names.ts` can name them. These five are the ones the
- * transfers archive holds records for.
- */
 export const bridgeNetworkChainIds = Object.values(chainsMetadata).map((metadata) => Number(metadata.id));
-/**
- * The chain identifiers this product treats as TEST networks.
- *
- * THE FLAG IS VIEM'S AND IT IS CHECKED FOR `true`, NOT FOR TRUTHINESS. Each
- * entry above spreads a viem chain definition, and viem sets `testnet: true` on
- * Sepolia and on PulseChain Testnet V4, `testnet: false` on PulseChain, and
- * omits the key entirely on Ethereum and on Binance Smart Chain. So the value
- * has three states, and only one of them is a claim. Testing for `=== true`
- * means a chain whose definition says nothing is treated as a real network —
- * which is the safe direction, because the cost of failing to hide a test
- * network is an extra row and the cost of hiding a real one is a reader who
- * cannot find their money.
- *
- * WHY NOT DERIVE IT FROM THE BRIDGE KEYS. `validBridgeKeys(isProd)` in
- * `config.ts` splits the same five chains into a mainnet set and a testnet set,
- * and subtracting one from the other would give the same two identifiers today.
- * It would also give the wrong answer the moment a real chain gains a pathway
- * that is still behind the testnet switch — the key list records what is
- * ENABLED, and this records what a chain IS. Two different questions.
- *
- * `buildFullChainIdSet` in the interface already gates the pickers on the same
- * flag, and `tokenLists.ts` gates the synthesized native assets on it. This is
- * that decision written down once so a third reader does not restate it.
- */
 export const testNetworkChainIds = new Set(Object.values(chainsMetadata)
     .filter((metadata) => metadata.testnet === true)
     .map((metadata) => Number(metadata.id)));
-/**
- * Whether one chain is a test network.
- *
- * @param chainId - a decimal chain id
- * @returns true only when the chain's own definition claims it is a test network
- */
 export const isTestNetwork = (chainId) => testNetworkChainIds.has(chainId);

package/dist/cjs/abis.js

@@ -14,6 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// All ABIs have moved to the standalone @gibs/abis package.
-// This module re-exports everything for backwards compatibility.
 __exportStar(require("@gibs/abis"), exports);

package/dist/cjs/bridge-limits.js

@@ -2,27 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkEntryAmount = exports.bridgeEntryLimits = exports.entryLimitsAbi = void 0;
 const viem_1 = require("viem");
-/**
- * Exported so a batched reader (`routing/carriers/omnibridge.ts`'s `prepare`)
- * can multicall the same two functions across many tokens in one call rather
- * than duplicating this ABI.
- */
 exports.entryLimitsAbi = (0, viem_1.parseAbi)([
     'function minPerTx(address token) external view returns(uint256)',
     'function maxAvailablePerTx(address token) external view returns(uint256)',
 ]);
-/**
- * Reads the bounds the entry mediator will enforce on this exact call.
- *
- * IT TAKES THE CALL, NOT A MEDIATOR AND A TOKEN. The two travel together on the
- * destination call precisely so a caller cannot pair one route's mediator with
- * another route's token and get a plausible number back — the reads would
- * succeed and the answer would be about a transfer nobody is making.
- *
- * @param destinationCall - the entry call, or null when none could be built
- * @param entryChainClient - a client on the chain the funds leave
- * @returns the two bounds, or null when there is no call to measure
- */
 const bridgeEntryLimits = async ({ destinationCall, entryChainClient, }) => {
     if (!destinationCall) {
         return null;
@@ -45,28 +28,7 @@ const bridgeEntryLimits = async ({ destinationCall, entryChainClient, }) => {
     return { minimumPerTransaction, availablePerTransaction };
 };
 exports.bridgeEntryLimits = bridgeEntryLimits;
-/**
- * Decides whether an amount can enter the bridge.
- *
- * WHY THIS IS WORTH CHECKING BEFORE A ROUTE IS OFFERED: on a consolidated
- * route the entry call is made by an aggregator's executor, not by the user.
- * When the mediator rejects the amount the executor's call reverts, the
- * aggregator has already delivered the funds, and they stop at the fallback
- * address on the entry chain. The user is left holding an entry-chain token
- * and a second transfer to make. Refusing the quote costs them nothing.
- *
- * The bounds are inclusive: the mediator accepts an amount equal to either.
- *
- * @param amount - the transfer, in the token's base units
- * @param limits - the bounds from {@link bridgeEntryLimits}, or null when they
- *   could not be read
- * @returns a verdict naming the bound that was missed
- */
 const checkEntryAmount = ({ amount, limits, }) => {
-    // An unread limit is not a failed one. A network hiccup must not block a
-    // route that the mediator would accept — the transaction still gets the
-    // mediator's own answer, and this guard exists to save the user a wasted
-    // crossing, not to be the only thing standing between them and a revert.
     if (!limits) {
         return { fits: true };
     }

package/dist/cjs/chain-info.js

@@ -40,34 +40,8 @@ const viem_1 = require("viem");
 const abis = __importStar(require("./abis.js"));
 const chains_js_1 = require("./chains.js");
 const config_js_1 = require("./config.js");
-/** Cache key for the links memoize: one entry per (chain, bridge, token) triple. */
 const linksCacheKey = ({ chainId, target, address, }) => `${chainId}-${target}-${address}`.toLowerCase();
-/**
- * Whether a {@link links} answer says the token has no mapping on this bridge
- * yet. That answer is temporary: the first transfer of the token creates the
- * mapping, so it must not be cached.
- * @param pair - the bridged and native addresses the mediator returned
- * @returns true when both are the zero address
- */
 const isUnmappedAnswer = ([bridged, native]) => bridged === viem_1.zeroAddress && native === viem_1.zeroAddress;
-/**
- * Returns the bridged token address and native token address that a mediator
- * holds for one token.
- *
- * A non-zero answer is cached for the life of the process: a mediator never
- * changes a mapping once the first transfer creates it. A failed read, and a
- * `[zero, zero]` answer (the token is not bridged yet), are not cached, so the
- * next call reads the chain again. Call {@link clearChainInfoCaches} to drop
- * every cached answer.
- *
- * @param inputs.chainId - the chain id being targeted
- * @param inputs.target - the mediator to ask
- * @param inputs.address - the token address
- * @param inputs.client - a client for that chain
- * @returns the bridged token address and native token address
- */
-// The body reaches for `links.cache` to evict an answer, so the cache surface
-// is spelled out to the extent this file uses it.
 exports.links = (0, cache_1.memoizeByKey)(async (inputs) => {
     const { chainId, target, address, client } = inputs;
     const evict = () => exports.links.cache.delete(linksCacheKey(inputs));
@@ -81,35 +55,18 @@ exports.links = (0, cache_1.memoizeByKey)(async (inputs) => {
             { functionName: 'nativeTokenAddress', args: [address] },
         ],
     }).catch((error) => {
-        // a transient read failure must not poison the cache for the session
         evict();
         throw error;
     });
     if (isUnmappedAnswer(pair)) {
-        // the token may be bridged a minute from now; ask again next time
         evict();
     }
     return pair;
 }, linksCacheKey);
-/**
- * Drops every answer this module has cached, so the next read goes to the chain.
- *
- * Use it after a token's first transfer, in a long-running process that wants
- * a fresh view, or between tests.
- */
 const clearChainInfoCaches = () => {
     exports.links.cache.clear();
 };
 exports.clearChainInfoCaches = clearChainInfoCaches;
-/**
- * Returns the token bridge info for the given bridge key, asset in, is prod, from chain client, and to chain client
- * @param bridgeKey - the bridge key
- * @param assetIn - the asset in
- * @param isProd - whether to use the production pathway
- * @param fromChainClient - the from chain client
- * @param toChainClient - the to chain client
- * @returns the token bridge info
- */
 const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainClient, toChainClient, }) => {
     const bridgePathway = (0, config_js_1.pathway)(bridgeKey, isProd, assetIn?.address);
     if (!assetIn || !bridgePathway) {
@@ -177,7 +134,6 @@ const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainClient, to
             },
         };
     }
-    // the token has not been bridged yet
     return {
         originationChainId: toChain,
         assetInAddress: assetInAddress,
@@ -198,23 +154,11 @@ const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainClient, to
     };
 };
 exports.tokenBridgeInfo = tokenBridgeInfo;
-/**
- * Check the prices that each router offers for the given paths
- * @param assetInAddress the address of the asset going into the bridge
- * @param oneTokenInt the number of tokens to push into the bridge (before fees)
- * @param chain the chain of the asset going into the bridge
- * @param bridgeKey the bridge key
- * @param blockNumber the block number to use for the price
- * @param paths the paths to check
- * @returns the prices as bigint for each path, hex whenever the price is not available
- */
 const readAmountOut = ({ amountIn, chain, paths, client, uniV2Router, }) => {
     return (0, multicall_1.multicallRead)({
         chain: chains_js_1.chainsMetadata[chain],
         client,
         abi: abis.univ2Router,
-        // pulsex router
-        // a chain with no router reads nothing, as lodash's flatMap over undefined did
         calls: (uniV2Router ? [uniV2Router] : (config_js_1.uniV2Routers[chain] ?? [])).flatMap((target) => paths.map((path) => ({
             functionName: 'getAmountsOut',
             allowFailure: true,
@@ -223,22 +167,9 @@ const readAmountOut = ({ amountIn, chain, paths, client, uniV2Router, }) => {
         }))),
     });
 };
-/**
- * Fetch the price corrective for the given bridge key, asset out, measurement token, from chain client, to chain client, asset link, amount in, and is prod
- * @param bridgeKeyPartner - the bridge key partner
- * @param assetOut - the asset out
- * @param measurementToken - the measurement token
- * @param fromChainClient - the from chain client
- * @param toChainClient - the to chain client
- * @param assetLink - the asset link
- * @param amountIn - the amount in
- * @param isProd - whether to use the production pathway
- * @returns the price corrective
- */
 const fetchPriceCorrective = ({ bridgeKeyPartner, assetOut, measurementToken, fromChainClient, toChainClient, assetLink, amountIn, isProd, }) => {
     return {
         getPaymentToken: async () => {
-            // fetch the token bridge info for the token that is about to be spent by the delivery service
             return await (0, exports.tokenBridgeInfo)({
                 bridgeKey: bridgeKeyPartner,
                 assetIn: {
@@ -246,8 +177,6 @@ const fetchPriceCorrective = ({ bridgeKeyPartner, assetOut, measurementToken, fr
                     address: measurementToken,
                 },
                 isProd,
-                // clients are reversed here because we are actually fetching the
-                // tokens going the opposite direction to the provided bridge key
                 fromChainClient: toChainClient,
                 toChainClient: fromChainClient,
             });
@@ -260,9 +189,7 @@ const fetchPriceCorrective = ({ bridgeKeyPartner, assetOut, measurementToken, fr
                     uniV2Router,
                     client,
                     paths: [
-                        // check the direct route
                         [assetLink.assetInAddress, paymentTokenResult.assetOutAddress],
-                        // might have heavier liquidity going through the native asset on the home side
                         [assetLink.assetInAddress, config_js_1.nativeAssetOut[chain], paymentTokenResult.assetOutAddress],
                     ],
                 }),
@@ -272,22 +199,17 @@ const fetchPriceCorrective = ({ bridgeKeyPartner, assetOut, measurementToken, fr
                     uniV2Router,
                     client,
                     paths: [[assetOut.address, measurementToken]],
-                    // only the direct route is available.
-                    // might be able to create a whitelist for this at some point
                 }),
             ]);
         },
         reduceResults: ({ results, oneToken, }) => {
             const outputFromRouter = (result) => {
                 if (typeof result === 'string') {
-                    // the router failed to return a result
                     return 0n;
                 }
                 if (!result.length) {
-                    // the router returned an empty result
                     return 0n;
                 }
-                // the last element is the amount of the output token
                 const last = result[result.length - 1];
                 return (last * oneToken) / amountIn;
             };
@@ -296,7 +218,6 @@ const fetchPriceCorrective = ({ bridgeKeyPartner, assetOut, measurementToken, fr
                     .filter((amount) => amount !== undefined)
                     .reduce((max, current) => (max < current ? current : max), 0n);
             };
-            // could do with a refactor to unify the results
             const [outputs, inputs] = results;
             const outputAmounts = outputs.map(outputFromRouter);
             const inputAmounts = inputs.map(outputFromRouter);
@@ -312,29 +233,6 @@ const fetchPriceCorrective = ({ bridgeKeyPartner, assetOut, measurementToken, fr
     };
 };
 exports.fetchPriceCorrective = fetchPriceCorrective;
-/**
- * Read the smallest amount the bridge will accept for this asset on this pathway.
- *
- * THE ENTRY MEDIATOR DECIDES, so this always reads `pathway.from` on the chain
- * the funds leave. `feeManager` says which side prices the transfer; it has
- * never said which side validates the amount, and using it for both is what
- * produced the defect this replaces.
- *
- * Both mediators keep a `minPerTx` under the same name, and for a token that
- * originates on the entry chain the two sides usually hold the same number. That
- * agreement is a coincidence of configuration - each side is separately
- * governed, and both happen to apply one blanket default. It breaks outright for
- * a token that originates on the far side, because the two mediators key their
- * limits by different addresses. Wrapped Pulse entering from Ethereum is the
- * live case: the entry mediator enforces 50,000, and the destination mediator
- * answers 0 for that same address because it files that token under its
- * PulseChain address instead. Reading the destination got both the chain and the
- * token key wrong, and reported no floor where a real one stood.
- * @param assetIn - the asset the sender holds, on the chain it leaves from
- * @param pathway - the pathway, with any per-asset overrides already applied
- * @param fromPublicClient - a client for the chain the funds leave
- * @returns the smallest amount the entry mediator will accept
- */
 const minBridgeAmountIn = async ({ assetIn, pathway, fromPublicClient, }) => fromPublicClient.readContract({
     abi: abis.inputBridge,
     functionName: 'minPerTx',
@@ -342,7 +240,6 @@ const minBridgeAmountIn = async ({ assetIn, pathway, fromPublicClient, }) => fro
     address: pathway.from,
 });
 exports.minBridgeAmountIn = minBridgeAmountIn;
-/** get the symbol of the native asset, unwrap it if it needs to be */
 const nativeSymbol = (asset, unwrap = false) => {
     return asset
         ? unwrap && asset.address === config_js_1.nativeAssetOut[(0, config_js_1.toChain)(asset.chainId)]
@@ -351,12 +248,6 @@ const nativeSymbol = (asset, unwrap = false) => {
         : '';
 };
 exports.nativeSymbol = nativeSymbol;
-/**
- * Returns the Multicall3 contract for the client's chain.
- * @param client - a client whose `chain` is one of {@link chainsMetadata}'s chains
- * @returns the Multicall3 contract instance
- * @throws when the client carries no chain, or the chain has no Multicall3 address
- */
 const chainMulticall = (client) => {
     const chainId = client.chain?.id;
     if (chainId === undefined) {
@@ -369,13 +260,6 @@ const chainMulticall = (client) => {
     return (0, viem_1.getContract)({ abi: viem_1.multicall3Abi, client, address });
 };
 exports.chainMulticall = chainMulticall;
-/**
- * Load the bridge fees for the given pathway, from chain client, and to chain client
- * @param pathway - the pathway
- * @param fromChainClient - the from chain client
- * @param toChainClient - the to chain client
- * @returns the bridge fees
- */
 const loadBridgeFees = async ({ pathway, fromChainClient, toChainClient, }) => {
     const multicall = pathway.feeManager === 'from' ? (0, exports.chainMulticall)(fromChainClient) : (0, exports.chainMulticall)(toChainClient);
     const [feeManagerResponse] = await multicall.read.aggregate3([