@gibs/bridge-sdk 1.12.0 → 1.13.0

package/dist/config.d.ts

@@ -0,0 +1,216 @@
+import { type Hex } from 'viem';
+import type { BridgeKey, Token, TokenOut } from './types.js';
+/**
+ * Add here your chain id as hex, be sure to add your chain in the chainsMetadata object too
+ */
+export declare enum Chains {
+    PLS = "0x171",
+    ETH = "0x1",
+    BNB = "0x38",
+    SEP = "0xaa36a7",
+    V4PLS = "0x3af"
+}
+/** The key of a chain - human readable for query params */
+export type ChainKey = keyof typeof Chains;
+/** A map of chain ids to chain keys */
+export declare const chainIdToKey: Map<Chains, "PLS" | "ETH" | "BNB" | "SEP" | "V4PLS">;
+/**
+ * Converts a chain id to a chain key
+ * @param chainId - the chain id
+ * @returns the chain key
+ */
+export declare const toChain: (chainId: number | string) => Chains;
+/**
+ * Converts a chain id to a chain key
+ * @param chainId - the chain id
+ * @returns the chain key
+ */
+export declare const toChainKey: (chainId: number | string) => "PLS" | "ETH" | "BNB" | "SEP" | "V4PLS" | undefined;
+export declare const Providers: {
+    readonly PULSECHAIN: "pulsechain";
+    readonly TOKENSEX: "tokensex";
+};
+export type Provider = (typeof Providers)[keyof typeof Providers];
+/** A map of chains to native asset out addresses */
+export declare const nativeAssetOut: Record<Chains, Hex>;
+/** A map of chains to deprecated native asset out addresses */
+export declare const deprecatedNativeAssetOut: Partial<Record<Chains, Set<Hex>>>;
+/** A map of chains to uni v2 router addresses */
+export declare const uniV2Routers: Record<Chains, Hex[]>;
+/**
+ * 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 declare const uniV2Factories: Record<Chains, Hex[]>;
+/** A map of chains to native token symbols */
+export declare const nativeTokenSymbol: Record<Chains, string>;
+/** A map of chains to native token names */
+export declare const nativeTokenName: Record<Chains, string>;
+/** The pathway of a bridge */
+export type Pathway = {
+    from: Hex;
+    to: Hex;
+    destinationRouter: Hex | null;
+    nativeRouter: Hex;
+    validator: Hex;
+    usesExtraParam: boolean;
+    feeManager: 'from' | 'to';
+    toHome: boolean;
+    requiresDelivery: boolean;
+    bridgedNativeAssetOut: Hex;
+    settingOverrides?: Record<Hex, Partial<Pathway>>;
+};
+/** A map of providers to pathways */
+export type DeepPathwayConfig = Record<Provider, Partial<Record<Chains, Partial<Record<Chains, Pathway>>>>>;
+export declare const pathways: DeepPathwayConfig;
+export declare const testnetPathways: DeepPathwayConfig;
+/** Returns the valid bridge keys for the given is prod */
+export declare const validBridgeKeys: (isProd: boolean) => BridgeKey[];
+/**
+ * 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 declare const isTestnetChain: (chain: Chains) => boolean;
+/**
+ * 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 declare const inferBridgeKey: ({ currentKey, provider, fromChain, toChain, isProd, }: {
+    currentKey: BridgeKey;
+    provider: Provider;
+    fromChain?: Chains;
+    toChain?: Chains;
+    isProd?: boolean;
+}) => BridgeKey | null;
+/**
+ * Returns the pathway for the given bridge key, is prod, and asset in address
+ * @param bridgeKey - the bridge key
+ * @param isProd - whether to use the production pathway
+ * @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 declare const pathwayGroup: (provider: Provider, chain: Chains, isProd: boolean) => Partial<Record<Chains, Pathway>> | undefined;
+export declare const pathway: (bridgeKey: BridgeKey | null, isProd: boolean, assetInAddress?: string | Hex | null | undefined) => Pathway | undefined;
+/**
+ * Returns the default asset in for the given bridge key and is prod
+ * @param bridgeKey - the bridge key
+ * @param isProd - whether to use the production pathway
+ * @returns the default asset in
+ */
+export declare const defaultAssetIn: ($bridgeKey: BridgeKey | null, isProd: boolean) => `0x${string}` | null | undefined;
+/** Which pathway maps a lookup reads. */
+export type PathwayLookupOptions = {
+    /**
+     * true reads the mainnet map alone; false (the default) also reads the
+     * testnet map, which is what every caller did before this option existed.
+     */
+    isProd?: boolean;
+};
+/**
+ * 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 declare const isNative: (asset: Token | TokenOut | null, bridgeKey: BridgeKey | null, options?: PathwayLookupOptions) => boolean;
+/**
+ * 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 declare const isUnwrappable: (bridgeKey: BridgeKey | null, assetIn: {
+    address: string | null;
+} | null, options?: PathwayLookupOptions) => boolean;
+/**
+ * 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 declare const canChangeUnwrap: (bridgeKey: BridgeKey, assetIn: Token | null, options?: PathwayLookupOptions) => boolean;
+export declare const chains: {
+    readonly ethereum: 1;
+    readonly bsc: 56;
+    readonly pulsechain: 369;
+    readonly pulsechainV4: 943;
+    readonly sepolia: 11155111;
+};
+export declare const chainIds: (1 | 56 | 369 | 943 | 11155111)[];
+/** Start blocks aligned with when bridge validators began operating — canonical reference for all ponder indexers in this monorepo. */
+export declare const startBlocks: Record<keyof typeof chains, number>;
+export type ChainId = (typeof chainIds)[number];
+export type Side = 'home' | 'foreign';
+export type MinimalKey = `${ChainId}-${Hex}`;
+export type PathwayInfo = {
+    pair: string;
+    key: string;
+    home: Hex;
+    foreign: Hex;
+};
+export type ProviderHomeChainEntry = Partial<Record<ChainId, PathwayInfo[]>>;
+export type ProviderEntries = Partial<Record<ChainId, ProviderHomeChainEntry>>;
+export type BridgeConfig = Record<Provider, ProviderEntries>;
+export declare const bridgeConfigs: BridgeConfig;
+export declare const HOME_TO_FOREIGN_FEE: `0x${string}`;
+export declare const FOREIGN_TO_HOME_FEE: `0x${string}`;