@gibs/bridge-sdk 1.6.27

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@gibs/bridge-sdk",
+  "version": "1.6.27",
+  "main": "index.js",
+  "access": "public",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./types": "./src/types.ts",
+    "./config": "./src/config.ts",
+    "./abis": "./src/abis.ts",
+    "./image-links": "./src/image-links.ts",
+    "./chains": "./src/chains.ts",
+    "./chain-info": "./src/chain-info.ts",
+    "./fee-type": "./src/fee-type.ts"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@gibs/common": "^1.0.0",
+    "lodash": "^4.17.21",
+    "viem": "^2.31.0"
+  }
+}

package/src/abis.ts

@@ -0,0 +1,57 @@
+import { parseAbi, parseAbiParameters } from 'viem'
+
+/** the abi for the bridge */
+export const inputBridge = parseAbi([
+  'function minPerTx(address token) external view returns(uint256)',
+  'function foreignTokenAddress(address token) external view returns(address)',
+  'function homeTokenAddress(address token) external view returns(address)',
+  'function bridgedTokenAddress(address token) external view returns(address)',
+  'function nativeTokenAddress(address token) external view returns(address)',
+  'function feeManager() external view returns(address)',
+  'function relayTokensAndCall(address token, address _receiver, uint256 _value, bytes memory _data) external',
+  'function relayTokens(address token, address _receiver, uint256 _value) external',
+])
+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',
+])
+export const erc677 = parseAbi([
+  'function transferAndCall(address, uint256, bytes calldata) external',
+])
+export const erc677ExtraInput = parseAbi([
+  'function transferAndCall(address, uint256, bytes calldata, address sender) external',
+])
+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)',
+])
+export const outputBridge = parseAbi(['function bridgeContract() external view returns(address)'])
+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)',
+])
+export const nativeRouter = parseAbi([
+  'function wrapAndRelayTokens(address receiver) external payable',
+  'function relayTokensAndCall(address receiver, bytes calldata data) external payable',
+])
+export const nativeRouterExtraInput = parseAbi([
+  'function wrapAndRelayTokens(address receiver, address sender) external payable',
+  'function relayTokensAndCall(address receiver, bytes calldata data, address sender) external payable',
+])
+export const univ2Router = parseAbi([
+  'function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns(uint256[] memory)',
+])
+export const feeDeliveryStruct = parseAbiParameters('(address, uint256, uint256, uint256)')
+
+export const relayTokensDirect = parseAbi([
+  'function safeExecuteSignaturesWithAutoGasLimit(bytes calldata data, bytes calldata signatures) external',
+])
+export const homeAmb = parseAbi([
+  'function submitSignature(bytes message, bytes signature) external',
+])
+
+export const pair = parseAbi([
+  'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+])

package/src/chain-info.ts

@@ -0,0 +1,424 @@
+import { encodeFunctionData, getContract, type Hex, multicall3Abi, type PublicClient, zeroAddress } from "viem"
+import { Chains, nativeAssetOut, type Pathway, pathway, toChain, uniV2Routers } from "./config.js"
+import type { BridgeKey, Token } from "./types.js"
+import _ from "lodash"
+import { chainsMetadata } from "./chains.js"
+import * as abis from "./abis.js"
+import { multicallRead } from "@gibs/common/multicall"
+
+export type TokenBridgeInfo = {
+  originationChainId: Chains
+  assetInAddress: Hex
+  assetOutAddress: Hex | null
+  toForeign?: {
+    home: Hex
+    foreign: Hex | null
+  }
+  toHome?: {
+    home: Hex | null
+    foreign: Hex
+  }
+}
+
+export const links = _.memoize(
+  async ({ chainId, target, address, client }: { chainId: number; target: Hex; address: Hex, client: PublicClient }) => {
+    return multicallRead<Hex[]>({
+      client,
+      chain: chainsMetadata[toChain(chainId)],
+      abi: abis.inputBridge,
+      target,
+      calls: [
+        { functionName: 'bridgedTokenAddress', args: [address] },
+        { functionName: 'nativeTokenAddress', args: [address] },
+      ],
+    })
+  },
+  ({ chainId, target, address }) => `${chainId}-${target}-${address}`.toLowerCase(),
+)
+
+export const tokenBridgeInfo = async ({
+  bridgeKey,
+  assetIn,
+  isProd,
+  fromChainClient,
+  toChainClient,
+}: {
+  bridgeKey: BridgeKey,
+  assetIn: Token | null,
+  isProd: boolean,
+  fromChainClient: PublicClient,
+  toChainClient: PublicClient,
+}): Promise<null | TokenBridgeInfo> => {
+  const bridgePathway = pathway(bridgeKey, isProd)
+  if (!assetIn || !bridgePathway) {
+    console.log('missing asset in or bridge pathway')
+    return null
+  }
+  const [, fromChain, toChain] = bridgeKey
+  const assetInAddress =
+    assetIn.address === zeroAddress ? nativeAssetOut[fromChain] : assetIn.address
+  const [toMappings, fromMappings] = await Promise.all([
+    links({
+      chainId: Number(toChain),
+      target: bridgePathway.to,
+      address: assetInAddress as Hex,
+      client: toChainClient,
+    }),
+    links({
+      chainId: Number(fromChain),
+      target: bridgePathway.from,
+      address: assetInAddress as Hex,
+      client: fromChainClient,
+    }),
+  ])
+  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,
+      },
+    }
+  }
+  if (toNative !== zeroAddress) {
+    // if (notGas) console.log('toNative')
+    return {
+      originationChainId: toChain,
+      assetInAddress: assetInAddress as Hex,
+      assetOutAddress: toNative,
+      toHome: {
+        home: toNative,
+        foreign: assetInAddress as Hex,
+      },
+    }
+  }
+  const [fromBridged, fromNative] = fromMappings
+  if (fromNative !== zeroAddress) {
+    // if (notGas) console.log('fromNative')
+    return {
+      originationChainId: toChain,
+      assetInAddress: assetInAddress as Hex,
+      assetOutAddress: fromNative,
+      toHome: {
+        home: assetInAddress as Hex,
+        foreign: fromNative,
+      },
+    }
+  }
+  if (fromBridged !== zeroAddress) {
+    // if (notGas) console.log('fromBridged')
+    return {
+      originationChainId: fromChain,
+      assetInAddress: assetInAddress as Hex,
+      assetOutAddress: fromBridged,
+      toForeign: {
+        foreign: fromBridged,
+        home: assetInAddress as Hex,
+      },
+    }
+  }
+  // the token has not been bridged yet
+  return {
+    originationChainId: toChain,
+    assetInAddress: assetInAddress as Hex,
+    assetOutAddress: null,
+    ...(bridgePathway.toHome
+      ? {
+        toHome: {
+          foreign: assetInAddress as Hex,
+          home: null,
+        },
+      }
+      : {
+        toForeign: {
+          foreign: null,
+          home: assetInAddress as Hex,
+        },
+      }),
+  }
+}
+export type FetchResult = bigint[] | Hex
+/**
+ * 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,
+}: {
+  amountIn: bigint,
+  chain: Chains,
+  paths: Hex[][],
+  client: PublicClient,
+  uniV2Router?: Hex,
+}): Promise<FetchResult[]> => {
+  return multicallRead<FetchResult[]>({
+    chain: chainsMetadata[chain],
+    client,
+    abi: abis.univ2Router,
+    // pulsex router
+    calls: _.flatMap(uniV2Router ? [uniV2Router] : uniV2Routers[chain], (target) =>
+      paths.map((path) => ({
+        functionName: 'getAmountsOut',
+        allowFailure: true,
+        args: [amountIn, path],
+        target,
+      })),
+    ),
+  })
+}
+
+export const fetchPriceCorrective = ({
+  // bridgeKey,
+  // assetIn,
+  // isProd,
+  bridgeKeyPartner,
+  assetOut,
+  measurementToken,
+  fromChainClient,
+  toChainClient,
+  assetLink,
+  amountIn,
+  isProd,
+}: {
+  bridgeKey: BridgeKey,
+  bridgeKeyPartner: BridgeKey,
+  measurementToken: Hex,
+  assetOut: Token,
+  fromChainClient: PublicClient,
+  toChainClient: PublicClient,
+  assetLink: TokenBridgeInfo,
+  amountIn: bigint,
+  isProd: boolean,
+}) => {
+  return {
+    getPaymentToken: async () => {
+      // fetch the token bridge info for the token that is about to be spent by the delivery service
+      return await tokenBridgeInfo({
+        bridgeKey: bridgeKeyPartner,
+        assetIn: {
+          ...assetOut,
+          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,
+      })
+    },
+    getSwapResults: async ({
+      paymentTokenResult,
+      chain,
+      uniV2Router,
+      client,
+    }: {
+      paymentTokenResult: TokenBridgeInfo
+      chain: Chains
+      client: PublicClient
+      uniV2Router?: Hex
+    }) => {
+      return await Promise.all([
+        readAmountOut({
+          amountIn,
+          chain,
+          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, nativeAssetOut[chain], paymentTokenResult!.assetOutAddress!],
+          ],
+        }),
+        readAmountOut({
+          amountIn,
+          chain,
+          uniV2Router,
+          client,
+          paths: [[assetOut.address as Hex, measurementToken]],
+          // only the direct route is available.
+          // might be able to create a whitelist for this at some point
+        }),
+      ])
+    },
+    reduceResults: ({
+      results,
+      oneToken,
+    }: {
+      results: [FetchResult[], ...[FetchResult[]]]
+      oneToken: bigint
+    }) => {
+      const outputFromRouter = (result: FetchResult) => {
+        if (_.isString(result)) {
+          // 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
+      }
+      const max = (amountsOut: (bigint | undefined)[]) => {
+        return _.compact(amountsOut).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)
+      const outputToken = max(outputAmounts)
+      const inputToken = max(inputAmounts)
+      const result =
+        outputToken && outputToken > 0n
+          ? inputToken && inputToken > outputToken && inputToken / outputToken === 1n
+            ? inputToken
+            : outputToken
+          : inputToken
+      return result
+    }
+  }
+}
+
+export const minBridgeAmountIn = async ({
+  assetIn,
+  pathway,
+  fromPublicClient,
+  toPublicClient,
+}: {
+  assetIn: Token,
+  pathway: Pathway,
+  fromPublicClient: PublicClient,
+  toPublicClient: PublicClient,
+}) => {
+  const publicClient = pathway?.feeManager === 'from' ? fromPublicClient : toPublicClient
+  return publicClient.readContract({
+    abi: abis.inputBridge,
+    functionName: 'minPerTx',
+    args: [assetIn.address as Hex],
+    address: pathway[pathway.feeManager],
+  })
+}
+/** 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) => {
+  return asset ? (unwrap && asset.address === nativeAssetOut[toChain(asset.chainId)] ? asset.symbol.slice(1) : asset.symbol) : ''
+}
+
+export type InputLoadFeeFor = {
+  pathway: Pathway
+  fromChainClient: PublicClient
+  toChainClient: PublicClient
+}
+
+export type PathwayExtendableConfig = {
+  feeManager: Hex
+  feeH2F: bigint
+  feeF2H: bigint
+}
+
+export const chainMulticall = (client: PublicClient) => {
+  const chainId = client.chain!.id
+  const metadata = chainsMetadata[toChain(chainId)]
+  return getContract({
+    abi: multicall3Abi,
+    client: client as any,
+    address: metadata.contracts!.multicall3!.address,
+  }) as any
+}
+
+export const loadBridgeFees = async ({ pathway, fromChainClient, toChainClient }: InputLoadFeeFor) => {
+  const multicall = pathway.feeManager === 'from'
+    ? chainMulticall(fromChainClient)
+    : chainMulticall(toChainClient)
+
+  const [feeManagerResponse] = await multicall.read.aggregate3([
+    [
+      {
+        allowFailure: false,
+        target: pathway[pathway.feeManager],
+        callData: encodeFunctionData({
+          abi: abis.inputBridge,
+          functionName: 'feeManager',
+        }),
+      },
+    ],
+  ])
+  const { success, returnData } = feeManagerResponse
+  if (!success) {
+    throw new Error('unable to load feeManager')
+  }
+  if (returnData === '0x') {
+    throw new Error('unable to read feeManager')
+  }
+  const feeManager = (
+    returnData.startsWith('0x000000000000000000000000')
+      ? `0x${returnData.slice(26)}`
+      : `0x${returnData.slice(-40)}`
+  ) as Hex
+  const [keyH2F, keyF2H] = await multicall.read.aggregate3([
+    [
+      {
+        allowFailure: false,
+        target: feeManager,
+        callData: encodeFunctionData({
+          abi: abis.feeManager,
+          functionName: 'HOME_TO_FOREIGN_FEE',
+        }),
+      },
+      {
+        allowFailure: false,
+        target: feeManager,
+        callData: encodeFunctionData({
+          abi: abis.feeManager,
+          functionName: 'FOREIGN_TO_HOME_FEE',
+        }),
+      },
+    ],
+  ])
+  const [feeH2F, feeF2H] = await multicall.read.aggregate3([
+    [
+      {
+        allowFailure: false,
+        target: feeManager,
+        callData: encodeFunctionData({
+          abi: abis.feeManager,
+          functionName: 'getFee',
+          args: [keyH2F.returnData, zeroAddress],
+        }),
+      },
+      {
+        allowFailure: false,
+        target: feeManager,
+        callData: encodeFunctionData({
+          abi: abis.feeManager,
+          functionName: 'getFee',
+          args: [keyF2H.returnData, zeroAddress],
+        }),
+      },
+    ],
+  ])
+  const setting = {
+    feeManager,
+    feeH2F: BigInt(feeH2F.returnData),
+    feeF2H: BigInt(feeF2H.returnData),
+  } as PathwayExtendableConfig
+  return setting
+}

package/src/chains.ts

@@ -0,0 +1,88 @@
+import { mainnet, pulsechain, bsc, sepolia, pulsechainV4 } from '@reown/appkit/networks'
+import { Chains } from '@gibs/bridge-sdk/config'
+import type { ChainsMetadata } from '@gibs/bridge-sdk/types'
+import * as imageLinks from '@gibs/bridge-sdk/image-links'
+
+/**
+ * all of the chains that are enabled in this dapp
+ * and their corresponding useful metadata
+ */
+export const chainsMetadata = {
+  [Chains.PLS]: {
+    ...pulsechain,
+    chainId: Chains.PLS,
+    logoURI: imageLinks.network(pulsechain.id),
+    alt: 'a pink blue and purple hexagon with an ekg line running horizontally',
+    rpcUrls: {
+      default: {
+        http: ['https://rpc.pulsechain.com'],
+      },
+    },
+    contracts: {
+      ...pulsechain.contracts,
+      ensRegistry: {
+        address: '0xbd5133993FCDED5945c5539D9f032261F0d13170',
+      },
+      ensUniversalResolver: {
+        address: '0x2FDBb906b4FE68e31D928C1ED0b6a3bD1f204374',
+        blockCreated: 19_400_610,
+      },
+    },
+  },
+  [Chains.ETH]: {
+    ...mainnet,
+    chainId: Chains.ETH,
+    logoURI: imageLinks.network(mainnet.id),
+    alt: 'two pyramids joined on one side',
+    rpcUrls: {
+      default: {
+        http: ['https://rpc-ethereum.g4mm4.io'],
+      },
+    },
+  },
+  [Chains.BNB]: {
+    ...bsc,
+    name: 'Binance Smart Chain',
+    chainId: Chains.BNB,
+    logoURI: imageLinks.network(bsc.id),
+    alt: 'a gold cube with slits in the middle of each side',
+    rpcUrls: {
+      default: {
+        http: ['https://bsc-pokt.nodies.app'],
+      },
+    },
+  },
+  [Chains.SEP]: {
+    ...sepolia,
+    name: 'Sepolia',
+    chainId: Chains.SEP,
+    logoURI: imageLinks.network(sepolia.id),
+    alt: 'two pyramids joined on one side',
+    rpcUrls: {
+      default: {
+        http: ['https://ethereum-sepolia-rpc.publicnode.com'],
+      },
+    },
+  },
+  [Chains.V4PLS]: {
+    ...pulsechainV4,
+    name: 'Pulsechain V4',
+    chainId: Chains.V4PLS,
+    logoURI: imageLinks.network(pulsechainV4.id),
+    alt: 'a pink blue and purple hexagon with an ekg line running horizontally',
+    rpcUrls: {
+      default: {
+        http: ['https://rpc-testnet-pulsechain.g4mm4.io'],
+      },
+    },
+    contracts: {
+      ...pulsechainV4.contracts,
+      ensRegistry: {
+        address: '0xaDB38309aF7F85034FDC35bd6E6B45d1216CfB56',
+      },
+      ensUniversalResolver: {
+        address: '0xDDFde3fA938dE0cdff82645579d03Ed750DE2e69',
+      },
+    },
+  },
+} as ChainsMetadata

package/src/config.ts

@@ -0,0 +1,369 @@
+import { 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";
+
+/**
+ * Add here your chain id as hex, be sure to add your chain in the chainsMetadata object too
+ */
+export enum Chains {
+  PLS = '0x171',
+  ETH = '0x1',
+  BNB = '0x38',
+  // testnets
+  SEP = '0xaa36a7',
+  V4PLS = '0x3af',
+  // TBNB = '0x61',
+}
+
+export type ChainKey = keyof typeof Chains
+
+export const chainIdToKey = new Map<Chains, ChainKey>(
+  Object.entries(Chains).map(([key, chain]) => [chain, key] as [Chains, ChainKey]),
+)
+
+export const toChain = (chainId: number | string) => `0x${Number(chainId).toString(16)}` as Chains
+
+export const toChainKey = (chainId: number | string) => chainIdToKey.get(toChain(chainId))
+
+export enum Provider {
+  PULSECHAIN = 'pulsechain',
+  TOKENSEX = 'tokensex',
+}
+
+export const nativeAssetOut = {
+  [Chains.ETH]: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+  [Chains.BNB]: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
+  [Chains.PLS]: '0xA1077a294dDE1B09bB078844df40758a5D0f9a27',
+  [Chains.SEP]: '0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9',
+  [Chains.V4PLS]: '0x70499adEBB11Efd915E3b69E700c331778628707',
+} as Record<Chains, Hex>
+
+export const uniV2Routers = {
+  [Chains.PLS]: [
+    '0x98bf93ebf5c380C0e6Ae8e192A7e2AE08edAcc02',
+    '0x165C3410fC91EF562C50559f7d2289fEbed552d9',
+  ],
+  [Chains.ETH]: ['0x7a250d5630b4cf539739df2c5dacb4c659f2488d'],
+  [Chains.BNB]: ['0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F'],
+  [Chains.SEP]: ['0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3'],
+  [Chains.V4PLS]: [
+    '0xDaE9dd3d1A52CfCe9d5F2fAC7fDe164D500E50f7',
+    '0x636f6407B90661b73b1C0F7e24F4C79f624d0738',
+  ],
+} as Record<Chains, Hex[]>
+
+export const nativeTokenSymbol = {
+  [Chains.PLS]: 'PLS',
+  [Chains.V4PLS]: 'V4PLS',
+  [Chains.ETH]: 'ETH',
+  [Chains.SEP]: 'sepETH',
+  [Chains.BNB]: 'BNB',
+} as Record<Chains, string>
+
+export const nativeTokenName = {
+  [Chains.PLS]: 'Pulse',
+  [Chains.V4PLS]: 'V4 Pulse',
+  [Chains.ETH]: 'Ether',
+  [Chains.SEP]: 'Sepolia Ether',
+  [Chains.BNB]: 'BNB',
+} as Record<Chains, string>
+
+export type Pathway = {
+  from: Hex
+  to: Hex
+  destinationRouter: Hex | null
+  nativeRouter: Hex
+  validator: Hex
+  defaultAssetIn: Token
+  usesExtraParam: boolean
+  feeManager: 'from' | 'to'
+  toHome: boolean
+  requiresDelivery: boolean
+}
+
+export type DeepPathwayConfig = Record<
+  Provider,
+  Partial<Record<Chains, Partial<Record<Chains, Pathway>>>>
+>
+
+export const pathways = {
+  [Provider.PULSECHAIN]: {
+    [Chains.PLS]: {
+      [Chains.ETH]: {
+        from: '0x4fD0aaa7506f3d9cB8274bdB946Ec42A1b8751Ef',
+        to: '0x1715a3E4A142d8b698131108995174F37aEBA10D',
+        destinationRouter: '0x2Ed02372C3efF1F239B22a901ceA8Cf6fbf82d8d',
+        nativeRouter: '0x612Da68aA7BcA625dD2F27f252cddB573674991A',
+        validator: '0x5ECfE77502317F3677f23C3b8Ab17929ACE3D74E',
+        usesExtraParam: false,
+        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],
+              },
+            },
+          },
+        },
+      },
+    },
+    [Chains.ETH]: {
+      [Chains.PLS]: {
+        from: '0x1715a3E4A142d8b698131108995174F37aEBA10D',
+        to: '0x4fD0aaa7506f3d9cB8274bdB946Ec42A1b8751Ef',
+        nativeRouter: '0x2Ed02372C3efF1F239B22a901ceA8Cf6fbf82d8d',
+        destinationRouter: '0x612Da68aA7BcA625dD2F27f252cddB573674991A',
+        validator: '0x5ECfE77502317F3677f23C3b8Ab17929ACE3D74E',
+        feeManager: 'to',
+        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',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  [Provider.TOKENSEX]: {
+    [Chains.PLS]: {
+      [Chains.BNB]: {
+        from: '0xf1DFc63e10fF01b8c3d307529b47AefaD2154C0e',
+        to: '0xb4005881e81a6ecd2c1f75d58e8e41f28d59c6b1',
+        destinationRouter: '0x9c50EfD36dF2DBD310fBC981d6D8478cF3484B85',
+        nativeRouter: '0xB80B80EBB375BD83a9d6c0761b197d16a8670f81',
+        validator: '0xc3c3d5d3ba946a2eb3906878ebe187418b0b524e',
+        feeManager: 'from',
+        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],
+              },
+            },
+          },
+        },
+      },
+    },
+    [Chains.BNB]: {
+      [Chains.PLS]: {
+        from: '0xb4005881e81a6ecd2c1f75d58e8e41f28d59c6b1',
+        to: '0xf1DFc63e10fF01b8c3d307529b47AefaD2154C0e',
+        nativeRouter: '0x9c50EfD36dF2DBD310fBC981d6D8478cF3484B85',
+        destinationRouter: '0xB80B80EBB375BD83a9d6c0761b197d16a8670f81',
+        validator: '0xc3c3d5d3ba946a2eb3906878ebe187418b0b524e',
+        feeManager: 'to',
+        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',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+} as DeepPathwayConfig
+
+export const testnetPathways = {
+  [Provider.TOKENSEX]: {
+    // plsv4 to bnb home omnibridge: 0xfd0c07C376D27EA0E9fA64Ac5D2481439e36CF9C
+    // [Chains.BNB]: {
+    //   [Chains.V4PLS]: {
+    //     from: '0xDDf1b0CD7fb7AAA310c703C17995c6671F9DC806',
+    //     to: '0xfd0c07C376D27EA0E9fA64Ac5D2481439e36CF9C',
+    //     usesExtraParam: false,
+    //     requiresDelivery: false,
+    //     toHome: true,
+    //     feeManager: 'to',
+    //     defaultAssetIn: {
+    //       chainId: 56,
+    //       address: nativeAssetOut[Chains.TBNB],
+    //     },
+    //   },
+    // },
+    // [Chains.V4PLS]: {
+    //   [Chains.BNB]: {
+    //     from: '0xfd0c07C376D27EA0E9fA64Ac5D2481439e36CF9C',
+    //     to: '0xDDf1b0CD7fb7AAA310c703C17995c6671F9DC806',
+    //   },
+    // },
+  },
+  [Provider.PULSECHAIN]: {
+    [Chains.V4PLS]: {
+      [Chains.SEP]: {
+        from: '0x6B08a50865aDeCe6e3869D9AfbB316d0a0436B6c',
+        to: '0x546e37DAA15cdb82fd1a717E5dEEa4AF08D4349A',
+        nativeRouter: '0xCA1BDc038909038C4B3cbab0EA0ec3cC2839F106',
+        destinationRouter: '0xCb4057d7DA4CE521B93b71186DfE11f9FBC3e3b1',
+        validator: '0xDcd4D88552c86114b2ca029F7F8d4e1a7951d051',
+        usesExtraParam: false,
+        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],
+              },
+            },
+          },
+        },
+      },
+    },
+    [Chains.SEP]: {
+      [Chains.V4PLS]: {
+        from: '0x546e37DAA15cdb82fd1a717E5dEEa4AF08D4349A',
+        to: '0x6B08a50865aDeCe6e3869D9AfbB316d0a0436B6c',
+        nativeRouter: '0xCb4057d7DA4CE521B93b71186DfE11f9FBC3e3b1',
+        destinationRouter: '0xCA1BDc038909038C4B3cbab0EA0ec3cC2839F106',
+        validator: '0xDcd4D88552c86114b2ca029F7F8d4e1a7951d051',
+        usesExtraParam: false,
+        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',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+} as DeepPathwayConfig
+
+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],
+] as BridgeKey[]
+
+const testnetBridgeKeys = [
+  [Provider.PULSECHAIN, Chains.SEP, Chains.V4PLS],
+  [Provider.PULSECHAIN, Chains.V4PLS, Chains.SEP],
+] as BridgeKey[]
+
+export const validBridgeKeys = (isProd: boolean) => [
+  ...mainnetBridgeKeys,
+  ...(isProd ? [] : testnetBridgeKeys),
+]
+
+export const inferBridgeKey = ({
+  currentKey,
+  provider,
+  fromChain,
+  toChain,
+}: {
+  currentKey: BridgeKey
+  provider: Provider
+  fromChain?: Chains
+  toChain?: Chains
+}) => {
+  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] as Chains)
+  const currentToChainIsValid = !!_.get(pathways, [provider, nextFromChain, to])
+  const nextToChain = currentToChainIsValid
+    ? to
+    : (Object.keys(pathways[provider]![nextFromChain]!)[0] as Chains)
+  return [provider, nextFromChain, nextToChain] as BridgeKey
+}
+
+export const pathway = (bridgeKey: BridgeKey | null, isProd: boolean) => {
+  if (!bridgeKey) return
+  return _.get(pathways, bridgeKey) || (!isProd ? _.get(testnetPathways, bridgeKey) : undefined)
+}
+
+export const defaultAssetIn = ($bridgeKey: BridgeKey | null, isProd: boolean) => {
+  const conf = pathway($bridgeKey, isProd)
+  const defaultAssetIn = _.get(conf, ['defaultAssetIn']) as Token | undefined
+  return defaultAssetIn
+}
+
+export const isNative = (asset: Token | TokenOut | null, bridgeKey: BridgeKey | null) => {
+  if (!bridgeKey || !asset) {
+    return false
+  }
+  return (
+    (asset.address === zeroAddress ||
+      nativeAssetOut[toChain(asset.chainId)]?.toLowerCase() === asset.address?.toLowerCase()) &&
+    !asset.name.includes(' from Pulsechain')
+  )
+}
+
+export const isUnwrappable = (
+  asset: Pick<Token, 'extensions'> | null,
+  bridgeKey: BridgeKey | null,
+) => {
+  if (!bridgeKey || !asset) {
+    return false
+  }
+  const [, , toChain] = bridgeKey
+  return nativeAssetOut[toChain] === asset.extensions?.bridgeInfo?.[Number(toChain)]?.tokenAddress
+}
+
+export const canChangeUnwrap = (bridgeKey: BridgeKey, assetIn: Token | null) =>
+  !!assetIn && isUnwrappable(assetIn, bridgeKey)

package/src/fee-type.ts

@@ -0,0 +1,12 @@
+
+export enum FeeType {
+  PERCENT = '%',
+  GAS_TIP = 'gas+%',
+  FIXED = 'fixed',
+}
+
+export type FeeTypeKeys = keyof typeof FeeType
+
+export const feeTypeValToKeyMap = new Map<FeeType, FeeTypeKeys>(
+  (Object.keys(FeeType) as FeeTypeKeys[]).map((key) => [FeeType[key], key]),
+)

package/src/image-links.ts

@@ -0,0 +1,32 @@
+import { getAddress } from 'viem'
+
+let imageRoot = 'https://gib.show'
+
+export const setImageRoot = (root: string) => {
+  imageRoot = root
+}
+
+export const getImageRoot = () => imageRoot
+
+interface MinimalTokenInfo {
+  chainId: number
+  address: string
+  logoURI?: string | null
+}
+
+export const list = (path: string) => {
+  return `${imageRoot}/list${path}`
+}
+
+export const network = (chainId: number) => {
+  if (!chainId) {
+    console.trace('network image')
+  }
+  return `${imageRoot}/image/${Number(chainId)}`
+}
+
+export const image = (t: MinimalTokenInfo) =>
+  t.logoURI || `${network(t.chainId)}/${getAddress(t.address)}`
+
+export const images = (sources: string[]) =>
+  `${imageRoot}/image/?${sources.map((s) => `i=${s}`).join('&')}`

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './chain-info.js'
+export * from './abis.js'
+export * from './config.js'
+export * from './chains.js'
+export * from './types.js'
+export * from './image-links.js'

package/src/types.ts

@@ -0,0 +1,39 @@
+import type { Hex, Chain } from 'viem'
+import type { Chains, Provider } from './config.js'
+
+export type PerNetworkBridgeLink = {
+  tokenAddress: Hex
+}
+export type Extensions = {
+  wrapped?: { address: Hex }
+  bridgeInfo?: Record<number, PerNetworkBridgeLink>
+}
+
+export type TokenMetadata = {
+  name: string
+  symbol: string
+  decimals: number
+}
+
+export type Token = TokenMetadata & {
+  address: string
+  chainId: number
+  logoURI: string | null
+  extensions?: Extensions
+}
+
+export type TokenOut = Omit<Token, 'address'> & { address: string | null }
+
+export type TokenList = {
+  tokens: Token[]
+}
+
+export type BridgeKey = [Provider, Chains, Chains]
+
+export type VisualChain = Chain & {
+  chainId: Chains
+  logoURI: string
+  alt: string
+}
+
+export type ChainsMetadata = Record<Chains, VisualChain>

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "useDefineForClassFields": true,
+    "module": "NodeNext",
+    "composite": true,
+    "allowJs": true,
+    "outDir": "./dist",
+    "strict": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "moduleDetection": "force",
+    "moduleResolution": "nodenext"
+  },
+  "include": ["src/**/*.ts", "src/**/*.js"]
+}