@gibs/bridge-sdk 1.6.36 → 1.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gibs/bridge-sdk",
-  "version": "1.6.36",
+  "version": "1.7.2",
   "main": "index.js",
   "access": "public",
   "type": "module",
@@ -12,7 +12,8 @@
     "./image-links": "./src/image-links.ts",
     "./chains": "./src/chains.ts",
     "./chain-info": "./src/chain-info.ts",
-    "./fee-type": "./src/fee-type.ts"
+    "./fee-type": "./src/fee-type.ts",
+    "./settings": "./src/settings.ts"
   },
   "scripts": {
     "build": "tsc"

package/src/abis.ts

@@ -1,6 +1,6 @@
 import { parseAbi, parseAbiParameters } from 'viem'
 
-/** the abi for the bridge */
+/** the abi for the input bridge */
 export const inputBridge = parseAbi([
   'function minPerTx(address token) external view returns(uint256)',
   'function foreignTokenAddress(address token) external view returns(address)',
@@ -11,47 +11,59 @@ export const inputBridge = parseAbi([
   'function relayTokensAndCall(address token, address _receiver, uint256 _value, bytes memory _data) external',
   'function relayTokens(address token, address _receiver, uint256 _value) external',
 ])
+/** the abi for the input bridge with extra input for the sender origin (tokensex) */
 export const inputBridgeExtraInput = parseAbi([
   'function relayTokensAndCall(address token, address _receiver, uint256 _value, bytes memory _data, address _senderOrigin) external',
   'function relayTokens(address token, address _receiver, uint256 _value, address _senderOrigin) external',
 ])
+/** the abi for erc677 tokens */
 export const erc677 = parseAbi([
   'function transferAndCall(address, uint256, bytes calldata) external',
 ])
+/** the abi for erc677 tokens bridge with extra input for the sender origin (tokensex) */
 export const erc677ExtraInput = parseAbi([
   'function transferAndCall(address, uint256, bytes calldata, address sender) external',
 ])
+/** the abi to read data from the output router */
 export const outputRouter = parseAbi([
   'function onTokenBridged(address _token, uint256 _value, bytes memory _data) external payable',
   'function WETH() external view returns(address)',
   'function bridge() external view returns(address)',
 ])
+/** the abi for the output bridge */
 export const outputBridge = parseAbi(['function bridgeContract() external view returns(address)'])
+/** the abi for the fee manager */
 export const feeManager = parseAbi([
   'function HOME_TO_FOREIGN_FEE() public view returns(bytes32)',
   'function FOREIGN_TO_HOME_FEE() public view returns(bytes32)',
   'function getFee(bytes32, address) public view returns(uint256)',
 ])
+/** the abi for the native router */
 export const nativeRouter = parseAbi([
   'function wrapAndRelayTokens(address receiver) external payable',
   'function relayTokensAndCall(address receiver, bytes calldata data) external payable',
 ])
+/** the abi for the native router with extra input for the sender origin (tokensex) */
 export const nativeRouterExtraInput = parseAbi([
   'function wrapAndRelayTokens(address receiver, address sender) external payable',
   'function relayTokensAndCall(address receiver, bytes calldata data, address sender) external payable',
 ])
+/** the abi for the univ2 router */
 export const univ2Router = parseAbi([
   'function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns(uint256[] memory)',
 ])
+/** the abi for the fee delivery struct */
 export const feeDeliveryStruct = parseAbiParameters('(address, uint256, uint256, uint256)')
-
+/** the abi for the relay tokens direct */
 export const relayTokensDirect = parseAbi([
   'function safeExecuteSignaturesWithAutoGasLimit(bytes calldata data, bytes calldata signatures) external',
 ])
+/** the abi for the home amb */
 export const homeAmb = parseAbi([
   'function submitSignature(bytes message, bytes signature) external',
 ])
 
+/** the abi for the univ2 pair */
 export const pair = parseAbi([
   'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
 ])

package/src/chain-info.ts

@@ -20,6 +20,14 @@ export type TokenBridgeInfo = {
   }
 }
 
+/**
+ * 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 }: { chainId: number; target: Hex; address: Hex, client: PublicClient }) => {
     return multicallRead<Hex[]>({
@@ -36,6 +44,15 @@ export const links = _.memoize(
   ({ 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,
@@ -49,7 +66,7 @@ export const tokenBridgeInfo = async ({
   fromChainClient: PublicClient,
   toChainClient: PublicClient,
 }): Promise<null | TokenBridgeInfo> => {
-  const bridgePathway = pathway(bridgeKey, isProd)
+  const bridgePathway = pathway(bridgeKey, isProd, assetIn?.address as Hex | null)
   if (!assetIn || !bridgePathway) {
     console.log('missing asset in or bridge pathway')
     return null
@@ -72,28 +89,23 @@ export const tokenBridgeInfo = async ({
     }),
   ])
   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 as Hex,
       assetOutAddress: toBridged,
-      toForeign: {
-        foreign: toBridged,
-        home: assetInAddress as Hex,
+      toHome: {
+        home: toBridged,
+        foreign: assetInAddress as Hex,
       },
     }
   }
   if (toNative !== zeroAddress) {
-    // if (notGas) console.log('toNative')
     return {
       originationChainId: toChain,
       assetInAddress: assetInAddress as Hex,
       assetOutAddress: toNative,
-      toHome: {
+      toForeign: {
         home: toNative,
         foreign: assetInAddress as Hex,
       },
@@ -101,7 +113,6 @@ export const tokenBridgeInfo = async ({
   }
   const [fromBridged, fromNative] = fromMappings
   if (fromNative !== zeroAddress) {
-    // if (notGas) console.log('fromNative')
     return {
       originationChainId: toChain,
       assetInAddress: assetInAddress as Hex,
@@ -113,7 +124,6 @@ export const tokenBridgeInfo = async ({
     }
   }
   if (fromBridged !== zeroAddress) {
-    // if (notGas) console.log('fromBridged')
     return {
       originationChainId: fromChain,
       assetInAddress: assetInAddress as Hex,
@@ -144,9 +154,10 @@ export const tokenBridgeInfo = async ({
       }),
   }
 }
+/** The result of reading the amount out from a router */
 export type FetchResult = bigint[] | Hex
 /**
- * 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
@@ -184,10 +195,19 @@ const readAmountOut = ({
   })
 }
 
+/**
+ * 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 = ({
-  // bridgeKey,
-  // assetIn,
-  // isProd,
   bridgeKeyPartner,
   assetOut,
   measurementToken,
@@ -298,6 +318,14 @@ export const fetchPriceCorrective = ({
   }
 }
 
+/**
+ * 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,
@@ -318,22 +346,28 @@ export const minBridgeAmountIn = async ({
   })
 }
 /** get the symbol of the native asset, unwrap it if it needs to be */
-export const nativeSymbol = (asset: { address: Hex, symbol: string, chainId: number } | null, unwrap = false) => {
+export const nativeSymbol = (asset: { address: string, symbol: string, chainId: number } | null, unwrap = false) => {
   return asset ? (unwrap && asset.address === nativeAssetOut[toChain(asset.chainId)] ? asset.symbol.slice(1) : asset.symbol) : ''
 }
 
+/** 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 const chainMulticall = (client: PublicClient) => {
   const chainId = client.chain!.id
   const metadata = chainsMetadata[toChain(chainId)]
@@ -343,7 +377,13 @@ export const chainMulticall = (client: PublicClient) => {
     address: metadata.contracts!.multicall3!.address,
   }) as 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 const loadBridgeFees = async ({ pathway, fromChainClient, toChainClient }: InputLoadFeeFor) => {
   const multicall = pathway.feeManager === 'from'
     ? chainMulticall(fromChainClient)

package/src/config.ts

@@ -1,4 +1,4 @@
-import { zeroAddress, type Hex } from "viem";
+import { getAddress, zeroAddress, type Hex } from "viem";
 import _ from 'lodash'
 import * as imageLinks from '@gibs/bridge-sdk/image-links'
 import type { BridgeKey, Token, TokenOut } from "./types.js";
@@ -16,21 +16,35 @@ export enum Chains {
   // TBNB = '0x61',
 }
 
+/** 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 const chainIdToKey = new Map<Chains, ChainKey>(
   Object.entries(Chains).map(([key, chain]) => [chain, key] as [Chains, ChainKey]),
 )
 
+/**
+ * Converts a chain id to a chain key
+ * @param chainId - the chain id
+ * @returns the chain key
+ */
 export const toChain = (chainId: number | string) => `0x${Number(chainId).toString(16)}` as Chains
 
+/**
+ * Converts a chain id to a chain key
+ * @param chainId - the chain id
+ * @returns the chain key
+ */
 export const toChainKey = (chainId: number | string) => chainIdToKey.get(toChain(chainId))
 
+/** The provider of an omnibridge */
 export enum Provider {
   PULSECHAIN = 'pulsechain',
   TOKENSEX = 'tokensex',
 }
 
+/** A map of chains to native asset out addresses */
 export const nativeAssetOut = {
   [Chains.ETH]: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
   [Chains.BNB]: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
@@ -39,6 +53,12 @@ export const nativeAssetOut = {
   [Chains.V4PLS]: '0x70499adEBB11Efd915E3b69E700c331778628707',
 } as Record<Chains, Hex>
 
+/** A map of chains to deprecated native asset out addresses */
+export const deprecatedNativeAssetOut = {
+  [Chains.PLS]: new Set(['0x97Ac4a2439A47c07ad535bb1188c989dae755341']),
+} as Partial<Record<Chains, Set<Hex>>>
+
+/** A map of chains to uni v2 router addresses */
 export const uniV2Routers = {
   [Chains.PLS]: [
     '0x98bf93ebf5c380C0e6Ae8e192A7e2AE08edAcc02',
@@ -53,6 +73,7 @@ export const uniV2Routers = {
   ],
 } as Record<Chains, Hex[]>
 
+/** A map of chains to native token symbols */
 export const nativeTokenSymbol = {
   [Chains.PLS]: 'PLS',
   [Chains.V4PLS]: 'V4PLS',
@@ -61,6 +82,7 @@ export const nativeTokenSymbol = {
   [Chains.BNB]: 'BNB',
 } as Record<Chains, string>
 
+/** A map of chains to native token names */
 export const nativeTokenName = {
   [Chains.PLS]: 'Pulse',
   [Chains.V4PLS]: 'V4 Pulse',
@@ -69,24 +91,36 @@ export const nativeTokenName = {
   [Chains.BNB]: 'BNB',
 } as Record<Chains, string>
 
+/** The pathway of a bridge */
 export type Pathway = {
   from: Hex
   to: Hex
   destinationRouter: Hex | null
   nativeRouter: Hex
   validator: Hex
-  defaultAssetIn: Token
+  // defaultAssetIn: Token
   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>>>>
 >
 
+/** The settings for the pulsechain pls eth pathway */
+const pulsechainPLSETHSettings = {
+  from: '0x0e18d0d556b652794EF12Bf68B2dC857EF5f3996',
+  to: '0xe20E337DB2a00b1C37139c873B92a0AAd3F468bF',
+  destinationRouter: '0x1F0144Ce3BDaf11944Fe0beF6444599a0500695B',
+  nativeRouter: '0xE66877Cfe4CEc10ffBbBB3092B7001321AB5809D',
+}
+
 export const pathways = {
   [Provider.PULSECHAIN]: {
     [Chains.PLS]: {
@@ -100,20 +134,11 @@ export const pathways = {
         feeManager: 'from',
         toHome: false,
         requiresDelivery: true,
-        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],
-              },
-            },
-          },
+        // weth from ethereum on pulsechain
+        bridgedNativeAssetOut: '0x02DcdD04e3F455D838cd1249292C58f3B79e3C3C',
+        settingOverrides: {
+          [zeroAddress]: pulsechainPLSETHSettings,
+          [getAddress(nativeAssetOut[Chains.PLS])]: pulsechainPLSETHSettings,
         },
       },
     },
@@ -128,19 +153,14 @@ export const pathways = {
         usesExtraParam: false,
         toHome: true,
         requiresDelivery: false,
-        defaultAssetIn: {
-          chainId: 1,
-          address: nativeAssetOut[Chains.ETH],
-          name: 'Wrapped Ether',
-          symbol: 'WETH',
-          decimals: 18,
-          logoURI: imageLinks.network(1),
-          extensions: {
-            bridgeInfo: {
-              '369': {
-                tokenAddress: '0x02DcdD04e3F455D838cd1249292C58f3B79e3C3C',
-              },
-            },
+        // wpls from pulsechain on ethereum
+        bridgedNativeAssetOut: '0xA882606494D86804B5514E07e6Bd2D6a6eE6d68A',
+        settingOverrides: {
+          [getAddress('0xa882606494d86804b5514e07e6bd2d6a6ee6d68a')]: {
+            from: '0xe20E337DB2a00b1C37139c873B92a0AAd3F468bF',
+            to: '0x0e18d0d556b652794EF12Bf68B2dC857EF5f3996',
+            destinationRouter: '0xE66877Cfe4CEc10ffBbBB3092B7001321AB5809D',
+            nativeRouter: '0x1F0144Ce3BDaf11944Fe0beF6444599a0500695B',
           },
         },
       },
@@ -158,21 +178,8 @@ export const pathways = {
         usesExtraParam: true,
         toHome: false,
         requiresDelivery: true,
-        defaultAssetIn: {
-          symbol: 'WBNB',
-          name: 'Wrapped BNB',
-          address: '0x518076CCE3729eF1a3877EA3647a26e278e764FE',
-          decimals: 18,
-          chainId: 369,
-          logoURI: imageLinks.network(369),
-          extensions: {
-            bridgeInfo: {
-              '56': {
-                tokenAddress: nativeAssetOut[Chains.BNB],
-              },
-            },
-          },
-        },
+        // wbnb from bsc on pulsechain (tokensex)
+        bridgedNativeAssetOut: '0x518076CCE3729eF1a3877EA3647a26e278e764FE',
       },
     },
     [Chains.BNB]: {
@@ -186,21 +193,8 @@ export const pathways = {
         usesExtraParam: true,
         toHome: true,
         requiresDelivery: false,
-        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',
-              },
-            },
-          },
-        },
+        // wpls from pulsechain on bsc (tokensex)
+        bridgedNativeAssetOut: '0xF6088134D28eeBEF7128BA41FaDb2FCA0666c64C',
       },
     },
   },
@@ -242,21 +236,7 @@ export const testnetPathways = {
         requiresDelivery: true,
         toHome: false,
         feeManager: 'from',
-        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],
-              },
-            },
-          },
-        },
+        bridgedNativeAssetOut: '0x3677bd78ccf4d299328ecfba61790cf8dbfcf686',
       },
     },
     [Chains.SEP]: {
@@ -270,26 +250,13 @@ export const testnetPathways = {
         requiresDelivery: false,
         toHome: true,
         feeManager: 'to',
-        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',
-              },
-            },
-          },
-        },
+        bridgedNativeAssetOut: '0x35807560aD0597E23F452cdc82D4Fb0e7E3c6590',
       },
     },
   },
 } as DeepPathwayConfig
 
+/** The mainnet bridge keys */
 const mainnetBridgeKeys = [
   [Provider.PULSECHAIN, Chains.PLS, Chains.ETH],
   [Provider.PULSECHAIN, Chains.ETH, Chains.PLS],
@@ -297,16 +264,26 @@ const mainnetBridgeKeys = [
   [Provider.TOKENSEX, Chains.BNB, Chains.PLS],
 ] as BridgeKey[]
 
+/** The testnet bridge keys */
 const testnetBridgeKeys = [
   [Provider.PULSECHAIN, Chains.SEP, Chains.V4PLS],
   [Provider.PULSECHAIN, Chains.V4PLS, Chains.SEP],
 ] as BridgeKey[]
 
+/** Returns the valid bridge keys for the given is prod */
 export const validBridgeKeys = (isProd: boolean) => [
   ...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,
@@ -332,38 +309,85 @@ export const inferBridgeKey = ({
   return [provider, nextFromChain, nextToChain] as BridgeKey
 }
 
-export const pathway = (bridgeKey: BridgeKey | null, isProd: boolean) => {
+/**
+ * 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: BridgeKey | null, isProd: boolean, assetInAddress?: string | Hex | null | undefined) => {
   if (!bridgeKey) return
-  return _.get(pathways, bridgeKey) || (!isProd ? _.get(testnetPathways, bridgeKey) : undefined)
+  let pathway = _.get(pathways, bridgeKey) || (!isProd ? _.get(testnetPathways, bridgeKey) : undefined)
+  if (assetInAddress) {
+    const addr = getAddress(assetInAddress)
+    if (pathway?.settingOverrides?.[addr]) {
+      pathway = {
+        ...pathway,
+        ...pathway.settingOverrides[addr],
+      }
+    }
+  }
+  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: BridgeKey | null, isProd: boolean) => {
+  if (!$bridgeKey) return null
   const conf = pathway($bridgeKey, isProd)
-  const defaultAssetIn = _.get(conf, ['defaultAssetIn']) as Token | undefined
+  const defaultAssetIn = _.get(conf, ['bridgedNativeAssetOut']) as Hex | undefined
   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: Token | TokenOut | null, bridgeKey: BridgeKey | null) => {
   if (!bridgeKey || !asset) {
     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')
   )
 }
 
+/**
+ * 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 = (
-  asset: Pick<Token, 'extensions'> | null,
   bridgeKey: BridgeKey | null,
+  assetIn: Pick<Token, 'address'> | null,
 ) => {
-  if (!bridgeKey || !asset) {
+  if (!bridgeKey || !assetIn) {
     return false
   }
-  const [, , toChain] = bridgeKey
-  return nativeAssetOut[toChain] === asset.extensions?.bridgeInfo?.[Number(toChain)]?.tokenAddress
+  const addr = getAddress(assetIn.address)
+  const path = pathway(bridgeKey, false)
+  if (!path) return false
+  return path.bridgedNativeAssetOut === getAddress(addr)
 }
 
-export const canChangeUnwrap = (bridgeKey: BridgeKey, assetIn: Token | null) =>
-  !!assetIn && isUnwrappable(assetIn, bridgeKey)
+/**
+ * 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: BridgeKey, assetIn: Token | null) => {
+  return !!assetIn && isUnwrappable(bridgeKey, assetIn)
+}

package/src/fee-type.ts

@@ -1,12 +1,14 @@
-
+/** The type of fee to use for the bridge */
 export 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 const feeTypeValToKeyMap = new Map<FeeType, FeeTypeKeys>(
   (Object.keys(FeeType) as FeeTypeKeys[]).map((key) => [FeeType[key], key]),
 )