@gibs/bridge-sdk 1.10.1 → 1.13.0

package/dist/{src/config.js → config.js}

@@ -1,5 +1,5 @@
-import { getAddress, keccak256, stringToHex, zeroAddress } from "viem";
-import _ from 'lodash';
+import * as _ from 'lodash-es';
+import { getAddress, isAddress, isAddressEqual, keccak256, stringToHex, zeroAddress, } from 'viem';
 /**
  * Add here your chain id as hex, be sure to add your chain in the chainsMetadata object too
  */
@@ -62,6 +62,40 @@ export const uniV2Routers = {
         '0x636f6407B90661b73b1C0F7e24F4C79f624d0738',
     ],
 };
+/**
+ * Each {@link uniV2Routers} entry's OWN factory address, same index, same
+ * chain — `router.factory()` read live from `one.valve.city` on 2026-09-24.
+ * Only PulseChain mainnet is filled: PulseX carries funds nowhere else
+ * (`routing/carriers/pulsex.ts`'s own `pulseXCarries`), so no other chain's
+ * factory has ever been needed or verified.
+ *
+ * MEASURED, NOT ASSUMED (owner Rule 13). Reading each factory's `getPair`
+ * and the resulting pool's `getReserves`, then recomputing `getAmountsOut`
+ * from the standard constant-product formula, showed the SAME fee ratio for
+ * both — `9971/10000` (0.29%) — to the base unit, on both a one-hop and a
+ * two-hop path. "V1 and V2 differ" was the assumption going in; measurement
+ * said otherwise, so `routing/carriers/pulsex.ts`'s `exact` uses one shared
+ * fee constant rather than two.
+ *
+ * `0x1715a3E4A142d8b698131108995174F37aEBA10D` (the V1 factory, index 0) is
+ * NOT a copy-paste of the omnibridge's Ethereum mediator address from
+ * `pathways` above — it is the same string on a DIFFERENT chain (PulseChain,
+ * not Ethereum), confirmed by reading it fresh from `one.valve.city/…/evm/369`.
+ * Two unrelated contracts landing on the same address on two different
+ * chains is possible (a shared deployer at a matching nonce, or a CREATE2
+ * salt collision) and worth this note so a future reader does not assume a
+ * transcription error and "fix" it back to something wrong.
+ */
+export const uniV2Factories = {
+    [Chains.PLS]: [
+        '0x1715a3E4A142d8b698131108995174F37aEBA10D',
+        '0x29eA7545DEf87022BAdc76323F373EA1e707C523',
+    ],
+    [Chains.ETH]: [],
+    [Chains.BNB]: [],
+    [Chains.SEP]: [],
+    [Chains.V4PLS]: [],
+};
 /** A map of chains to native token symbols */
 export const nativeTokenSymbol = {
     [Chains.PLS]: 'PLS',
@@ -235,26 +269,48 @@ export const validBridgeKeys = (isProd) => [
     ...mainnetBridgeKeys,
     ...(isProd ? [] : testnetBridgeKeys),
 ];
+/** Every chain that appears only on a testnet pathway. */
+const testnetChains = new Set(testnetBridgeKeys.flatMap(([, fromChain, toChain]) => [fromChain, toChain]));
+/**
+ * Whether a chain belongs to the testnet pathway map rather than the mainnet one.
+ * @param chain - the chain to classify
+ * @returns true for Sepolia and PulseChain testnet V4
+ */
+export const isTestnetChain = (chain) => testnetChains.has(chain);
 /**
- * Infers the bridge key from the current key, provider, from chain, and to chain
- * @param currentKey - the current bridge key
- * @param provider - the provider
- * @param fromChain - the from chain
- * @param toChain - the to chain
- * @returns the inferred bridge key
+ * Infers the bridge key from the current key, provider, from chain, and to chain.
+ *
+ * A chain the provider does not serve falls back to the provider's first chain,
+ * so a provider switch lands on a real pathway. That fallback never crosses
+ * between the testnet and mainnet maps: when testnets are off and a requested
+ * chain is a testnet chain, this returns null rather than a mainnet key for a
+ * testnet pair.
+ *
+ * @param options.currentKey - the current bridge key
+ * @param options.provider - the provider
+ * @param options.fromChain - the from chain (defaults to the current key's)
+ * @param options.toChain - the to chain (defaults to the current key's)
+ * @param options.isProd - true leaves testnet pathways out (default false: both maps)
+ * @returns the inferred bridge key, or null when no pathway can honour the request
  */
-export const inferBridgeKey = ({ currentKey, provider, fromChain, toChain, }) => {
+export const inferBridgeKey = ({ currentKey, provider, fromChain, toChain, isProd = false, }) => {
     const [, fromChainKey, toChainKey] = currentKey;
     const from = fromChain ?? fromChainKey;
     const to = toChain ?? toChainKey;
-    const currentFromChainIsValid = !!_.get(pathways, [provider, from]);
-    const nextFromChain = currentFromChainIsValid
-        ? from
-        : Object.keys(pathways[provider])[0];
-    const currentToChainIsValid = !!_.get(pathways, [provider, nextFromChain, to]);
-    const nextToChain = currentToChainIsValid
-        ? to
-        : Object.keys(pathways[provider][nextFromChain])[0];
+    if (isProd && (isTestnetChain(from) || isTestnetChain(to))) {
+        return null;
+    }
+    const network = isTestnetChain(from) ? testnetPathways : pathways;
+    const providerGroups = network[provider] ?? {};
+    const nextFromChain = providerGroups[from] ? from : Object.keys(providerGroups)[0];
+    if (!nextFromChain) {
+        return null;
+    }
+    const destinations = providerGroups[nextFromChain] ?? {};
+    const nextToChain = destinations[to] ? to : Object.keys(destinations)[0];
+    if (!nextToChain) {
+        return null;
+    }
     return [provider, nextFromChain, nextToChain];
 };
 /**
@@ -264,6 +320,23 @@ export const inferBridgeKey = ({ currentKey, provider, fromChain, toChain, }) =>
  * @param assetInAddress - the asset in address
  * @returns the pathway
  */
+/**
+ * The pathway group for one provider on one chain, honouring the testnet map.
+ *
+ * Exists because {@link pathway} already knew that testnet pathways live in a
+ * SECOND map and are only in play off production, while other callers reached
+ * straight into `pathways` and therefore could not see a testnet route at all.
+ * That is the sort of knowledge that has to live in one place: duplicated, one
+ * copy silently lags the other, and the symptom is a thrown "no pathway found"
+ * on a route the rest of the application considers perfectly valid.
+ *
+ * @param provider - the bridge provider
+ * @param chain - the chain being bridged FROM
+ * @param isProd - whether this is a production build; testnets are off when true
+ * @returns the group keyed by destination chain, or undefined when unknown
+ */
+export const pathwayGroup = (provider, chain, isProd) => _.get(pathways, [provider, chain]) ||
+    (!isProd ? _.get(testnetPathways, [provider, chain]) : undefined);
 export const pathway = (bridgeKey, isProd, assetInAddress) => {
     if (!bridgeKey)
         return;
@@ -293,45 +366,63 @@ export const defaultAssetIn = ($bridgeKey, isProd) => {
     return defaultAssetIn;
 };
 /**
- * Returns whether the given asset is the native asset for the given bridge key
+ * Returns whether the given asset is the native asset for the given bridge key.
+ *
+ * Never throws. A token whose address is not known yet (a {@link TokenOut} for a
+ * not-yet-bridged token), an address that is not a valid address, and a bridge
+ * key with no pathway each answer false.
+ *
  * @param asset - the asset
  * @param bridgeKey - the bridge key
+ * @param options - which pathway maps to read; see {@link PathwayLookupOptions}
  * @returns whether the given asset is the native asset for the given bridge key
  */
-export const isNative = (asset, bridgeKey) => {
-    if (!bridgeKey || !asset) {
+export const isNative = (asset, bridgeKey, options = {}) => {
+    if (!bridgeKey || !asset?.address || !isAddress(asset.address, { strict: false })) {
+        return false;
+    }
+    const path = pathway(bridgeKey, options.isProd ?? false);
+    if (!path) {
         return false;
     }
-    const path = pathway(bridgeKey, false);
-    return (getAddress(asset.address) === getAddress(path.bridgedNativeAssetOut) ||
-        (asset.address === zeroAddress ||
-            nativeAssetOut[toChain(asset.chainId)]?.toLowerCase() === asset.address?.toLowerCase()) &&
-            !asset.name.includes(' from Pulsechain'));
+    if (isAddressEqual(asset.address, path.bridgedNativeAssetOut)) {
+        return true;
+    }
+    const wrappedNative = nativeAssetOut[toChain(asset.chainId)];
+    const isGasTokenOrItsWrapper = isAddressEqual(asset.address, zeroAddress) ||
+        (!!wrappedNative && isAddressEqual(asset.address, wrappedNative));
+    return isGasTokenOrItsWrapper && !asset.name.includes(' from Pulsechain');
 };
 /**
- * Returns whether the given asset is unwrappable for the given bridge key
+ * Returns whether the given asset is unwrappable for the given bridge key.
+ *
+ * Never throws: a missing or malformed address and a bridge key with no
+ * pathway each answer false.
+ *
  * @param bridgeKey - the bridge key
  * @param assetIn - the asset in
+ * @param options - which pathway maps to read; see {@link PathwayLookupOptions}
  * @returns whether the given asset is unwrappable for the given bridge key
  */
-export const isUnwrappable = (bridgeKey, assetIn) => {
-    if (!bridgeKey || !assetIn) {
+export const isUnwrappable = (bridgeKey, assetIn, options = {}) => {
+    if (!bridgeKey || !assetIn?.address || !isAddress(assetIn.address, { strict: false })) {
         return false;
     }
-    const addr = getAddress(assetIn.address);
-    const path = pathway(bridgeKey, false);
-    if (!path)
+    const path = pathway(bridgeKey, options.isProd ?? false);
+    if (!path) {
         return false;
-    return path.bridgedNativeAssetOut === getAddress(addr);
+    }
+    return isAddressEqual(path.bridgedNativeAssetOut, assetIn.address);
 };
 /**
  * Returns whether the given asset can be unwrapped for the given bridge key
  * @param bridgeKey - the bridge key
  * @param assetIn - the asset in
+ * @param options - which pathway maps to read; see {@link PathwayLookupOptions}
  * @returns boolean
  */
-export const canChangeUnwrap = (bridgeKey, assetIn) => {
-    return !!assetIn && isUnwrappable(bridgeKey, assetIn);
+export const canChangeUnwrap = (bridgeKey, assetIn, options = {}) => {
+    return !!assetIn && isUnwrappable(bridgeKey, assetIn, options);
 };
 export const chains = {
     ethereum: 1,
@@ -341,46 +432,62 @@ export const chains = {
     sepolia: 11155111,
 };
 export const chainIds = Object.values(chains);
+/** Start blocks aligned with when bridge validators began operating — canonical reference for all ponder indexers in this monorepo. */
+export const startBlocks = {
+    ethereum: 17_264_119,
+    bsc: 28_987_313,
+    pulsechain: 17_268_300,
+    pulsechainV4: 16_564_233,
+    sepolia: 3_331_901,
+};
 // provider -> home -> foreign
 export const bridgeConfigs = {
     [Providers.PULSECHAIN]: {
         [chains.pulsechain]: {
-            [chains.ethereum]: [{
+            [chains.ethereum]: [
+                {
                     pair: 'mainnet',
                     key: 'erc20',
                     home: '0x4fD0aaa7506f3d9cB8274bdB946Ec42A1b8751Ef',
                     foreign: '0x1715a3e4a142d8b698131108995174f37aeba10d',
-                }, {
+                },
+                {
                     pair: 'mainnet',
                     key: 'native',
                     home: '0x0e18d0d556b652794EF12Bf68B2dC857EF5f3996',
                     foreign: '0xe20E337DB2a00b1C37139c873B92a0AAd3F468bF',
-                }],
+                },
+            ],
         },
         [chains.pulsechainV4]: {
-            [chains.sepolia]: [{
+            [chains.sepolia]: [
+                {
                     pair: 'v4',
                     key: 'erc20',
                     home: '0x6B08a50865aDeCe6e3869D9AfbB316d0a0436B6c',
                     foreign: '0x546e37DAA15cdb82fd1a717E5dEEa4AF08D4349A',
-                }, {
+                },
+                {
                     pair: 'v4',
                     key: 'native',
                     home: '0x81c10846F40fA2B173FC47958D0a892529983F50',
                     foreign: '0x5e238ef968467cf443ef5ecb683b76c5a04a0421',
-                }],
+                },
+            ],
         },
     },
     [Providers.TOKENSEX]: {
         [chains.pulsechain]: {
-            [chains.bsc]: [{
+            [chains.bsc]: [
+                {
                     pair: 'bsctokensex',
                     key: 'erc20',
                     home: '0xf1DFc63e10fF01b8c3d307529b47AefaD2154C0e',
                     foreign: '0xb4005881e81a6ecd2c1f75d58e8e41f28d59c6b1',
-                }],
+                },
+            ],
         },
     },
 };
-export const HOME_TO_FOREIGN_FEE = keccak256(stringToHex("homeToForeignFee"));
-export const FOREIGN_TO_HOME_FEE = keccak256(stringToHex("foreignToHomeFee"));
+export const HOME_TO_FOREIGN_FEE = keccak256(stringToHex('homeToForeignFee'));
+export const FOREIGN_TO_HOME_FEE = keccak256(stringToHex('foreignToHomeFee'));