@gibs/bridge-sdk 1.12.0 → 1.13.1

package/src/chain-info.ts

@@ -1,498 +0,0 @@
-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;
-  toForeign?: {
-    home: Hex;
-    foreign: Hex | null;
-  };
-  toHome?: {
-    home: Hex | null;
-    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 const links = _.memoize(
-  async ({
-    chainId,
-    target,
-    address,
-    client,
-  }: {
-    chainId: number;
-    target: Hex;
-    address: Hex;
-    client: PublicClient;
-  }) => {
-    return multicallRead<[Hex, 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(),
-);
-
-/**
- * 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,
-}: {
-  bridgeKey: BridgeKey;
-  assetIn: Token | null;
-  isProd: boolean;
-  fromChainClient: PublicClient;
-  toChainClient: PublicClient;
-}): Promise<null | TokenBridgeInfo> => {
-  const bridgePathway = pathway(bridgeKey, isProd, assetIn?.address as Hex | null);
-  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;
-  if (toBridged !== zeroAddress) {
-    return {
-      originationChainId: fromChain,
-      assetInAddress: assetInAddress as Hex,
-      assetOutAddress: toBridged,
-      toHome: {
-        home: toBridged,
-        foreign: assetInAddress as Hex,
-      },
-    };
-  }
-  if (toNative !== zeroAddress) {
-    return {
-      originationChainId: toChain,
-      assetInAddress: assetInAddress as Hex,
-      assetOutAddress: toNative,
-      toForeign: {
-        home: toNative,
-        foreign: assetInAddress as Hex,
-      },
-    };
-  }
-  const [fromBridged, fromNative] = fromMappings;
-  if (fromNative !== zeroAddress) {
-    return {
-      originationChainId: toChain,
-      assetInAddress: assetInAddress as Hex,
-      assetOutAddress: fromNative,
-      toHome: {
-        home: assetInAddress as Hex,
-        foreign: fromNative,
-      },
-    };
-  }
-  if (fromBridged !== zeroAddress) {
-    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,
-          },
-        }),
-  };
-};
-/** 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
- * @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,
-      })),
-    ),
-  });
-};
-
-/**
- * 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,
-}: {
-  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;
-    },
-  };
-};
-
-/**
- * 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,
-}: {
-  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: 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)];
-  return getContract({
-    abi: multicall3Abi,
-    client: client as any,
-    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) : 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.test.ts

@@ -1,123 +0,0 @@
-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,88 +0,0 @@
-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
- * 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-rpc.publicnode.com'],
-      },
-    },
-  },
-  [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;