@gibs/bridge-sdk 1.7.1 → 1.7.3

package/dist/src/chain-info.d.ts

@@ -15,12 +15,29 @@ export type TokenBridgeInfo = {
         foreign: Hex;
     };
 };
+/**
+ * Returns the bridged token address and native token address
+ * @param chainId - the chain id being targeted
+ * @param target - the target
+ * @param address - the address
+ * @param client - the client
+ * @returns the bridged token address and native token address
+ */
 export declare const links: (({ chainId, target, address, client }: {
     chainId: number;
     target: Hex;
     address: Hex;
     client: PublicClient;
 }) => Promise<`0x${string}`[]>) & _.MemoizedFunction;
+/**
+ * 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
+ */
 export declare const tokenBridgeInfo: ({ bridgeKey, assetIn, isProd, fromChainClient, toChainClient, }: {
     bridgeKey: BridgeKey;
     assetIn: Token | null;
@@ -28,7 +45,20 @@ export declare const tokenBridgeInfo: ({ bridgeKey, assetIn, isProd, fromChainCl
     fromChainClient: PublicClient;
     toChainClient: PublicClient;
 }) => Promise<null | TokenBridgeInfo>;
+/** The result of reading the amount out from a router */
 export type FetchResult = bigint[] | Hex;
+/**
+ * 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
+ */
 export declare const fetchPriceCorrective: ({ bridgeKeyPartner, assetOut, measurementToken, fromChainClient, toChainClient, assetLink, amountIn, isProd, }: {
     bridgeKey: BridgeKey;
     bridgeKeyPartner: BridgeKey;
@@ -52,6 +82,14 @@ export declare const fetchPriceCorrective: ({ bridgeKeyPartner, assetOut, measur
         oneToken: bigint;
     }) => bigint;
 };
+/**
+ * Fetch the minimum bridge amount in for the given asset in, pathway, from public client, and to public client
+ * @param assetIn - the asset in
+ * @param pathway - the pathway
+ * @param fromPublicClient - the from public client
+ * @param toPublicClient - the to public client
+ * @returns the minimum bridge amount in
+ */
 export declare const minBridgeAmountIn: ({ assetIn, pathway, fromPublicClient, toPublicClient, }: {
     assetIn: Token;
     pathway: Pathway;
@@ -64,15 +102,29 @@ export declare const nativeSymbol: (asset: {
     symbol: string;
     chainId: number;
 } | null, unwrap?: boolean) => string;
+/** The input for loading the bridge fees */
 export type InputLoadFeeFor = {
     pathway: Pathway;
     fromChainClient: PublicClient;
     toChainClient: PublicClient;
 };
+/** The fee configuration for a given pathway */
 export type PathwayExtendableConfig = {
     feeManager: Hex;
     feeH2F: bigint;
     feeF2H: bigint;
 };
+/**
+ * Returns the chain multicall for the given client
+ * @param client - the client
+ * @returns the chain multicall
+ */
 export declare const chainMulticall: (client: PublicClient) => any;
+/**
+ * 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
+ */
 export declare const loadBridgeFees: ({ pathway, fromChainClient, toChainClient }: InputLoadFeeFor) => Promise<PathwayExtendableConfig>;

package/dist/src/chain-info.js

@@ -4,6 +4,14 @@ import _ from "lodash";
 import { chainsMetadata } from "./chains.js";
 import * as abis from "./abis.js";
 import { multicallRead } from "@gibs/common/multicall";
+/**
+ * Returns the bridged token address and native token address
+ * @param chainId - the chain id being targeted
+ * @param target - the target
+ * @param address - the address
+ * @param client - the client
+ * @returns the bridged token address and native token address
+ */
 export const links = _.memoize(async ({ chainId, target, address, client }) => {
     return multicallRead({
         client,
@@ -16,6 +24,15 @@ export const links = _.memoize(async ({ chainId, target, address, client }) => {
         ],
     });
 }, ({ chainId, target, address }) => `${chainId}-${target}-${address}`.toLowerCase());
+/**
+ * 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
+ */
 export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainClient, toChainClient, }) => {
     const bridgePathway = pathway(bridgeKey, isProd, assetIn?.address);
     if (!assetIn || !bridgePathway) {
@@ -39,11 +56,7 @@ export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainCli
         }),
     ]);
     const [toBridged, toNative] = toMappings;
-    // const notGas = !Object.values(nativeAssetOut).find(
-    //   (v) => v.toLowerCase() === assetInAddress.toLowerCase(),
-    // )
     if (toBridged !== zeroAddress) {
-        // if (notGas) console.log('toBridged')
         return {
             originationChainId: fromChain,
             assetInAddress: assetInAddress,
@@ -55,8 +68,6 @@ export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainCli
         };
     }
     if (toNative !== zeroAddress) {
-        // if (notGas) console.log('toNative')
-        console.log('toNative', toNative);
         return {
             originationChainId: toChain,
             assetInAddress: assetInAddress,
@@ -69,8 +80,6 @@ export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainCli
     }
     const [fromBridged, fromNative] = fromMappings;
     if (fromNative !== zeroAddress) {
-        // if (notGas) console.log('fromNative')
-        console.log('fromNative', fromNative);
         return {
             originationChainId: toChain,
             assetInAddress: assetInAddress,
@@ -82,7 +91,6 @@ export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainCli
         };
     }
     if (fromBridged !== zeroAddress) {
-        // if (notGas) console.log('fromBridged')
         return {
             originationChainId: fromChain,
             assetInAddress: assetInAddress,
@@ -114,7 +122,7 @@ export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainCli
     };
 };
 /**
- * check the prices that each router offers for the given paths
+ * 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
@@ -137,11 +145,19 @@ const readAmountOut = ({ amountIn, chain, paths, client, uniV2Router, }) => {
         }))),
     });
 };
-export const fetchPriceCorrective = ({ 
-// bridgeKey,
-// assetIn,
-// isProd,
-bridgeKeyPartner, assetOut, measurementToken, fromChainClient, toChainClient, assetLink, amountIn, isProd, }) => {
+/**
+ * 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
+ */
+export 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
@@ -215,6 +231,14 @@ bridgeKeyPartner, assetOut, measurementToken, fromChainClient, toChainClient, as
         }
     };
 };
+/**
+ * Fetch the minimum bridge amount in for the given asset in, pathway, from public client, and to public client
+ * @param assetIn - the asset in
+ * @param pathway - the pathway
+ * @param fromPublicClient - the from public client
+ * @param toPublicClient - the to public client
+ * @returns the minimum bridge amount in
+ */
 export const minBridgeAmountIn = async ({ assetIn, pathway, fromPublicClient, toPublicClient, }) => {
     const publicClient = pathway?.feeManager === 'from' ? fromPublicClient : toPublicClient;
     return publicClient.readContract({
@@ -228,6 +252,11 @@ export const minBridgeAmountIn = async ({ assetIn, pathway, fromPublicClient, to
 export const nativeSymbol = (asset, unwrap = false) => {
     return asset ? (unwrap && asset.address === nativeAssetOut[toChain(asset.chainId)] ? asset.symbol.slice(1) : asset.symbol) : '';
 };
+/**
+ * Returns the chain multicall for the given client
+ * @param client - the client
+ * @returns the chain multicall
+ */
 export const chainMulticall = (client) => {
     const chainId = client.chain.id;
     const metadata = chainsMetadata[toChain(chainId)];
@@ -237,6 +266,13 @@ export const chainMulticall = (client) => {
         address: metadata.contracts.multicall3.address,
     });
 };
+/**
+ * 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
+ */
 export const loadBridgeFees = async ({ pathway, fromChainClient, toChainClient }) => {
     const multicall = pathway.feeManager === 'from'
         ? chainMulticall(fromChainClient)

package/dist/src/config.d.ts

@@ -10,26 +10,44 @@ export declare enum Chains {
     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, "ETH" | "PLS" | "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) => "ETH" | "PLS" | "BNB" | "SEP" | "V4PLS" | undefined;
+/** The provider of an omnibridge */
 export declare enum Provider {
     PULSECHAIN = "pulsechain",
     TOKENSEX = "tokensex"
 }
+/** 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[]>;
+/** 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;
-    defaultAssetIn: Token;
     usesExtraParam: boolean;
     feeManager: 'from' | 'to';
     toHome: boolean;
@@ -37,18 +55,59 @@ export type Pathway = {
     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[];
+/**
+ * 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
+ */
 export declare const inferBridgeKey: ({ currentKey, provider, fromChain, toChain, }: {
     currentKey: BridgeKey;
     provider: Provider;
     fromChain?: Chains;
     toChain?: Chains;
 }) => BridgeKey;
+/**
+ * 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
+ */
 export declare const pathway: (bridgeKey: BridgeKey | null, isProd: boolean, assetInAddress?: string | Hex | null | undefined) => Pathway | undefined;
-export declare const defaultAssetIn: ($bridgeKey: BridgeKey | null, isProd: boolean) => Token | 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;
+/**
+ * Returns whether the given asset is the native asset for the given bridge key
+ * @param asset - the asset
+ * @param bridgeKey - the bridge key
+ * @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) => boolean;
+/**
+ * Returns whether the given asset is unwrappable for the given bridge key
+ * @param bridgeKey - the bridge key
+ * @param assetIn - the asset in
+ * @returns whether the given asset is unwrappable for the given bridge key
+ */
 export declare const isUnwrappable: (bridgeKey: BridgeKey | null, assetIn: Pick<Token, "address"> | null) => boolean;
+/**
+ * Returns whether the given asset can be unwrapped for the given bridge key
+ * @param bridgeKey - the bridge key
+ * @param assetIn - the asset in
+ * @returns boolean
+ */
 export declare const canChangeUnwrap: (bridgeKey: BridgeKey, assetIn: Token | null) => boolean;

package/dist/src/config.js

@@ -1,6 +1,5 @@
 import { getAddress, zeroAddress } from "viem";
 import _ from 'lodash';
-import * as imageLinks from '@gibs/bridge-sdk/image-links';
 /**
  * Add here your chain id as hex, be sure to add your chain in the chainsMetadata object too
  */
@@ -14,14 +13,27 @@ export var Chains;
     Chains["V4PLS"] = "0x3af";
     // TBNB = '0x61',
 })(Chains || (Chains = {}));
+/** A map of chain ids to chain keys */
 export const chainIdToKey = new Map(Object.entries(Chains).map(([key, chain]) => [chain, key]));
+/**
+ * Converts a chain id to a chain key
+ * @param chainId - the chain id
+ * @returns the chain key
+ */
 export const toChain = (chainId) => `0x${Number(chainId).toString(16)}`;
+/**
+ * Converts a chain id to a chain key
+ * @param chainId - the chain id
+ * @returns the chain key
+ */
 export const toChainKey = (chainId) => chainIdToKey.get(toChain(chainId));
+/** The provider of an omnibridge */
 export var Provider;
 (function (Provider) {
     Provider["PULSECHAIN"] = "pulsechain";
     Provider["TOKENSEX"] = "tokensex";
 })(Provider || (Provider = {}));
+/** A map of chains to native asset out addresses */
 export const nativeAssetOut = {
     [Chains.ETH]: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
     [Chains.BNB]: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
@@ -29,9 +41,11 @@ export const nativeAssetOut = {
     [Chains.SEP]: '0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9',
     [Chains.V4PLS]: '0x70499adEBB11Efd915E3b69E700c331778628707',
 };
+/** A map of chains to deprecated native asset out addresses */
 export const deprecatedNativeAssetOut = {
     [Chains.PLS]: new Set(['0x97Ac4a2439A47c07ad535bb1188c989dae755341']),
 };
+/** A map of chains to uni v2 router addresses */
 export const uniV2Routers = {
     [Chains.PLS]: [
         '0x98bf93ebf5c380C0e6Ae8e192A7e2AE08edAcc02',
@@ -45,6 +59,7 @@ export const uniV2Routers = {
         '0x636f6407B90661b73b1C0F7e24F4C79f624d0738',
     ],
 };
+/** A map of chains to native token symbols */
 export const nativeTokenSymbol = {
     [Chains.PLS]: 'PLS',
     [Chains.V4PLS]: 'V4PLS',
@@ -52,6 +67,7 @@ export const nativeTokenSymbol = {
     [Chains.SEP]: 'sepETH',
     [Chains.BNB]: 'BNB',
 };
+/** A map of chains to native token names */
 export const nativeTokenName = {
     [Chains.PLS]: 'Pulse',
     [Chains.V4PLS]: 'V4 Pulse',
@@ -59,6 +75,7 @@ export const nativeTokenName = {
     [Chains.SEP]: 'Sepolia Ether',
     [Chains.BNB]: 'BNB',
 };
+/** The settings for the pulsechain pls eth pathway */
 const pulsechainPLSETHSettings = {
     from: '0x0e18d0d556b652794EF12Bf68B2dC857EF5f3996',
     to: '0xe20E337DB2a00b1C37139c873B92a0AAd3F468bF',
@@ -84,21 +101,6 @@ export const pathways = {
                     [zeroAddress]: pulsechainPLSETHSettings,
                     [getAddress(nativeAssetOut[Chains.PLS])]: pulsechainPLSETHSettings,
                 },
-                defaultAssetIn: {
-                    symbol: 'WETH',
-                    name: 'Wrapped Ether from Ethereum',
-                    address: '0x02DcdD04e3F455D838cd1249292C58f3B79e3C3C',
-                    decimals: 18,
-                    chainId: 369,
-                    logoURI: imageLinks.network(369),
-                    extensions: {
-                        bridgeInfo: {
-                            '1': {
-                                tokenAddress: nativeAssetOut[Chains.ETH],
-                            },
-                        },
-                    },
-                },
             },
         },
         [Chains.ETH]: {
@@ -122,21 +124,6 @@ export const pathways = {
                         nativeRouter: '0x1F0144Ce3BDaf11944Fe0beF6444599a0500695B',
                     },
                 },
-                defaultAssetIn: {
-                    chainId: 1,
-                    address: nativeAssetOut[Chains.ETH],
-                    name: 'Wrapped Ether',
-                    symbol: 'WETH',
-                    decimals: 18,
-                    logoURI: imageLinks.network(1),
-                    extensions: {
-                        bridgeInfo: {
-                            '369': {
-                                tokenAddress: '0x02DcdD04e3F455D838cd1249292C58f3B79e3C3C',
-                            },
-                        },
-                    },
-                },
             },
         },
     },
@@ -154,21 +141,6 @@ export const pathways = {
                 requiresDelivery: true,
                 // wbnb from bsc on pulsechain (tokensex)
                 bridgedNativeAssetOut: '0x518076CCE3729eF1a3877EA3647a26e278e764FE',
-                defaultAssetIn: {
-                    symbol: 'WBNB',
-                    name: 'Wrapped BNB',
-                    address: '0x518076CCE3729eF1a3877EA3647a26e278e764FE',
-                    decimals: 18,
-                    chainId: 369,
-                    logoURI: imageLinks.network(369),
-                    extensions: {
-                        bridgeInfo: {
-                            '56': {
-                                tokenAddress: nativeAssetOut[Chains.BNB],
-                            },
-                        },
-                    },
-                },
             },
         },
         [Chains.BNB]: {
@@ -184,21 +156,6 @@ export const pathways = {
                 requiresDelivery: false,
                 // wpls from pulsechain on bsc (tokensex)
                 bridgedNativeAssetOut: '0xF6088134D28eeBEF7128BA41FaDb2FCA0666c64C',
-                defaultAssetIn: {
-                    chainId: 56,
-                    address: nativeAssetOut[Chains.BNB],
-                    name: 'Wrapped BNB from BSC',
-                    symbol: 'WBNB',
-                    decimals: 18,
-                    logoURI: imageLinks.network(56),
-                    extensions: {
-                        bridgeInfo: {
-                            '369': {
-                                tokenAddress: '0x518076CCE3729eF1a3877EA3647a26e278e764FE',
-                            },
-                        },
-                    },
-                },
             },
         },
     },
@@ -240,21 +197,6 @@ export const testnetPathways = {
                 toHome: false,
                 feeManager: 'from',
                 bridgedNativeAssetOut: '0x3677bd78ccf4d299328ecfba61790cf8dbfcf686',
-                defaultAssetIn: {
-                    chainId: 943,
-                    address: '0x3677bd78CCf4d299328ECFBa61790cf8dBfcF686',
-                    name: 'Wrapped Ether from Sepolia',
-                    symbol: 'WsepETH',
-                    decimals: 18,
-                    logoURI: imageLinks.network(943),
-                    extensions: {
-                        bridgeInfo: {
-                            '11155111': {
-                                tokenAddress: nativeAssetOut[Chains.SEP],
-                            },
-                        },
-                    },
-                },
             },
         },
         [Chains.SEP]: {
@@ -269,39 +211,35 @@ export const testnetPathways = {
                 toHome: true,
                 feeManager: 'to',
                 bridgedNativeAssetOut: '0x35807560aD0597E23F452cdc82D4Fb0e7E3c6590',
-                defaultAssetIn: {
-                    chainId: 11_155_111,
-                    address: nativeAssetOut[Chains.SEP],
-                    name: 'Wrapped Ether',
-                    symbol: 'sepWETH',
-                    decimals: 18,
-                    logoURI: imageLinks.network(11_155_111),
-                    extensions: {
-                        bridgeInfo: {
-                            '943': {
-                                tokenAddress: '0x3677bd78CCf4d299328ECFBa61790cf8dBfcF686',
-                            },
-                        },
-                    },
-                },
             },
         },
     },
 };
+/** The mainnet bridge keys */
 const mainnetBridgeKeys = [
     [Provider.PULSECHAIN, Chains.PLS, Chains.ETH],
     [Provider.PULSECHAIN, Chains.ETH, Chains.PLS],
     [Provider.TOKENSEX, Chains.PLS, Chains.BNB],
     [Provider.TOKENSEX, Chains.BNB, Chains.PLS],
 ];
+/** The testnet bridge keys */
 const testnetBridgeKeys = [
     [Provider.PULSECHAIN, Chains.SEP, Chains.V4PLS],
     [Provider.PULSECHAIN, Chains.V4PLS, Chains.SEP],
 ];
+/** Returns the valid bridge keys for the given is prod */
 export const validBridgeKeys = (isProd) => [
     ...mainnetBridgeKeys,
     ...(isProd ? [] : testnetBridgeKeys),
 ];
+/**
+ * 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
+ */
 export const inferBridgeKey = ({ currentKey, provider, fromChain, toChain, }) => {
     const [, fromChainKey, toChainKey] = currentKey;
     const from = fromChain ?? fromChainKey;
@@ -316,6 +254,13 @@ export const inferBridgeKey = ({ currentKey, provider, fromChain, toChain, }) =>
         : Object.keys(pathways[provider][nextFromChain])[0];
     return [provider, nextFromChain, nextToChain];
 };
+/**
+ * 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
+ */
 export const pathway = (bridgeKey, isProd, assetInAddress) => {
     if (!bridgeKey)
         return;
@@ -331,11 +276,25 @@ export const pathway = (bridgeKey, isProd, assetInAddress) => {
     }
     return pathway;
 };
+/**
+ * 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 const defaultAssetIn = ($bridgeKey, isProd) => {
+    if (!$bridgeKey)
+        return null;
     const conf = pathway($bridgeKey, isProd);
-    const defaultAssetIn = _.get(conf, ['defaultAssetIn']);
+    const defaultAssetIn = _.get(conf, ['bridgedNativeAssetOut']);
     return defaultAssetIn;
 };
+/**
+ * Returns whether the given asset is the native asset for the given bridge key
+ * @param asset - the asset
+ * @param bridgeKey - the bridge key
+ * @returns whether the given asset is the native asset for the given bridge key
+ */
 export const isNative = (asset, bridgeKey) => {
     if (!bridgeKey || !asset) {
         return false;
@@ -346,6 +305,12 @@ export const isNative = (asset, bridgeKey) => {
             nativeAssetOut[toChain(asset.chainId)]?.toLowerCase() === asset.address?.toLowerCase()) &&
             !asset.name.includes(' from Pulsechain'));
 };
+/**
+ * Returns whether the given asset is unwrappable for the given bridge key
+ * @param bridgeKey - the bridge key
+ * @param assetIn - the asset in
+ * @returns whether the given asset is unwrappable for the given bridge key
+ */
 export const isUnwrappable = (bridgeKey, assetIn) => {
     if (!bridgeKey || !assetIn) {
         return false;
@@ -356,6 +321,12 @@ export const isUnwrappable = (bridgeKey, assetIn) => {
         return false;
     return path.bridgedNativeAssetOut === getAddress(addr);
 };
+/**
+ * Returns whether the given asset can be unwrapped for the given bridge key
+ * @param bridgeKey - the bridge key
+ * @param assetIn - the asset in
+ * @returns boolean
+ */
 export const canChangeUnwrap = (bridgeKey, assetIn) => {
     return !!assetIn && isUnwrappable(bridgeKey, assetIn);
 };

package/dist/src/fee-type.d.ts

@@ -1,7 +1,10 @@
+/** The type of fee to use for the bridge */
 export declare enum FeeType {
     PERCENT = "%",
     GAS_TIP = "gas+%",
     FIXED = "fixed"
 }
+/** The keys of the fee type */
 export type FeeTypeKeys = keyof typeof FeeType;
+/** A map of fee type values to keys */
 export declare const feeTypeValToKeyMap: Map<FeeType, "PERCENT" | "GAS_TIP" | "FIXED">;

package/dist/src/fee-type.js

@@ -1,7 +1,9 @@
+/** The type of fee to use for the bridge */
 export var FeeType;
 (function (FeeType) {
     FeeType["PERCENT"] = "%";
     FeeType["GAS_TIP"] = "gas+%";
     FeeType["FIXED"] = "fixed";
 })(FeeType || (FeeType = {}));
+/** A map of fee type values to keys */
 export const feeTypeValToKeyMap = new Map(Object.keys(FeeType).map((key) => [FeeType[key], key]));