@gibs/bridge-sdk 1.9.1 → 1.12.0

package/src/chain-info.ts

@@ -1,24 +1,38 @@
-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"
+import { multicallRead } from '@gibs/common/multicall';
+import _ from 'lodash';
+import {
+  encodeFunctionData,
+  getContract,
+  type Hex,
+  multicall3Abi,
+  type PublicClient,
+  zeroAddress,
+} from 'viem';
+import * as abis from './abis.js';
+import { chainsMetadata } from './chains.js';
+import {
+  type Chains,
+  nativeAssetOut,
+  type Pathway,
+  pathway,
+  toChain,
+  uniV2Routers,
+} from './config.js';
+import type { BridgeKey, Token } from './types.js';
 
 export type TokenBridgeInfo = {
-  originationChainId: Chains
-  assetInAddress: Hex
-  assetOutAddress: Hex | null
+  originationChainId: Chains;
+  assetInAddress: Hex;
+  assetOutAddress: Hex | null;
   toForeign?: {
-    home: Hex
-    foreign: Hex | null
-  }
+    home: Hex;
+    foreign: Hex | null;
+  };
   toHome?: {
-    home: Hex | null
-    foreign: Hex
-  }
-}
+    home: Hex | null;
+    foreign: Hex;
+  };
+};
 
 /**
  * Returns the bridged token address and native token address
@@ -29,7 +43,17 @@ export type TokenBridgeInfo = {
  * @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 }) => {
+  async ({
+    chainId,
+    target,
+    address,
+    client,
+  }: {
+    chainId: number;
+    target: Hex;
+    address: Hex;
+    client: PublicClient;
+  }) => {
     return multicallRead<[Hex, Hex]>({
       client,
       chain: chainsMetadata[toChain(chainId)],
@@ -39,10 +63,10 @@ export const links = _.memoize(
         { functionName: 'bridgedTokenAddress', args: [address] },
         { functionName: 'nativeTokenAddress', args: [address] },
       ],
-    })
+    });
   },
   ({ 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
@@ -60,20 +84,20 @@ export const tokenBridgeInfo = async ({
   fromChainClient,
   toChainClient,
 }: {
-  bridgeKey: BridgeKey,
-  assetIn: Token | null,
-  isProd: boolean,
-  fromChainClient: PublicClient,
-  toChainClient: PublicClient,
+  bridgeKey: BridgeKey;
+  assetIn: Token | null;
+  isProd: boolean;
+  fromChainClient: PublicClient;
+  toChainClient: PublicClient;
 }): Promise<null | TokenBridgeInfo> => {
-  const bridgePathway = pathway(bridgeKey, isProd, assetIn?.address as Hex | null)
+  const bridgePathway = pathway(bridgeKey, isProd, assetIn?.address as Hex | null);
   if (!assetIn || !bridgePathway) {
-    console.log('missing asset in or bridge pathway')
-    return null
+    console.log('missing asset in or bridge pathway');
+    return null;
   }
-  const [, fromChain, toChain] = bridgeKey
+  const [, fromChain, toChain] = bridgeKey;
   const assetInAddress =
-    assetIn.address === zeroAddress ? nativeAssetOut[fromChain] : assetIn.address
+    assetIn.address === zeroAddress ? nativeAssetOut[fromChain] : assetIn.address;
   const [toMappings, fromMappings] = await Promise.all([
     links({
       chainId: Number(toChain),
@@ -87,8 +111,8 @@ export const tokenBridgeInfo = async ({
       address: assetInAddress as Hex,
       client: fromChainClient,
     }),
-  ])
-  const [toBridged, toNative] = toMappings
+  ]);
+  const [toBridged, toNative] = toMappings;
   if (toBridged !== zeroAddress) {
     return {
       originationChainId: fromChain,
@@ -98,7 +122,7 @@ export const tokenBridgeInfo = async ({
         home: toBridged,
         foreign: assetInAddress as Hex,
       },
-    }
+    };
   }
   if (toNative !== zeroAddress) {
     return {
@@ -109,9 +133,9 @@ export const tokenBridgeInfo = async ({
         home: toNative,
         foreign: assetInAddress as Hex,
       },
-    }
+    };
   }
-  const [fromBridged, fromNative] = fromMappings
+  const [fromBridged, fromNative] = fromMappings;
   if (fromNative !== zeroAddress) {
     return {
       originationChainId: toChain,
@@ -121,7 +145,7 @@ export const tokenBridgeInfo = async ({
         home: assetInAddress as Hex,
         foreign: fromNative,
       },
-    }
+    };
   }
   if (fromBridged !== zeroAddress) {
     return {
@@ -132,7 +156,7 @@ export const tokenBridgeInfo = async ({
         foreign: fromBridged,
         home: assetInAddress as Hex,
       },
-    }
+    };
   }
   // the token has not been bridged yet
   return {
@@ -141,21 +165,21 @@ export const tokenBridgeInfo = async ({
     assetOutAddress: null,
     ...(bridgePathway.toHome
       ? {
-        toHome: {
-          foreign: assetInAddress as Hex,
-          home: null,
-        },
-      }
+          toHome: {
+            foreign: assetInAddress as Hex,
+            home: null,
+          },
+        }
       : {
-        toForeign: {
-          foreign: null,
-          home: assetInAddress as Hex,
-        },
-      }),
-  }
-}
+          toForeign: {
+            foreign: null,
+            home: assetInAddress as Hex,
+          },
+        }),
+  };
+};
 /** The result of reading the amount out from a router */
-export type FetchResult = bigint[] | 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
@@ -173,11 +197,11 @@ const readAmountOut = ({
   client,
   uniV2Router,
 }: {
-  amountIn: bigint,
-  chain: Chains,
-  paths: Hex[][],
-  client: PublicClient,
-  uniV2Router?: Hex,
+  amountIn: bigint;
+  chain: Chains;
+  paths: Hex[][];
+  client: PublicClient;
+  uniV2Router?: Hex;
 }): Promise<FetchResult[]> => {
   return multicallRead<FetchResult[]>({
     chain: chainsMetadata[chain],
@@ -192,8 +216,8 @@ const readAmountOut = ({
         target,
       })),
     ),
-  })
-}
+  });
+};
 
 /**
  * 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
@@ -217,15 +241,15 @@ export const fetchPriceCorrective = ({
   amountIn,
   isProd,
 }: {
-  bridgeKey: BridgeKey,
-  bridgeKeyPartner: BridgeKey,
-  measurementToken: Hex,
-  assetOut: Token,
-  fromChainClient: PublicClient,
-  toChainClient: PublicClient,
-  assetLink: TokenBridgeInfo,
-  amountIn: bigint,
-  isProd: boolean,
+  bridgeKey: BridgeKey;
+  bridgeKeyPartner: BridgeKey;
+  measurementToken: Hex;
+  assetOut: Token;
+  fromChainClient: PublicClient;
+  toChainClient: PublicClient;
+  assetLink: TokenBridgeInfo;
+  amountIn: bigint;
+  isProd: boolean;
 }) => {
   return {
     getPaymentToken: async () => {
@@ -241,7 +265,7 @@ export const fetchPriceCorrective = ({
         // tokens going the opposite direction to the provided bridge key
         fromChainClient: toChainClient,
         toChainClient: fromChainClient,
-      })
+      });
     },
     getSwapResults: async ({
       paymentTokenResult,
@@ -249,10 +273,10 @@ export const fetchPriceCorrective = ({
       uniV2Router,
       client,
     }: {
-      paymentTokenResult: TokenBridgeInfo
-      chain: Chains
-      client: PublicClient
-      uniV2Router?: Hex
+      paymentTokenResult: TokenBridgeInfo;
+      chain: Chains;
+      client: PublicClient;
+      uniV2Router?: Hex;
     }) => {
       return await Promise.all([
         readAmountOut({
@@ -276,47 +300,47 @@ export const fetchPriceCorrective = ({
           // 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
+      results: [FetchResult[], ...[FetchResult[]]];
+      oneToken: bigint;
     }) => {
       const outputFromRouter = (result: FetchResult) => {
         if (_.isString(result)) {
           // the router failed to return a result
-          return 0n
+          return 0n;
         }
         if (!result.length) {
           // the router returned an empty result
-          return 0n
+          return 0n;
         }
         // the last element is the amount of the output token
-        const last = result[result.length - 1]!
-        return (last * oneToken) / amountIn
-      }
+        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)
-      }
+        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 [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
-    }
-  }
-}
+          : inputToken;
+      return result;
+    },
+  };
+};
 
 /**
  * Fetch the minimum bridge amount in for the given asset in, pathway, from public client, and to public client
@@ -332,51 +356,58 @@ export const minBridgeAmountIn = async ({
   fromPublicClient,
   toPublicClient,
 }: {
-  assetIn: Token,
-  pathway: Pathway,
-  fromPublicClient: PublicClient,
-  toPublicClient: PublicClient,
+  assetIn: Token;
+  pathway: Pathway;
+  fromPublicClient: PublicClient;
+  toPublicClient: PublicClient;
 }) => {
-  const publicClient = pathway?.feeManager === 'from' ? fromPublicClient : toPublicClient
+  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: string, symbol: string, chainId: number } | null, unwrap = false) => {
-  return asset ? (unwrap && asset.address === nativeAssetOut[toChain(asset.chainId)] ? asset.symbol.slice(1) : asset.symbol) : ''
-}
+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
-}
+  pathway: Pathway;
+  fromChainClient: PublicClient;
+  toChainClient: PublicClient;
+};
 
 /** The fee configuration for a given pathway */
 export type PathwayExtendableConfig = {
-  feeManager: Hex
-  feeH2F: bigint
-  feeF2H: bigint
-}
+  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)]
+  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
-}
+  }) as any;
+};
 /**
  * Load the bridge fees for the given pathway, from chain client, and to chain client
  * @param pathway - the pathway
@@ -384,10 +415,13 @@ export const chainMulticall = (client: PublicClient) => {
  * @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)
-    : chainMulticall(toChainClient)
+export const loadBridgeFees = async ({
+  pathway,
+  fromChainClient,
+  toChainClient,
+}: InputLoadFeeFor) => {
+  const multicall =
+    pathway.feeManager === 'from' ? chainMulticall(fromChainClient) : chainMulticall(toChainClient);
 
   const [feeManagerResponse] = await multicall.read.aggregate3([
     [
@@ -400,19 +434,19 @@ export const loadBridgeFees = async ({ pathway, fromChainClient, toChainClient }
         }),
       },
     ],
-  ])
-  const { success, returnData } = feeManagerResponse
+  ]);
+  const { success, returnData } = feeManagerResponse;
   if (!success) {
-    throw new Error('unable to load feeManager')
+    throw new Error('unable to load feeManager');
   }
   if (returnData === '0x') {
-    throw new Error('unable to read feeManager')
+    throw new Error('unable to read feeManager');
   }
   const feeManager = (
     returnData.startsWith('0x000000000000000000000000')
       ? `0x${returnData.slice(26)}`
       : `0x${returnData.slice(-40)}`
-  ) as Hex
+  ) as Hex;
   const [keyH2F, keyF2H] = await multicall.read.aggregate3([
     [
       {
@@ -432,7 +466,7 @@ export const loadBridgeFees = async ({ pathway, fromChainClient, toChainClient }
         }),
       },
     ],
-  ])
+  ]);
   const [feeH2F, feeF2H] = await multicall.read.aggregate3([
     [
       {
@@ -454,11 +488,11 @@ export const loadBridgeFees = async ({ pathway, fromChainClient, toChainClient }
         }),
       },
     ],
-  ])
+  ]);
   const setting = {
     feeManager,
     feeH2F: BigInt(feeH2F.returnData),
     feeF2H: BigInt(feeF2H.returnData),
-  } as PathwayExtendableConfig
-  return setting
-}
+  } as PathwayExtendableConfig;
+  return setting;
+};

package/src/chains.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest';
+import { chainsMetadata } from './chains';
+import { Chains } from './config';
+
+describe('chains', () => {
+  describe('chainsMetadata', () => {
+    it('should have metadata for all main chains', () => {
+      expect(chainsMetadata[Chains.PLS]).toBeDefined();
+      expect(chainsMetadata[Chains.ETH]).toBeDefined();
+      expect(chainsMetadata[Chains.BNB]).toBeDefined();
+    });
+
+    it('should have metadata for testnet chains', () => {
+      expect(chainsMetadata[Chains.SEP]).toBeDefined();
+      expect(chainsMetadata[Chains.V4PLS]).toBeDefined();
+    });
+
+    it('should have required fields for each chain', () => {
+      Object.entries(chainsMetadata).forEach(([chainKey, metadata]) => {
+        expect(metadata).toHaveProperty('chainId');
+        expect(metadata).toHaveProperty('name');
+        expect(metadata).toHaveProperty('logoURI');
+        expect(metadata).toHaveProperty('alt');
+        expect(metadata).toHaveProperty('rpcUrls');
+        expect(metadata.rpcUrls).toHaveProperty('default');
+        expect(metadata.rpcUrls.default).toHaveProperty('http');
+        expect(Array.isArray(metadata.rpcUrls.default.http)).toBe(true);
+        expect(metadata.rpcUrls.default.http.length).toBeGreaterThan(0);
+      });
+    });
+
+    it('should have valid RPC URLs for each chain', () => {
+      Object.values(chainsMetadata).forEach((metadata) => {
+        metadata.rpcUrls.default.http.forEach((url) => {
+          expect(url).toMatch(/^https?:\/\//);
+          expect(url).not.toContain(' ');
+        });
+      });
+    });
+
+    it('should have valid logoURIs', () => {
+      Object.values(chainsMetadata).forEach((metadata) => {
+        expect(metadata.logoURI).toMatch(/^https?:\/\//);
+      });
+    });
+
+    it('should have alt text for accessibility', () => {
+      Object.values(chainsMetadata).forEach((metadata) => {
+        expect(typeof metadata.alt).toBe('string');
+        expect(metadata.alt.length).toBeGreaterThan(0);
+      });
+    });
+
+    it('should have matching chainId in metadata', () => {
+      Object.entries(chainsMetadata).forEach(([chainKey, metadata]) => {
+        expect(metadata.chainId).toBe(chainKey);
+      });
+    });
+
+    it('should have ENS contracts for Pulsechain chains', () => {
+      // Mainnet PLS should have ENS
+      expect(chainsMetadata[Chains.PLS].contracts?.ensRegistry).toBeDefined();
+      expect(chainsMetadata[Chains.PLS].contracts?.ensUniversalResolver).toBeDefined();
+      expect(chainsMetadata[Chains.PLS].contracts?.ensRegistry?.address).toMatch(
+        /^0x[a-fA-F0-9]{40}$/,
+      );
+      expect(chainsMetadata[Chains.PLS].contracts?.ensUniversalResolver?.address).toMatch(
+        /^0x[a-fA-F0-9]{40}$/,
+      );
+
+      // Testnet V4PLS should have ENS
+      expect(chainsMetadata[Chains.V4PLS].contracts?.ensRegistry).toBeDefined();
+      expect(chainsMetadata[Chains.V4PLS].contracts?.ensUniversalResolver).toBeDefined();
+    });
+
+    it('should have multicall3 contracts for all chains', () => {
+      Object.values(chainsMetadata).forEach((metadata) => {
+        expect(metadata.contracts?.multicall3).toBeDefined();
+        expect(metadata.contracts?.multicall3?.address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+      });
+    });
+
+    it('should have unique RPC URLs per chain', () => {
+      const rpcUrls = Object.values(chainsMetadata).map((m) => m.rpcUrls.default.http[0]);
+      const uniqueUrls = new Set(rpcUrls);
+      expect(uniqueUrls.size).toBe(rpcUrls.length);
+    });
+
+    describe('specific chain validation', () => {
+      it('should have correct Pulsechain mainnet config', () => {
+        const pls = chainsMetadata[Chains.PLS];
+        expect(pls.name).toContain('Pulse');
+        expect(pls.chainId).toBe(Chains.PLS);
+        expect(pls.rpcUrls.default.http[0]).toContain('pulsechain');
+      });
+
+      it('should have correct Ethereum mainnet config', () => {
+        const eth = chainsMetadata[Chains.ETH];
+        expect(eth.name).toContain('Ethereum');
+        expect(eth.chainId).toBe(Chains.ETH);
+      });
+
+      it('should have correct BSC config', () => {
+        const bnb = chainsMetadata[Chains.BNB];
+        expect(bnb.name).toContain('Binance');
+        expect(bnb.chainId).toBe(Chains.BNB);
+        expect(bnb.rpcUrls.default.http[0]).toContain('bsc');
+      });
+
+      it('should have correct Sepolia testnet config', () => {
+        const sep = chainsMetadata[Chains.SEP];
+        expect(sep.name).toBe('Sepolia');
+        expect(sep.chainId).toBe(Chains.SEP);
+      });
+
+      it('should have correct Pulsechain V4 testnet config', () => {
+        const v4pls = chainsMetadata[Chains.V4PLS];
+        expect(v4pls.name).toContain('Pulsechain V4');
+        expect(v4pls.chainId).toBe(Chains.V4PLS);
+      });
+    });
+  });
+});

package/src/chains.ts

@@ -1,7 +1,7 @@
-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'
+import { Chains } from '@gibs/bridge-sdk/config';
+import * as imageLinks from '@gibs/bridge-sdk/image-links';
+import type { ChainsMetadata } from '@gibs/bridge-sdk/types';
+import { bsc, mainnet, pulsechain, pulsechainV4, sepolia } from '@reown/appkit/networks';
 
 /**
  * all of the chains that are enabled in this dapp
@@ -85,4 +85,4 @@ export const chainsMetadata = {
       },
     },
   },
-} as ChainsMetadata
+} as ChainsMetadata;